コード例 #1
0
ファイル: minimax.py プロジェクト: douglasscorrea/boku-player
def minimax(curr_node, player):
    score_list = []

    score = utils.calculate_score(curr_node.get_board(), player)

    if score in [math.inf, -math.inf]:
        curr_node.set_score(score)
        print(curr_node.get_board())
        return score

    if curr_node.get_depth() == 2:
        print(curr_node.get_board())
        curr_node.set_score(score)
        return score

    moves = utils.get_available_moves(curr_node.get_board())

    if moves == []:
        print(curr_node.get_board())
        curr_node.set_score(score)
        return score

    for move in moves:
        new_board = utils.perform_move(copy.deepcopy(curr_node.get_board()),
                                       move, player)
        new_node = node.Node(curr_node, new_board,
                             curr_node.get_depth() + 1, move)
        curr_node.add_lower(new_node)

        if player == 1:
            move_score = minimax(new_node, 2)
        else:
            move_score = minimax(new_node, 1)

        score_list.append(move_score)

    if (player == 1):
        score = max(score_list)
        curr_node.set_score(score)
    else:
        score = min(score_list)
        curr_node.set_score(score)

    return score
コード例 #2
0
def minimax_alphabeta(curr_node, player, alpha, beta):
    # end = datetime.datetime.now()
    # diff = end - start
    # print(diff)
    # print(curr_node.get_board())
    global identifier
    global forbidden_moves
    score_list = []
    identifier += 1
    
    if(curr_node.get_depth() >= c.max_depth):   # if we hit max depth, recursion is stopped
        score = utils.calc_differential_score_distinct_weights(curr_node.get_board(), player)
        curr_node.set_score(score)
        return score
    elif(curr_node.is_final()):                 # if current state is final, recursion is stopped
        score = utils.calc_differential_score_distinct_weights(curr_node.get_board(), player)
        curr_node.set_score(score)
        return score


    moves = utils.get_available_moves(curr_node.get_board())

    # If there are forbidden moves, they must be removed from available moves list
    if(len(forbidden_moves) > 0):
        # print("REMOVE FORBIDDEN MOVES")
        # print(str(forbidden_moves))
        # print()
        moves = utils.remove_forbidden_moves(moves, forbidden_moves)
    
    if(player == 1):
        value = -9999999999
        for move in moves:
            new_board = utils.perform_move(copy.deepcopy(curr_node.get_board()), move, player)
            new_node = node.Node(curr_node, new_board, curr_node.get_depth() + 1, player, move)
            new_node.set_identifier(identifier)
            # print("New move " + str(move[0]) + ',' + str(move[1]))
            # print(new_node.get_board())
            # print()
            # print
            curr_node.add_lower(new_node)

            move_score = minimax_alphabeta(new_node, 2, alpha, beta)

            value = max(move_score, value)
            alpha = max(alpha, value)
            if(alpha >= beta):
                break

        curr_node.set_score(value)
        return value        
    else:
        value = 9999999999
        for move in moves:
            new_board = utils.perform_move(copy.deepcopy(curr_node.get_board()), move, player)
            new_node = node.Node(curr_node, new_board, curr_node.get_depth() + 1, player, move)
            new_node.set_identifier(identifier)
            # print("New move " + str(move[0]) + ',' + str(move[1]))
            # print(new_node.get_board())
            # print()
            # print
            curr_node.add_lower(new_node)

            move_score = minimax_alphabeta(new_node, 1, alpha, beta)

            value = min(move_score, value)
            beta = min(beta, value)

            if(alpha >= beta):
                break

        curr_node.set_score(value)
        return value                        
