Ejemplo n.º 1
0
    def make_move(self, board, learning = False):
        # flatten the board from a grid to 1D for the neural network
        if learning:
            inputs = Game.flatten(board)
        else:
            inputs = Game.flatten(board, self.player)

        self.memories.observe(inputs)

        # get the neural networks movs
        self.net.set_input(inputs)
        self.net.forward_propagate()
        output = self.net.get_output()

        # if we are learning, we want to take the neural networks top choice,
        # but if we are in a game, it needs to pick a valid move
        while True:
            move = output.index(max(output))    # highest rated move by NN
            # Convert to x, y
            y = move/SIZE
            x = move%SIZE
        
            if learning: return move

            if board[x][y] == EMPTY:
                return move

            else:
                output[move] = -1
Ejemplo n.º 2
0
def main():
    # Testing code
    """
    game = Game('large_normal_186')
    game.load_events()
    game.process_events()
    print(game.generate_vote_count(278))
    print('\nNow in RC style!\n')
    print(game.generate_vote_count(278, style='large_normal_186'))
    my_list = Component.create('players_list', game_state=game.game_state, post=game.game_state.post)
    print(my_list.generate())
    print('\nLiving Players:\n')
    my_list = Component.create('players_list', game_state=game.game_state, post=game.game_state.post, filter='living')
    print(my_list.generate())
    print('\nDead Players:\n')
    my_list = Component.create('players_list', game_state=game.game_state, post=game.game_state.post, filter='dead')
    print(my_list.generate())
    print('\nModkilled Players:\n')
    my_list = Component.create('players_list', game_state=game.game_state, post=game.game_state.post, filter='modkilled')
    print(my_list.generate())
    print('breakpoint')
    """

    game = Game('mini_theme_1974')
    game.load_events()
    game.process_events()
    for election in game.game_state.elections:
        for vc in election.vote_counts:
            print(game.generate_vote_count(vc, style='Micc') + '\n\n')
    my_hacked_in_component = Component.create('players_list',
                                              game_state=game.game_state,
                                              post=game.game_state.post,
                                              style='Micc')
    print(my_hacked_in_component.generate())
    print('\n\nbreakpoint')
Ejemplo n.º 3
0
    def score(self, board, depth):
        winner = Game.winner(board)

        if winner == self.player:   # I win
            return 10
        if winner == (-1*self.player):  # I lose
            return -10

        return 0    # tie
Ejemplo n.º 4
0
    def __init__(self):
        self.curr_player = X    # whose turn is it?

        # the computer players
        self.learning_player = LearningPlayer(O)
        self.perfect_player = PerfectPlayer(O)
        self.computer_player = self.learning_player

        self.game = Game()  # new game/board
        
        # run the gui
        self.gui = Display(self)
        self.gui.mainloop()
Ejemplo n.º 5
0
    def learn_all_known_boards(self):
        self.passed_moves = self.failed_moves = 0

        # solve from the reference frame of the X player
        perfect_player = PerfectPlayer(X)

        for board in self.memories.get_memories():
            # build a grid out of a flattened board
            grid_board = Game.unflatten(board)

            # don't recompute move, if it's already be calculated
            if self.memories.remember_move(board) >= 0:
                correct_move = self.memories.remember_move(board)
            # get the move from the perfect player and store it in memory
            else:
                correct_move = perfect_player.make_move(grid_board)
                self.memories.learn_move(board, correct_move)

            self.learn_move(grid_board, correct_move) # learn the move
Ejemplo n.º 6
0
    def minimax(self, player, board, depth, alpha, beta):
        if Game.game_over(board): return self.score(board, depth)

        # all empty positions where a move can be made
        moves = [(i, j) for i in range(SIZE) for j in range(SIZE) if board[i][j] == EMPTY]

        best_score = alpha if player == self.player else beta

        # try each move and see how well it does
        for move in moves:
            this_board = deepcopy(board)

            # make the move
            i, j = move
            this_board[i][j] = player

            # maximizing player
            if player == self.player:
                score = self.minimax(-1*player, this_board, depth+1, best_score, beta)
                
                if score > best_score:
                    best_score = score
                    best_move = j*SIZE + i

                if beta <= best_score: break
            # minimizing player
            else:
                score = self.minimax(-1*player, this_board, depth+1, alpha, best_score)
                
                if score < best_score:
                    best_score = min(best_score, score)
                    best_move = j*SIZE + i

                if best_score <= alpha: break

        return best_score if depth else best_move
Ejemplo n.º 7
0
class Controller:
    def __init__(self):
        self.curr_player = X    # whose turn is it?

        # the computer players
        self.learning_player = LearningPlayer(O)
        self.perfect_player = PerfectPlayer(O)
        self.computer_player = self.learning_player

        self.game = Game()  # new game/board
        
        # run the gui
        self.gui = Display(self)
        self.gui.mainloop()

    # reset the game
    def reset(self):
        self.curr_player = X
        self.game = Game()

        if self.computer_player.get_player() == X: self.get_computer_move() # X goes first

    # Called by the GUI so this means a human moved. Update the game and get the computer's move
    def make_move(self, x, y):
        # check that the move is valid
        if self.get_position(x,y) == EMPTY and self.game.set_position(self.curr_player, x, y):
            self.switch_player()    # other players turn now

            winner = self.game_over()    # was there a winner?

            # game isn't over so get the computer player's move
            if not winner:
                self.get_computer_move()

    # get the move from the computer
    def get_computer_move(self):
        move = self.computer_player.make_move(self.game.board)  # the computer's move

        # convert from 1D to 2D
        y = move/SIZE
        x = move%SIZE

        self.game.set_position(self.curr_player, x, y) # update the game board
        self.gui.update_button(x, y)    # update the GUI

        self.game_over()     # check if the game is over

        self.switch_player()    # other players turn now

    # this is the fun stuff! Have the machine learn from the observed behavior
    def learn(self):
        print '\n\nLearning\n\n'

        # Ideally we want it to learn until it gets every move right, but at somepoint we have to stop learning
        for i in range(20000):
            self.learning_player.learn_all_known_boards()
            
            # see how many moves the machine got right and how many it got wrong
            print 'Pass', i, 'correct_moves:', self.learning_player.passed_moves, 'incorrect moves:', self.learning_player.failed_moves
            
            if not self.learning_player.failed_moves:   # got every move right!
                num_passes = i
                break

        print '\n\nIt took', i, 'iterations but I learned all of the moves!\n\n'

    def forget(self):
        self.learning_player.forget()

        print '\n\nI just forgot how to play\n\n'

    def get_position(self, x, y):
        return self.game.get_position(x, y)

    # has somebody won? if not, was there a tie?
    def game_over(self):
        winner = self.game.has_winner()

        if winner:  # somebody won
            self.gui.game_over(winner)
            return True
        elif self.game.is_full():   # board is full -> tie
            self.gui.game_over(None)
            return True

        return False    # game is not over

    # set what player the computer player is (X or O)
    def set_player(self, player):
        self.learning_player.set_player(-1*STRINGS[player])
        self.perfect_player.set_player(-1*STRINGS[player])

    # switch between whose turn it is
    def switch_player(self):
        if self.curr_player == X:
            self.curr_player = O
        else:
            self.curr_player = X

    # set the type of computer player (learning or perfect)
    def set_comp_type(self, comp_type):
        if comp_type == 'Perfect': self.computer_player = self.perfect_player
        else: self.computer_player = self.learning_player
Ejemplo n.º 8
0
    def reset(self):
        self.curr_player = X
        self.game = Game()

        if self.computer_player.get_player() == X: self.get_computer_move() # X goes first