def get_decision_move(self, grid: Grid) -> Grid:
# print('get_decision_move (input): {}'.format(grid.map))
moves = grid.getAvailableMoves()
max_value = -math.inf
self.sort_moves_for_alpha_beta_pruning(moves)
for move in moves:
grid_after_move = self.get_grid_for_move(grid, move)
grid_after_move.current_depth = grid.current_depth + 1
a = -math.inf
b = math.inf
(child, utility) = self.minimize(
grid_after_move, a,
b) # the first move was already done in this function
# print('get_decision_move: {} with utility_value (min) = {} for move {}'.format(grid_after_move.map, utility, move))
if utility > max_value:
move_return = move
max_value = utility
return move_return
def get_children(self, grid: Grid, min_or_max: str):
grid_children = []
if min_or_max == 'max':
moves = grid.getAvailableMoves()
for move in moves:
child_grid = self.get_grid_for_move(grid, move)
child_grid.current_depth = grid.current_depth + 1
grid_children.append(child_grid)
else:
cells = grid.getAvailableCells()
values = [2, 4]
for cell in cells:
for value in values:
grid_copy = grid.clone()
grid_copy.setCellValue(cell, value)
grid_copy.current_depth = grid.current_depth + 1
grid_children.append(grid_copy)
return grid_children
def maximizing(self, alpha, beta, node: Grid, depth):
maximizing_move = None
if depth == 0:
return self.heuristic(node), maximizing_move
moves = node.getAvailableMoves()
if not moves:
return self.get_terminal_node_value(node), maximizing_move
value = -math.inf
for move in moves:
child = node.clone()
child.move(move)
opponent_value = self.minimizing(alpha, beta, child, depth - 1)
maximizing_move = move if opponent_value >= value else maximizing_move
value = max(value, opponent_value)
alpha = max(alpha, value)
if alpha >= beta:
break
return value, maximizing_move
from Grid_3 import Grid
import numpy as np
import time
import minimax as minimax
import helper as helper
import alphabeta as ab
class PlayerAI(BaseAI):
def getMove(self, grid):
decision = ab.maximize(grid, 4, time.clock(), None, -np.inf, np.inf)
return decision[2]
if __name__ == '__main__':
g = Grid()
player = PlayerAI()
g.map[0][0] = 2
g.map[1][0] = 128
g.map[3][0] = 512
for b in range(3):
for i in g.map:
print(i)
print(g.getAvailableMoves())
v = player.getMove(g)
g.move(v)