コード例 #3
0
def alpha_beta_pruning(curr_node, player, abp_class, forbidden_moves):
    alpha = abp_class.get_alpha()
    beta = abp_class.get_beta()
    score = utils.calculate_score(curr_node.get_board(), player)

    if score in [math.inf, -math.inf]:
        curr_node.set_score(score)
        return score

    if curr_node.get_depth() == 2:
        curr_node.set_score(score)
        return score

    moves = utils.get_available_moves(curr_node.get_board())
    for move in moves:
        if [move[0] + 1, move[1] + 1] in forbidden_moves:
            moves.remove(move)

    if moves == []:
        curr_node.set_score(score)
        return score

    if len(moves) in [80, 79]:
        if [5, 4] in moves:
            curr_node.set_score(score)
            curr_node.set_move([5, 4])
            return score
        elif [5, 5] in moves:
            curr_node.set_score(score)
            curr_node.set_move([5, 5])
            return score
        elif [4, 3] in moves:
            curr_node.set_score(score)
            curr_node.set_move([4, 3])
            return score
        elif [6, 3] in moves:
            curr_node.set_score(score)
            curr_node.set_move([6, 3])
            return score

    if player == 1:
        best_score = -math.inf

        for move in moves:
            new_board = utils.perform_move(
                copy.deepcopy(curr_node.get_board()), move, player)
            new_node = node.Node(curr_node, new_board,
                                 curr_node.get_depth() + 1, move)
            curr_node.add_lower(new_node)

            move_score = alpha_beta_pruning(new_node, 2, abp_class,
                                            forbidden_moves)

            best_score = max(best_score, move_score)
            abp_class.set_alpha(max(alpha, best_score))
            if abp_class.get_alpha() >= beta:
                break

        curr_node.set_score(best_score)
        return best_score
    else:
        best_score = math.inf

        for move in moves:
            new_board = utils.perform_move(
                copy.deepcopy(curr_node.get_board()), move, player)
            new_node = node.Node(curr_node, new_board,
                                 curr_node.get_depth() + 1, move)
            curr_node.add_lower(new_node)

            move_score = alpha_beta_pruning(new_node, 1, abp_class,
                                            forbidden_moves)

            best_score = min(best_score, move_score)
            abp_class.set_beta(min(beta, best_score))
            if alpha >= abp_class.get_beta():
                break

        curr_node.set_score(best_score)
        return best_score
コード例 #4
0
 def available_moves(self):
     return get_available_moves(self.board,
                                self.position,
                                can_use_enemy=True,
                                maximum_steps=2)
コード例 #5
0
 def available_moves(self):
     return get_available_moves(self.board,
                                self.position,
                                can_use_body=True)
コード例 #6
0
 def available_moves(self):
     return get_available_moves(self.board, self.position)
コード例 #7
0
def minimax_alphabeta(curr_node, player, ab):

    global identifier
    global forbidden_moves
    score_list = []
    identifier += 1

    alpha = ab[0]
    beta = ab[1]

    if (curr_node.get_depth() >=
            c.max_depth):  # if we hit max depth, recursion is stopped
        score = utils.calc_differential_score(curr_node.get_board(), player)
        curr_node.set_score(score)
        return score
    elif (curr_node.is_final()
          ):  # if current state is final, recursion is stopped
        score = utils.calc_differential_score(curr_node.get_board(), player)
        curr_node.set_score(score)
        return score

    moves = utils.get_available_moves(curr_node.get_board())

    # If there are forbidden moves, they must be removed from available moves list
    if (len(forbidden_moves) > 0):
        moves = utils.remove_forbidden_moves(moves, forbidden_moves)

    if (player == 1):
        value = -9999999999
        for move in moves:
            new_board = utils.perform_move(
                copy.deepcopy(curr_node.get_board()), move, player)
            new_node = node.Node(curr_node, new_board,
                                 curr_node.get_depth() + 1, player, move)
            new_node.set_identifier(identifier)

            curr_node.add_lower(new_node)

            move_score = minimax_alphabeta(new_node, 2, ab)

            value = max(move_score, value)

            ab[0] = max(alpha, value)
            if (ab[0] >= beta):
                break

        curr_node.set_score(value)
        return value
    else:
        value = 9999999999
        for move in moves:
            new_board = utils.perform_move(
                copy.deepcopy(curr_node.get_board()), move, player)
            new_node = node.Node(curr_node, new_board,
                                 curr_node.get_depth() + 1, player, move)
            new_node.set_identifier(identifier)

            curr_node.add_lower(new_node)

            move_score = minimax_alphabeta(new_node, 1, ab)

            value = min(move_score, value)

            ab[1] = min(beta, value)
            if (alpha >= ab[1]):
                break

        curr_node.set_score(value)
        return value