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)
