Esempio n. 1
0
    def playToTheEnd(p1, p2, logg_moves=False):
        """ alternate playing moves between players until the game is over. """
        game = GomokuGame(parameters.DEFAULT_SIZE)
        p1.color = game.FIRST_PLAYER
        p2.color = game.getOtherPlayer(p1.color)
        move_nr = 1

        while game.winner is None:
            if move_nr % 2 == 1:
                move = alpha_beta.rootAlphaBeta(game, parameters.DEFAULT_ALPHA_BETA_DEPTH, p1)
                color = p1.color
            else:
                move = alpha_beta.rootAlphaBeta(game, parameters.DEFAULT_ALPHA_BETA_DEPTH, p2)
                color = p2.color
            valid_move = game.doMove(color, move)
            if valid_move:
                move_nr += 1
        return game
Esempio n. 2
0
boards = []
moves = []

for game_nr in range(games_played):
    game = g.GomokuGame(parameters.DEFAULT_SIZE)
    p1 = Player_fast(game.BLACK, random_start=parameters.RANDOM_START)
    p2 = Player_fast(game.WHITE)

    # Loop until the game is finished
    done = False
    ai_turn = True

    while not done:
        # --- Main event loop
        if parameters.PLAY_WITH_AI and ai_turn:
            move = ai.rootAlphaBeta(game, parameters.DEFAULT_ALPHA_BETA_DEPTH, p1)
            validMove = game.doMove(p1.color, move)
            if validMove:
                ai_turn = False
                if show_moves:
                    print("AI --> X:", move[0], "Y:", move[1])

        board_before_move = game.getCorrectBoardArray()

        if parameters.PLAY_WITH_AI and parameters.AI_VS_AI and not ai_turn:
            move = ai.rootAlphaBeta(game, parameters.DEFAULT_ALPHA_BETA_DEPTH, p2)
            validMove = game.doMove(p2.color, move)
            if validMove:
                boards.append(np.array(board_before_move))
                moves.append(np.array(get_flattened_arr_of_move(move, game.size)))
                ai_turn = True
Esempio n. 3
0
    print("Starting test nr", game_nr)

    # player2 = Player(game.getOtherPlayer(game.FIRST_PLAYER))

    # layer_sizes = [400, 10, 1]

    # weights, biases = new_ann.convert_all_to_weights_biases(layer_sizes, arr)
    # ann = new_ann.neuralnetwork(weights, biases, layer_sizes, activation=[nnet.sigmoid, nnet.sigmoid, nnet.sigmoid])
    # ann_player = ANN_Player(game.getOtherPlayer(game.FIRST_PLAYER), ann)

    move_nr = 1

    start_move_time = time.time()
    while game.winner is None:
        if move_nr % 2 == 1:
            move = alpha_beta.rootAlphaBeta(game, 3, player1)
            color = player1.color
        else:
            move = alpha_beta.rootAlphaBeta(game, 2, player2)
            color = player2.color
        valid_move = game.doMove(color, move)
        if valid_move:
            move_nr += 1
        # player = game.getOtherPlayer(player)
        end_move_time = time.time()
        print(game.getPlayerString(color), move, " - Time used:", end_move_time - start_move_time)
        start_move_time = time.time()
        # print(game.getCorrectBoardArray())

    end_time = time.time() - start_time
    print(game)