def main():
results = 0
maxTiles = []
for i in range(1, 11):
gameManager = GameManager()
playerAI = PlayerAI()
computerAI = ComputerAI()
displayer = Displayer()
print("Round {}".format(i))
gameManager.setDisplayer(displayer)
gameManager.setPlayerAI(playerAI)
gameManager.setComputerAI(computerAI)
gameManager.start()
displayer.display(gameManager.grid)
results += gameManager.maxTile
maxTiles.append(gameManager.maxTile)
top5Tiles = sorted(maxTiles, reverse=True)[:5]
print("Average Score {}".format(results / 10))
print("Average Top 5 Score {}".format(sum(top5Tiles) / 5))
class PlayerAI(BaseAI):
def __init__(self):
self.counter = 0
self.displayer = Displayer()
def getMove(self, grid):
# sys.setrecursionlimit(1500)
moves = grid.getAvailableMoves()
copyGrid = grid.clone()
# move = self.decision(copyGrid)
# return moves[randint(0, len(moves) - 1)] if moves else None
self.counter += 1
print("counter ", self.counter)
result = self.decision(copyGrid)
print("max utility", result[1])
return result[0]
def eval(self, grid):
result = grid.getMaxTile() + len(
grid.getAvailableCells()) + grid.getCellValue(
[0, 0]) + self.meanOfFields(grid)
# print('eval ', result)
return result
#
# def evaluate(self, grid):
#
# # return grid.getcellValue([0,0])
# # print(type(grid))
#
# return len(grid.getAvailableCells() * -1)
def meanOfFields(self, grid):
fieldsSum = 0
result = 0
for i in range(grid.size):
for j in range(grid.size):
fieldsSum += grid.getCellValue([i, j])
return fieldsSum / (grid.size * grid.size)
def decision(self, grid):
maxState = self.maximize(grid, -math.inf, math.inf)
return maxState
def maximize(self, grid, alpha, beta):
if self.terminalTest(grid):
return None, self.eval(grid)
maxMove = None
maxUtility = -math.inf
availableMoves = grid.getAvailableMoves()
for move in availableMoves:
copyGrid = grid.clone()
copyGrid.move(move)
# minimum = self.minimize(copyGrid)
# grid.move(move)
minimum = self.minimize(copyGrid, alpha, beta)
if minimum[1] >= maxUtility:
maxMove = move
maxUtility = minimum[1]
if maxUtility >= beta:
return maxMove, maxUtility
if maxUtility > alpha:
alpha = maxUtility
return maxMove, maxUtility
def minimize(self, grid, alpha, beta):
if self.terminalTest(grid):
print("terminal state reached with following grid")
print(f'alpha {alpha} and beta {beta}')
print("utility", self.eval(grid))
self.displayer.display(grid)
print("---------------------------------------------------------")
return None, self.eval(grid)
minMove = None
minUtility = math.inf
cells = grid.getAvailableCells()
availableCells = grid.getAvailableCells()
for cell in availableCells:
copyGrid = grid.clone()
copyGrid.setCellValue(cell, 2)
# grid.setCellValue(cell,2)
maximum = self.maximize(copyGrid, alpha, beta)
if maximum[1] <= minUtility:
minMove = cell
minUtility = maximum[1]
if minUtility <= alpha:
return minMove, minUtility
if minUtility < beta:
beta = minUtility
return minMove, minUtility
def terminalTest(self, grid):
availableMoves = grid.getAvailableMoves()
if len(availableMoves) == 0:
return True
else:
return False
def main():
player = PlayerAI()
testGrid = Grid()
displayer = Displayer()
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 0], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 3], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([2, 3], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 1], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 2], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([1, 1], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
#main()
def find_next(self, m, i, j, right=True):
if right:
j = j + 1
while j < self.grid.size and m[i, j] == 0:
j += 1
return m[i, j] if j < self.grid.size else None
else:
i = i + 1
while i < self.grid.size and m[i, j] == 0:
i += 1
return m[i, j] if i < self.grid.size else None
if __name__ == '__main__':
g = Grid()
g.map = [[4, 0, 0, 0], [64, 16, 4, 0], [256, 128, 32, 8],
[512, 256, 64, 16]]
displayer = Displayer()
displayer.display(g)
s = State(g, 2, 0, None, 0, 0)
print(s.smoothness())
print(s.eval())
testAI = PlayerAI()
print(actionDic[testAI.getMove(g)])
g.move(3)
displayer.display(g)
s1 = State(g, 2, 0, None, 0, 0)
print(s1.eval())
# for child in s.get_children_min():
# print(child.grid.map)
