def minimax_helper(game, depth, cur_depth): #print("Cur Depth " + str(cur_depth)) #game.display_board() if(game.draw()): return 0 if(game.has_won()): if(game.turn == 1): #print("We Lost!!") return -1000 return 1000 if(cur_depth == depth): #print(score(game)) return score(game) if(game.turn == 1): maxi = -10000 for row in range(7): if(game.legal_move(row)): game_next = copy.copy(game) game_next.play(row) maxi = max(maxi, minimax_helper(game_next, depth, cur_depth + 1)) #print("This is what we got as the maximum that player 1:") return maxi if(game.turn == 2): mini = 10000 for row in range(7): if(game.legal_move(row)): game_next = copy.copy(game) game_next.play(row) mini = min(mini, minimax_helper(game_next, depth, cur_depth + 1)) #print("This is what we got as the minimum that player 2:") #print(mini) return mini
def alphabeta(board, color, alpha, beta, moving_plr, depth): global nNode if moving_plr is None or depth == 0: nNode += 1 return score(board, color), None best = NEGATIVE_INF if moving_plr == color else POSITIVE_INF bestmv = None moves = legal_moves(board, moving_plr) for move in moves: board2 = copy_board(board) make_move(board2, moving_plr, move) mmx = alphabeta(board2, color, alpha, beta, next_player(board2, moving_plr), depth - 1)[0] # print(f"depth: {depth} alpha:{alpha} beta:{beta}") # print_board(board2) if moving_plr == color: bestmv = bestmv if best > mmx else move best = max(best, mmx) alpha = max(best, alpha) else: best = min(best, mmx) beta = min(best, beta) if beta <= alpha: # alpha-beta cutoff break return best, bestmv
def alphabeta(node: Node, color, alpha: int, beta: int, depth: int): global nNode if node.moving_plr is None or depth == 0: nNode += 1 return score(node), None best = NEGATIVE_INF if node.moving_plr == color else POSITIVE_INF bestmv = None for move in node.legal_moves: board2 = copy_board(node.board) make_move(board2, node.moving_plr, move) node2 = Node(board2, node.moving_plr) # print(f"depth:{depth}, Original board:") # print_board(board) # print(f"{node.moving_plr} makes a move") # print_board(board2) mmx = alphabeta(node2, color, delta, epsilon, depth - 1)[0] # print(f"depth:{depth} delta: {delta} epsilon: {epsilon} mmx: {mmx}") # print_board(board2) if node.moving_plr == color: bestmv = bestmv if best > mmx else move best = max(best, mmx) alpha = max(best, alpha) else: best = min(best, mmx) beta = min(best, beta) if beta <= alpha: # alpha-beta cutoff break return best, bestmv
def negamax_ab(board, color, alpha, beta, moving_plr, depth): init_alpha = alpha ttval = negatrans_lookup(board, moving_plr) if ttval is not None and ttval[0] >= depth: if ttval[2] == FLAG_EXACT: return ttval[1] elif ttval[2] == FLAG_LOWER: alpha = max(alpha, ttval[1]) elif ttval[2] == FLAG_UPPER: beta = min(beta, ttval[1]) if depth == 0 or moving_plr is None: return score(board, color) * (1 if color == BLACK else -1)
def lookahead_helper(board, color, depth, nextmv): if depth == 0: return score(board, color) best = NEGATIVE_INF # seriously - this makes no sense. # best = 342894366 for move in legal_moves(board, nextmv): board2 = [b[:] for b in board] # board2[move[0]][move[1]] = color make_move(board, nextmv, move) num = lookahead_helper(board2, color, depth - 1, next_player(board2, nextmv)) if num > best: best = num return best
def minimax_helper2(board, color, last_color, depth): moving_plr = next_player(board, last_color) if moving_plr == None or depth == 0: return score(board, color) if moving_plr == cinv(color): return minimax_helper2(board, cinv(color), last_color, depth) best = NEGATIVE_INF for move in legal_moves(board, moving_plr): # board2 = [list(b) for b in board] board2 = copy_board(board) make_move(board2, moving_plr, move) worstcase = minimax_helper2(board2, color, moving_plr, depth - 1) if worstcase > best: best = worstcase return best
def minimax_helper(board, color, last_color, depth): moving_plr = next_player(board, last_color) if moving_plr == None or depth == 0: return score(board, color) best = NEGATIVE_INF if moving_plr == color else POSITIVE_INF for move in legal_moves(board, moving_plr): board2 = copy_board(board) make_move(board2, moving_plr, move) worstcase = minimax_helper(board2, color, moving_plr, depth - 1) if moving_plr == color: # pick the move with the best worse-case if worstcase > best: best = worstcase else: # other player's turn - pick the worst case if worstcase < best: best = worstcase return best
def alphabeta_memory(board, color, alpha, beta, moving_plr, depth): # print_board(board) global nNode if moving_plr is None or depth == 0: nNode += 1 return score(board, color), None moves = legal_moves(board, moving_plr) nodes = [] for move in moves: board2 = copy_board(board) make_move(board2, moving_plr, move) cval = transposition_lookup(board2, moving_plr) if cval is not None: nodes.append((cval[0], cval[1], move, board2)) else: nodes.append((NEGATIVE_INF, NEGATIVE_INF, move, board2)) nodes.sort(key=lambda x: x[1], reverse=True) best = NEGATIVE_INF if moving_plr == color else POSITIVE_INF bestmv = None for node in nodes: if node[0] < depth: mmx = alphabeta_memory(node[3], color, alpha, beta, next_player(node[3], moving_plr), depth - 1)[0] transposition_add(node[3], moving_plr, depth, mmx) else: # print('Hit') mmx = node[1] if moving_plr == color: bestmv = bestmv if best > mmx else node[2] best = max(best, mmx) alpha = max(best, alpha) else: best = min(best, mmx) beta = min(best, beta) if beta <= alpha: # alpha-beta cutoff # print("alpha beta cutoff") break print( f'Depth: {depth}, heuristic: {score(board, color)}, minimax value: {best}' ) return best, bestmv
def alphabeta_helper(board, color, alpha, beta, last_color, depth): moving_plr = next_player(board, last_color) if moving_plr is None or depth == 0: return score(board, color) best = NEGATIVE_INF if moving_plr == color else POSITIVE_INF moves = legal_moves(board, moving_plr) for move in moves: board2 = copy_board(board) make_move(board2, moving_plr, move) mmx = alphabeta_helper(board2, color, alpha, beta, moving_plr, depth - 1) if moving_plr == color: best = max(best, mmx) alpha = max(best, alpha) else: best = min(best, mmx) beta = min(best, beta) if beta <= alpha: # alpha-beta cutoff break return best
def alphabeta_helper_memory(board, color, alpha, beta, last_color, depth): moving_plr = next_player(board, last_color) if moving_plr is None or depth == 0: return score(board, color) best = NEGATIVE_INF if moving_plr == color else POSITIVE_INF moves = legal_moves(board, moving_plr) nmv = [] for move in moves: cval = transposition_lookup(board, moving_plr) if cval is not None: nmv.append((cval[0], cval[1], move)) else: nmv.append((-1, -1, move)) nmv.sort(key=lambda x: x[1], reverse=False) for node in nmv: if node[0] < depth: # print("mss", node[0], node[1]) board2 = copy_board(board) make_move(board2, moving_plr, node[2]) mmx = alphabeta_helper_memory(board2, color, alpha, beta, moving_plr, depth - 1) else: print("hit", node[0], node[1]) mmx = node[1] if moving_plr == color: best = max(best, mmx) alpha = max(best, alpha) else: best = min(best, mmx) beta = min(best, beta) if node[0] < depth: # add this to transpose transposition_add(board, moving_plr, depth - 1, mmx) if beta <= alpha: # alpha-beta cutoff break return best