class GameManager: def __init__(self, size = 4): # init some variables self.grid = Grid(size) self.possibleNewTileValue = [2, 4] self.possibility = defaultPossibility self.initTiles = defaultInitialTiles self.computerAI = None self.playerAI = None self.displayer = None self.over = False def setComputerAI(self, compAI): self.computerAI = compAI def setPlayerAI(self, playerAI): self.playerAI = playerAI def setDisplayer(self, displayer): self.displayer = displayer def updateAlarm(self, curTime): # 0.1 sec for the running time outside the AI module if curTime - self.lastTime > timeLimit + 0.1: self.over = True else: self.lastTime = curTime def start(self): #insert 2 random tiles for i in xrange(self.initTiles): self.insertRandonTile() # show the initial grid state self.displayer.display(self.grid) #player plays first turn = PLAYER_TURN maxTile = 0 # set init alarm self.lastTime = time.clock()#time.time() # check game over conditions while not self.isGameOver() and not self.over: # make a copy make sure AI cannot change the real grid and cheat gridCopy = self.grid.clone() move = None if turn == PLAYER_TURN: print "Player's Turn" move = self.playerAI.getMove(gridCopy) print actionDic[move] #validate move if move != None and move >= 0 and move < 4: if self.grid.canMove([move]): self.grid.move(move) #update maxTile maxTile = self.grid.getMaxTile() else: print "Invalid PlayerAI Move" self.over = True else: print "Invalid PlayerAI Move - 1" self.over = True else: # computer turn print "Computer's turn" move = self.computerAI.getMove(gridCopy) # move should be (x, y) format #validate move if self.grid.canInsert(move): self.grid.setCellValue(move, self.getNewTileValue()) else: print "Invalid Computer AI Move" self.over = True if not self.over: self.displayer.display(self.grid) # once you exceeds the time limit, previous action will be your last action self.updateAlarm(time.clock()) #time.time() turn = 1 - turn print maxTile def isGameOver(self): return not self.grid.canMove() def getNewTileValue(self): if randint(0,99) < 100 * self.possibility: return self.possibleNewTileValue[0] else: return self.possibleNewTileValue[1] def insertRandonTile(self): tileValue = self.getNewTileValue() cells = self.grid.getAvailableCells() cell = cells[randint(0, len(cells) - 1)] self.grid.setCellValue(cell, tileValue)
class GameManager: def __init__(self, size = 4): self.grid = Grid(size) self.possibleNewTiles = [2, 4] self.probability = defaultProbability self.initTiles = defaultInitialTiles self.computerAI = None self.playerAI = None self.displayer = None self.over = False def setComputerAI(self, computerAI): self.computerAI = computerAI def setPlayerAI(self, playerAI): self.playerAI = playerAI def setDisplayer(self, displayer): self.displayer = displayer def updateAlarm(self, currTime): # print "time elapsed = ", currTime - self.prevTime # st = raw_input() if currTime - self.prevTime > timeLimit + allowance: self.over = True else: while time.clock() - self.prevTime < timeLimit + allowance: pass self.prevTime = time.clock() def start(self): for i in xrange(self.initTiles): self.insertRandonTile() #self.displayer.display(self.grid) # Player AI Goes First turn = PLAYER_TURN maxTile = 0 self.prevTime = time.clock() while not self.isGameOver() and not self.over: # Copy to Ensure AI Cannot Change the Real Grid to Cheat gridCopy = self.grid.clone() move = None if turn == PLAYER_TURN: print "Player's Turn:", move = self.playerAI.getMove(gridCopy) print actionDic[move] # Validate Move if move != None and move >= 0 and move < 4: if self.grid.canMove([move]): self.grid.move(move) # Update maxTile maxTile = self.grid.getMaxTile() else: print "Invalid PlayerAI Move" self.over = True else: print "Invalid PlayerAI Move - 1" self.over = True else: print "Computer's turn:" move = self.computerAI.getMove(gridCopy) # Validate Move if move and self.grid.canInsert(move): self.grid.setCellValue(move, self.getNewTileValue()) else: print "Invalid Computer AI Move" self.over = True if not self.over: self.displayer.display(self.grid) # Exceeding the Time Allotted for Any Turn Terminates the Game self.updateAlarm(time.clock()) turn = 1 - turn print maxTile def isGameOver(self): return not self.grid.canMove() def getNewTileValue(self): if randint(0,99) < 100 * self.probability: return self.possibleNewTiles[0] else: return self.possibleNewTiles[1]; def insertRandonTile(self): tileValue = self.getNewTileValue() cells = self.grid.getAvailableCells() cell = cells[randint(0, len(cells) - 1)] self.grid.setCellValue(cell, tileValue)
class GameManager: def __init__(self, size = 4): #self.grid = Grid(size) self.possibleNewTiles = [2, 4] self.probability = defaultProbability self.initTiles = defaultInitialTiles self.computerAI = None self.playerAI = None self.over = False self.grid = Grid(size) def setComputerAI(self, computerAI): self.computerAI = computerAI def setPlayerAI(self, playerAI): self.playerAI = playerAI def updateAlarm(self, currTime): if currTime - self.prevTime > timeLimit + allowance: print 'Out of time' self.over = True else: while time.clock() - self.prevTime < timeLimit + allowance: pass self.prevTime = time.clock() def start(self): #for i in xrange(self.initTiles): # self.insertRandonTile() sel_board = randint(0, 4) if sel_board == 0: self.board1(self.grid) elif sel_board == 1: self.board2(self.grid) elif sel_board == 2: self.board3(self.grid) elif sel_board == 3: self.board4(self.grid) else: self.board5(self.grid) # Player AI Goes First turn = PLAYER_TURN maxTile = 0 self.prevTime = time.clock() while not self.isGameOver() and not self.over: # Copy to Ensure AI Cannot Change the Real Grid to Cheat gridCopy = self.grid.clone() move = None if turn == PLAYER_TURN: #print "Player's Turn:", move = self.playerAI.getMove(gridCopy) #print actionDic[move] # Validate Move if move != None and move >= 0 and move < 4: if self.grid.canMove([move]): self.grid.move(move) #self.playerAI.utility(self.grid, True) # Update maxTile maxTile = self.grid.getMaxTile() else: #print "Invalid PlayerAI Move" self.over = True else: #print "Invalid PlayerAI Move - 1" self.over = True else: #print "Computer's turn:" move = self.computerAI.getMove(gridCopy) # Validate Move if move and self.grid.canInsert(move): self.grid.setCellValue(move, self.getNewTileValue()) else: print "Invalid Computer AI Move" self.over = True # Exceeding the Time Allotted for Any Turn Terminates the Game self.updateAlarm(time.clock()) turn = 1 - turn def isGameOver(self): return not self.grid.canMove() def getNewTileValue(self): if randint(0,99) < 100 * self.probability: return self.possibleNewTiles[0] else: return self.possibleNewTiles[1]; def insertRandonTile(self): tileValue = self.getNewTileValue() cells = self.grid.getAvailableCells() cell = cells[randint(0, len(cells) - 1)] self.grid.setCellValue(cell, tileValue) # Have predefined board conditions to explore games from an advanced state. def board1(self, grid): grid.map = [[2, 0, 2, 0], [4, 32, 16, 4], [2, 4, 128, 16], [128, 1024, 4, 2]] def board2(self, grid): grid.map = [[8, 8, 4, 2], [1024, 16, 64, 4], [4, 128, 16, 2], [256, 4, 0, 0]] def board3(self, grid): grid.map = [[0, 0, 4, 32], [0, 0, 0, 512], [2, 4, 8, 64], [0, 8, 32, 16]] def board4(self, grid): grid.map = [[2, 2, 4, 0], [1024, 32, 16, 0], [64, 512, 8, 8], [8, 2, 4, 2]] def board5(self, grid): grid.map = [[32, 16, 8, 0], [1024, 8, 16, 0], [8, 0, 0, 0], [4, 2, 2, 0]]
class GameManager: def __init__(self, size=4, intelligentAgent=None, computerAI=None, displayer=None): self.grid = Grid(size) self.possibleNewTiles = [2, 4] self.probability = defaultProbability self.initTiles = defaultInitialTiles self.over = False # Initialize the AI players self.computerAI = computerAI or ComputerAI() self.intelligentAgent = intelligentAgent or IntelligentAgent() self.displayer = displayer or Displayer() def updateAlarm(self) -> None: """ Checks if move exceeded the time limit and updates the alarm """ if time.process_time() - self.prevTime > maxTime: self.over = True self.prevTime = time.process_time() def getNewTileValue(self) -> int: """ Returns 2 with probability 0.95 and 4 with 0.05 """ return self.possibleNewTiles[random.random() > self.probability] def insertRandomTiles(self, numTiles: int): """ Insert numTiles number of random tiles. For initialization """ for i in range(numTiles): tileValue = self.getNewTileValue() cells = self.grid.getAvailableCells() cell = random.choice(cells) if cells else None self.grid.setCellValue(cell, tileValue) def start(self) -> int: """ Main method that handles running the game of ai_2048 """ # Initialize the game self.insertRandomTiles(self.initTiles) self.displayer.display(self.grid) turn = PLAYER_TURN # Player AI Goes First self.prevTime = time.process_time() while self.grid.canMove() and not self.over: # Copy to Ensure AI Cannot Change the Real Grid to Cheat gridCopy = self.grid.clone() move = None if turn == PLAYER_TURN: print("Player's Turn: ", end="") move = self.intelligentAgent.getMove(gridCopy) print(actionDic[move]) # If move is valid, attempt to move the grid if move != None and 0 <= move < 4: if self.grid.canMove([move]): self.grid.move(move) else: print("Invalid intelligentAgent Move - Cannot move") self.over = True else: print("Invalid intelligentAgent Move - Invalid input") self.over = True else: print("Computer's turn: ") move = self.computerAI.getMove(gridCopy) # Validate Move if move and self.grid.canInsert(move): self.grid.setCellValue(move, self.getNewTileValue()) else: print("Invalid Computer AI Move") self.over = True # Comment out during heuristing optimizations to increase runtimes. # Printing slows down computation time. self.displayer.display(self.grid) # Exceeding the Time Allotted for Any Turn Terminates the Game self.updateAlarm() turn = 1 - turn return self.grid.getMaxTile()
class GameManager: """ Game Manager class Agrs: size: Puzzle grid side size ComputerAI: ComputerAI class object running the computer's moves PlayerAI: PlayerAI class object running the player's moves optimizing the implemented heuristics displayer: Displayer class object allowing the Game Manager to display the current state of the game currTime: time.clock object indicating the current time at each move Methods: setComputerAI(): Set ComputerAI object setPlayerAI(): Set PlayerAI object setDisplayer(): Set Displayer object updateAlarm(): Check time consumed in the decision-making process doesn't exceed time limit start(): Start running the game isGameOver(): Check if the game is over, not allowing the player to perform any further moves getNewTileValue(): Get the value of the computer's new tile to be inserted insertRandomTile(): Insert the computer's new tile in a random available cell """ def __init__(self, size=4): self.grid = Grid(size) self.possibleNewTiles = [2, 4] self.probability = defaultProbability self.initTiles = defaultInitialTiles self.computerAI = None self.playerAI = None self.displayer = None self.over = False def setComputerAI(self, computerAI): """ Set ComputerAI object """ self.computerAI = computerAI def setPlayerAI(self, playerAI): """ Set PlayerAI object """ self.playerAI = playerAI def setDisplayer(self, displayer): """ Set Displayer object """ self.displayer = displayer def updateAlarm(self, currTime): """ Check time consumed in the decision-making process doesn't exceed time limit Args: currTime: time.clock object indicating the current time at each move """ if currTime - self.prevTime > timeLimit + allowance: self.over = True else: while time.clock() - self.prevTime < timeLimit + allowance: pass self.prevTime = time.clock() def start(self): """ Start running the game """ for i in range(self.initTiles): self.insertRandomTile() self.displayer.display(self.grid) # Player AI Goes First turn = PLAYER_TURN maxTile = 0 self.prevTime = time.clock() while not self.isGameOver() and not self.over: # Copy to Ensure AI Cannot Change the Real Grid to Cheat gridCopy = self.grid.clone() move = None if turn == PLAYER_TURN: print("Player's Turn:", end="") move = self.playerAI.getMove(gridCopy) print(actionDic[move]) # Validate Move if move != None and move >= 0 and move < 4: if self.grid.canMove([move]): self.grid.move(move) # Update maxTile maxTile = self.grid.getMaxTile() else: print("Invalid PlayerAI Move") self.over = True else: print("Invalid PlayerAI Move - 1") self.over = True else: print("Computer's turn:") move = self.computerAI.getMove(gridCopy) # Validate Move if move and self.grid.canInsert(move): self.grid.setCellValue(move, self.getNewTileValue()) else: print("Invalid Computer AI Move") self.over = True if not self.over: self.displayer.display(self.grid) print(self.over) # Exceeding the Time Allotted for Any Turn Terminates the Game self.updateAlarm(time.clock()) turn = 1 - turn print(self.over) print(maxTile) def isGameOver(self): """ Check if the game is over, not allowing the player to perform any further moves Returns: Boolean whether the game is over or not """ return not self.grid.canMove() def getNewTileValue(self): """ Get the value of the computer's new tile to be inserted Returns: Value of the computer's new tile to be inserted """ if randint(0, 99) < 100 * self.probability: return self.possibleNewTiles[0] else: return self.possibleNewTiles[1] def insertRandomTile(self): """ Insert the computer's new tile in a random available cell """ tileValue = self.getNewTileValue() cells = self.grid.getAvailableCells() cell = cells[randint(0, len(cells) - 1)] self.grid.setCellValue(cell, tileValue)
class GameManager: def __init__(self, size=4): self.grid = Grid(size) self.possibleNewTiles = [2, 4] self.probability = defaultProbability self.initTiles = defaultInitialTiles self.computerAI = None self.playerAI = None self.displayer = None self.over = False def setComputerAI(self, computerAI): self.computerAI = computerAI def setPlayerAI(self, playerAI): self.playerAI = playerAI def setDisplayer(self, displayer): self.displayer = displayer def updateAlarm(self, currTime): if currTime - self.prevTime > timeLimit + allowance: self.over = True else: while time.clock() - self.prevTime < timeLimit + allowance: pass self.prevTime = time.clock() def start(self): for i in xrange(self.initTiles): self.insertRandonTile() self.displayer.display(self.grid) # Player AI Goes First turn = PLAYER_TURN maxTile = 0 self.prevTime = time.clock() while not self.isGameOver() and not self.over: # Copy to Ensure AI Cannot Change the Real Grid to Cheat gridCopy = self.grid.clone() move = None if turn == PLAYER_TURN: print "Player's Turn:", move = self.playerAI.getMove(gridCopy) print actionDic[move] # Validate Move if move != None and move >= 0 and move < 4: if self.grid.canMove([move]): self.grid.move(move) # Update maxTile maxTile = self.grid.getMaxTile() else: print "Invalid PlayerAI Move" self.over = True else: print "Invalid PlayerAI Move - 1" self.over = True else: print "Computer's turn:" move = self.computerAI.getMove(gridCopy) # Validate Move if move and self.grid.canInsert(move): self.grid.setCellValue(move, self.getNewTileValue()) else: print "Invalid Computer AI Move" self.over = True if not self.over: #pass self.displayer.display(self.grid) # Exceeding the Time Allotted for Any Turn Terminates the Game self.updateAlarm(time.clock()) turn = 1 - turn print maxTile def isGameOver(self): return not self.grid.canMove() def getNewTileValue(self): if randint(0, 99) < 100 * self.probability: return self.possibleNewTiles[0] else: return self.possibleNewTiles[1] def insertRandonTile(self): tileValue = self.getNewTileValue() cells = self.grid.getAvailableCells() cell = cells[randint(0, len(cells) - 1)] self.grid.setCellValue(cell, tileValue)