def initializeVersusAIVariables(): global playerOne global playerTwo global current global nextMove global board global agent P1 = 0 P2 = 1 # multiprocess computaion print "board", agent board = mancala_board.Board() playerOne = Human(P1) # ai Player print agent, 'sdddddddddddddddddddddddddddd' if agent == "Minimax": playerTwo = minimax.AI(P2, 8) elif agent == "Genesis": playerTwo = genesis.genesis(P2, 3) elif agent == "MonteCarlo": playerTwo = mcts.MCTS(P2, mancala_board.Board()) print "Versus AI Agent:", agent # starting player is random # current = random.randint(0,1) # todo this line is a f*****g problem...... current = None nextMove = random.randint(0,1) return jsonify({'initialized' : True})
def move_serial(self, board): alpha = -48 beta = 48 value = alpha i = move = 0 # foreach move possible cut = False self.search_count = 0 print 'AI Thinking...' # for each move, check if its valid, if so get the value of the next possible move while i < 6 and not cut: board_copy = mancala_board.Board(board) # if i is a valid move, else ignore if board_copy.check_move(self.player, i): next_player = board_copy.move(self.player, i) # if the next player has no move, change to other player if not board_copy.has_move(self.player): next_player = (next_player+1)%2 # get next max move value = max(value, self.alphabeta(board_copy, alpha, beta, next_player, self.lookahead)) if alpha < value: alpha = value move = i if alpha > beta: cut = True i+=1 print 'Searched ', self.search_count, ' possibilities' return move
def move(self, board): valid = False move = 0 while not valid: self.board = mancala_board.Board(board) self.generation = self.init_pop() self.test_pop(self.player) for i in range(50): self.gen_encode() self.gen_evolution() self.test_pop(self.player) # to reinitialize total_fitness #print ("generation", i) x = 50 temp_lookahead = self.lookahead while self.count_legal_moves(self.player) == 0: if self.lookahead > 1: self.lookahead -= 1 self.gen_encode() #print ("generation", x) self.gen_evolution() self.test_pop(self.player) # to reinitialize total_fitness x += 1 self.test_pop_and_prune(self.player) self.lookahead = temp_lookahead self.sortandreverse() #print ("selecting most move with fitness: ", self.generation[0][0][0], self.generation[0][0][1]) # self.gen_prune() move = int(self.generation[0][0][0]) valid = board.check_move(self.player, move) return move
def rollout(self, current, player): #SIMULATE # no action counter noActions = 0 next = (player + 1) % 2 success = 0 loss = 0 tie = 0 # current should not move, so make copy of the board to simulate # Copy current board cp_board = mancala_board.Board(current.board) simulatedAction = Node(current.visits, current.score, cp_board) currPlayer = player while (not simulatedAction.board.game_over()): #if not game over then we expand hasAction = self.expansion(simulatedAction, currPlayer) if hasAction: # Has action so we randomly simulate a move chosenAction = random.choice(simulatedAction.actions) #Next player is based on the action taken from expansion next = chosenAction.next_player currPlayer = next simulatedAction = chosenAction noActions = 0 else: if noActions > 1: break noActions += 1 #pass next currPlayer = next next = (next + 1) % 2 #average the wins / total tries # print( "player {} score: ".format(self.player),simulatedAction.board.get_score(self.player)) if simulatedAction.board.get_score( self.player) > simulatedAction.board.get_score( (self.player + 1) % 2): success += 1 elif simulatedAction.board.get_score( self.player) < simulatedAction.board.get_score( (self.player + 1) % 2): loss += 1 else: tie += 1 # print("success", success) # print("Loss ", loss) # print("Tied ",tie ) return success / (success + loss + tie)
def alphabeta(self, board, alpha, beta, player, depth): value = 0 # cound does not update correct when threaded, only works with serial move self.search_count += 1 # traverse entire game to find best move if board.game_over() or depth <= 0: value = self.eval_heuristic(board) elif player == self.player: cut = False value = -48 i = 0 while i < 6 and not cut: board_copy = mancala_board.Board(board) if board_copy.check_move(self.player, i): next_player = board_copy.move(self.player, i) value = max(value, self.alphabeta(board_copy, alpha, beta, next_player, depth-1)) alpha = max(value, alpha) if alpha >= beta: cut = True else: # penalize no moves alpha = -48 i+=1 else: # opponent cut = False value = 48 i = 0 # for each opponent move, check if its valid, if so get the value of the next possible move while i < 6 and not cut: board_copy = mancala_board.Board(board) # if i is a valid move if board_copy.check_move(self.opponent, i): next_player = board_copy.move(self.opponent, i) value = min(value, self.alphabeta(board_copy, alpha, beta, next_player, depth-1)) beta = min(value, beta) if alpha >= beta: cut = True else: # no moves beta = 48 i+=1 return value
def get_move_score(self, move): value = -50 board_copy = mancala_board.Board(self.board) next_player = self.player # repeats are prioritized by increasing score while next_player == self.player and board_copy.check_move(self.player, move): next_player = board_copy.move(self.player, move) # if the next player has no move, change to other player if not board_copy.has_move(self.player): next_player = (next_player+1)%2 value = max(value, self.alphabeta(board_copy, -48, 48, next_player, self.lookahead)) return value
def get_strand_score(self, population, strand_id, player): # variable init strand = population[strand_id] board_copy = mancala_board.Board(self.board) strand_score = 0 # for each move in strand test if move is possible option for i in range(0, len(strand)): board_copy.move(player, int(strand[i])) strand_score += self.eval_heuristic(board_copy) player = (player + 1) % 2 # returns if move sequence is possible return strand_score
def move(self, board): # simulate n random games and return the best move #iterate = 20 valid = False move = 0 copy = mancala_board.Board(board) while not valid: self.root = Node(0, 0.0, copy) action = self.findMove(self.root, self.player, random.randint(2, 25)) move = action.moveTaken print move valid = board.check_move(self.player, move) return move
def initializeAIBattleVariables(): global playerOne global playerTwo global current global nextMove global parallel global board P1 = 0 P2 = 1 # multiprocess computaion parallel = True lookahead = 8 # AI lookahead depth, set to negative to search entire game # board = Board() commented out, moved it to global scope in hopes dynamic playerOne = minimax.AI(P1, lookahead, relative_score= False) #ai_horder = AI(P2, lookahead, horde=True) # hordes pieces on its side playerTwo = minimax.AI(P2, lookahead, relative_score= True, horde=True, relative_horde=True) #horde relative is better then not nextMove = random.randint(0,1) starting_ai = nextMove current = None # ai with current turn board = mancala_board.Board() return jsonify({'initialized' : True})
def test_strand(self, population, strand_id, player, istuple=False): # variable init if istuple: strand = population[strand_id][0] else: strand = population[strand_id] strand_health = True board_copy = mancala_board.Board(self.board) # for each move in strand test if move is possible option i = 0 while i < len(strand) and i < self.lookahead: # for i in range(0, len(strand)): if 0 == board_copy.board[player * 6 + int(strand[i])]: strand_health = False elif strand_health: board_copy.move(player, int(strand[i])) player = (player + 1) % 2 i += 1 # returns if move sequence is possible return strand_health
def expansion(self, current, player): #check if player has a move if current.board.has_move(player): #find all possible moves for i in range(0, 6): # check if move is valid if current.board.check_move(player, i): # Copy current board cp_board = mancala_board.Board(current.board) # Make possible action nextPlayer = cp_board.move(player, i) #Store all possible moves in actions (pointers to childresn) action = Node(0, 0.0, cp_board) action.update_nextPlayer(nextPlayer) action.update_move_taken(i) current.actions.append(action) #Current has children current.hasChildren = True current.isLeaf = False return True else: return False
def resetBoard(): return mancala_board.Board()