Beispiel #1
0
 def genmove_cmd(self, args):
     """
     Generate a move for the color args[0] in {'b', 'w'}, for the game of gomoku.
     """
     board_color = args[0].lower()
     color = color_to_int(board_color)
     movelist, pro = self.policy_moves_cmd("1")
     if not movelist:
         self.respond("resign")
     else:
         coard = self.board.copy()
         if self.go_engine.use_ucb:
             move = runUcb(self.go_engine, coard, 0.4, movelist,
                           coard.current_player)
         else:
             RRmoveWins = []
             for move in movelist:
                 wins = self.go_engine.simulateMove(coard, move,
                                                    coard.current_player)
                 RRmoveWins.append(wins)
             move = select_best_move(self.board, movelist, RRmoveWins)
         move_coord = point_to_coord(move, self.board.size)
         move_as_string = format_point(move_coord)
         if self.board.is_legal(move, color):
             self.board.play_move(move, color)
             self.respond(move_as_string.lower())
         else:
             self.respond("resign")
Beispiel #2
0
def get_move(board, color, selection_policy, sim_num, get_best):
    """
    Run one-ply MC simulations to get a move to play.
    """
    #cboard = board.copy()
    emptyPoints = board.get_empty_points()
    moves = []
    for p in emptyPoints:
        if board.is_legal(p, color):
            moves.append(p)
    if not moves:
        return None
    moves.append(None)
    if selection_policy == "ucb":
        C = 0.4 #sqrt(2) is safe, this is more aggressive
        return runUcb(board, C, moves, color, sim_num, get_best)
    else:
        moveWins = []
        for move in moves:
            wins = simulateMove(board, move, color, sim_num)
            moveWins.append(wins)
        if get_best:
            return select_best_move(board, moves, moveWins)
        else:
            return writeMoves(board, moves, moveWins, len(moves)*sim_num)
Beispiel #3
0
    def get_move(self, board, color):
        #get All Legal Moves
        cboard = board.copy()
        emptyPoints = board.get_empty_points()
        #List of All Legal Moves
        moves = []
        #Check if Move is Legal
        #If it is Append it to moves[] Otherwise Ignore it
        for p in emptyPoints:
            if board.is_legal(p, color):
                moves.append(p)
        if not moves:
            return None
        moves.append(None)


        #implement UCB
        if self.use_ucb:
            C = 0.4 #sqrt(2) is safe, this is more aggressive
            best = runUcb(self, cboard, C, moves, color)
            return best

        #Run Round Robin
        else:
            RRmoveWins = []
            for move in moves:
                wins = self.simulateMove(self, board, move, color)
                RRmoveWins.append(wins)
            writeMoves(cboard, moves, RRmoveWins, self.sim)
            return select_best_move(board, moves, RRmoveWins)
Beispiel #4
0
    def get_move(self, board, color):
        """
        Run one-ply MC simulations to get a move to play.
        """
        cboard = board.copy()
        moves = GoBoardUtil.generate_legal_moves(board, board.current_player)
        self.best_move = moves[0]
        if not moves:
            return None

        C = 0.4 #sqrt(2) is safe, this is more aggressive
        best = ucb.runUcb(self, cboard, C, moves, color)
        return best
        
        '''
Beispiel #5
0
 def get_move(self, board, color, table):
     """
     Run one-ply MC simulations to get a move to play.
     """
     cboard = board.copy()
     empty_points = board.get_empty_points()
     moves = [p for p in empty_points if board.is_legal(p, color)]
     if not moves:
         return None
     moves.append(None)
     if self.use_ucb:
         C = 0.4  #sqrt(2) is safe, this is more aggressive
         best = runUcb(self, cboard, C, moves, color, table)
         return best
     else:
         moveWins = []
         for move in moves:
             wins = self.simulateMove(cboard, move, color, table)
             moveWins.append(wins)
         return select_best_move(board, moves, moveWins)
Beispiel #6
0
 def get_move(self, board, toplay):
     cboard = board.copy()
     emptyPoints = board.get_empty_points()
     moves = []
     for p in emptyPoints:
         if board.check_legal(p, toplay):
             moves.append(p)
     if not moves: # pass move only, no need to simulate
         return None
     moves.append(None) # None for Pass
     if self.use_ucb == True:
         C = 0.4 #sqrt(2) is safe, this is more aggressive
         best = runUcb(self, board, cboard, C, moves, toplay)
         return best
     else:
         moveWins = []
         for move in moves:
             wins = self.simulateMove(board, cboard, move, toplay)
             moveWins.append(wins)
         writeMoves(board, moves, moveWins, self.num_simulation)
         return select_best_move(board, moves, moveWins)
Beispiel #7
0
 def get_move(self, board, color):
     #return GoBoardUtil.generate_random_move(board, color, False)
     #cboard = board.copy()
     emptyPoints = board.get_empty_points()
     moves = []
     for p in emptyPoints:
         if board.is_legal(p, color):
             moves.append(p)
     if not moves:
         return None
     if self.use_ucb:
         C = 0.4  #sqrt(2) is safe, this is more aggressive
         best = runUcb(self, board, C, moves, color)
         return best
     else:
         moveWins = []
         for move in moves:
             wins = self.simulateMove(board, move, color)
             moveWins.append(wins)
         #writeMoves(cboard, moves, moveWins, self.sim)
         return select_best_move(board, moves, moveWins)