def ai_move(self): player_obj = self.players[self.game.current_player] try: i, j = player_obj.get_move(self.game) player = "Dark" if self.game.current_player == 1 else "Light" player = "{} {}".format(player_obj.name, player) self.log("{}: {},{}".format(player, i, j)) self.game.play(i, j) self.draw_board() if not get_possible_moves(self.game.board, self.game.current_player): if get_score(self.game.board)[0] > get_score( self.game.board)[1]: self.shutdown("Dark wins!") elif get_score(self.game.board)[0] < get_score( self.game.board)[1]: self.shutdown("White wins!") else: self.shutdown("Tie!") elif isinstance(self.players[self.game.current_player], AiPlayerInterface): self.root.after(1, lambda: self.ai_move()) else: self.root.bind("<Button-1>", lambda e: self.mouse_pressed(e)) except AiTimeoutError: self.shutdown("Game Over, {} lost (timeout)".format( player_obj.name))
def compute_utility(board, color): if color == 2: co = 1 elif color == 1: co = 2 diff = get_score(board)[color - 1] - get_score(board)[co - 1] return diff
def compute_heuristic(board, color): #IMPLEMENT #1. Stable position (Corners & X and C squares & Edges) #The four corners are the most important position that need to occupy, so increase these positions' weight #The opponent can take the corner when one of three position that adjacent to the corner is occupied, so lower these positions' weight #The opponent cannot surround edge positions, so increase these positions' weight #2. Mobilitiy #Count the number of moves that the player can make for the current board. #3. In the opening, mid-game, and end-game, use different weight strategy. corners = compute_corners(board, color) * 20 xc_squares = -compute_xc_squares(board, color) * 10 edge_count, frontier_count = compute_edge(board, color) utility = compute_utility(board, color) * 2 mobilitiy = compute_mobility(board, color) game = get_score(board)[0] + get_score(board)[1] open_game = len(board) // 3 mid_game = len(board) // 3 * 2 end_game = len(board) return corners + xc_squares + edge_count + utility + mobilitiy
def play_game(game, player1, player2): players = [None, player1, player2] while True: player_obj = players[game.current_player] possible_moves = game.get_possible_moves() if not possible_moves: p1score, p2score = get_score(game.board) print("FINAL: {} (dark) {}:{} {} (light)".format( player1.name, p1score, p2score, player2.name)) player1.kill(game) player2.kill(game) break else: color = "dark" if game.current_player == 1 else "light" try: i, j = player_obj.get_move(game) print("{} ({}) plays {},{}".format(player_obj.name, color, i, j)) game.play(i, j) except AiTimeoutError: p1score, p2score = get_score(game.board) print("{} ({}) timed out!".format(player_obj.name, color)) print("FINAL: {} (dark) {}:{} {} (light)".format( player_obj.name, p1score, p2score, player2.name)) player1.kill(game) player2.kill(game) break
def compute_utility(board, color): #IMPLEMENT (num_dark, num_light) = get_score(board) if color == 1: # dark return num_dark - num_light if color == 2: # light return num_light - num_dark
def compute_heuristic(board, color): #not implemented, optional # IMPLEMENT # Board size d = len(board) # Minimize the number of disks the opponent result = get_score(board) if color == 1: utility = result[0] - result[1] else: utility = result[1] - result[0] # Minimize the number of moves the opponent can make dark_moves = len(get_possible_moves(board, 1)) light_moves = len(get_possible_moves(board, 2)) if color == 1: mobility = dark_moves - light_moves else: mobility = light_moves - dark_moves # Check board size to prevent index out of range if d < 4: return utility + mobility # Now the rest satisfies board size >= 4 dark = 0 light = 0 # Highly value taking corner fields corners = [(0, 0), (d - 1, 0), (0, d - 1), (d - 1, d - 1)] for (column, row) in corners: if board[column][row] == 1: dark += 500 elif board[column][row] == 2: light += 500 # Highly penalize taking the fields next to the corners near_corners = [(1, 0), (0, 1), (1, d - 1), (d - 1, 1), (0, d - 2), (d - 2, 0), (d - 1, d - 2), (d - 2, d - 1)] for (column, row) in near_corners: if board[column][row] == 1: dark -= 50 elif board[column][row] == 2: light -= 50 # Value other border tiles than remaining tiles for i in range(2, d - 2): edges = [(0, i), (i, 0), (i, d - 1), (d - 1, i)] for (column, row) in edges: if board[column][row] == 1: dark += 50 elif board[column][row] == 2: light += 50 if color == 1: weight = dark - light else: weight = light - dark return utility + mobility + weight
def compute_utility(board, color): disk_num = get_score(board) if (color == 1): ut = disk_num[0] - disk_num[1] else: ut = disk_num[1] - disk_num[0] return ut
def compute_utility(board, color): scores = get_score(board) if color==1: utility = scores[0]-scores[1] else: utility = scores[1] - scores[0] return utility
def select_move_minimax(board, color, move_num, time_remaining, time_opponent, ply): moves = get_possible_moves(board, color) if not isinstance(moves, list): score1, score2 = get_score(board) boardScore = [score1, score2] return boardScore, None # if time_remaining < 10: # return (0, max(moves, key=lambda move: self.greedy(board, color, move)) ) return_move = moves[0] bestscore = -float('inf') #ply = 4 #will define ply later; for move in moves: newboard = board[:] newboard = play_move(newboard, color, move[0], move[1]) if (color == 1): opp = 2 else: opp = 1 score = minimax_min_node(newboard, opp, move_num, ply) if score > bestscore: bestscore = score return_move = move #return (bestscore,return_move) return return_move
def compute_utility(board, color): #IMPLEMENT score1, score2 = get_score(board) if color == 1: return score1 - score2 else: return score2 - score1
def draw_board(self): self.draw_grid() self.draw_disks() player = "Dark" if self.game.current_player == 1 else "Light" self.move_label["text"] = player self.score_label["text"] = "Dark {} : {} Light".format( *get_score(self.game.board))
def compute_utility(board, color): #IMPLEMENT dark, light = get_score(board) if(color == 1): #dark return dark - light if(color == 2): #light return light - dark
def get_move(self, manager): white_score, dark_score = get_score(manager.board) self.process.stdin.write("SCORE {} {}\n".format( white_score, dark_score).encode("ASCII")) self.process.stdin.flush() self.process.stdin.write("{}\n".format(str( manager.board)).encode("ASCII")) self.process.stdin.flush() timer = Timer(AiPlayerInterface.TIMEOUT, lambda: self.timeout()) self.timed_out = False timer.start() start = datetime.datetime.now() # Wait for the AI call move_s = self.process.stdout.readline().decode("ASCII") last = datetime.datetime.now() - start print(last) if self.timed_out: raise AiTimeoutError timer.cancel() i_s, j_s = move_s.strip().split() i = int(i_s) j = int(j_s) return i, j
def compute_utility(board, color): a = get_score(board) if color == 1: b = a[color] - a[1] else: b = a[color] - a[2] return b
def compute_utility(board, color): score = get_score(board) #returns tuple (# of dark disks, # of light disks) if color == 1: return score[0]-score[1] else: return score[1]-score[0]
def compute_utility(board, color): #IMPLEMENT dark, light = get_score(board) if color == 1: # player is black return dark - light else: # color == 2 (i.e., player is white) return light - dark
def compute_utility(board, color): disk_count = get_score(board) dark_disk = disk_count[0] light_disk = disk_count[1] if color == 1: return dark_disk - light_disk elif color == 2: return light_disk - dark_disk
def compute_utility(board, color): score = get_score(board) if color == 1: return score[0] - score[1] elif color == 2: return score[1] - score[0] else: return 0
def compute_utility(board, color): score = get_score(board) #light if color == 2: return score[1] - score[0] #dark elif color == 1: return score[0] - score[1]
def compute_utility(board, color): result = get_score(board) dark = result[0] white = result[1] if color == 1: return dark - white else: return white - dark
def compute_utility(board, color): dark, light = get_score(board) if color == 2: return light - dark else: return dark - light
def compute_utility(board, color): #IMPLEMENT scores = get_score(board) if color == 1: score_final = scores[0] - scores[1] elif color == 2: score_final = scores[1] - scores[0] return score_final
def compute_utility(board, color): #IMPLEMENT (dark, light) = get_score(board) if color == 1: #dark return dark - light if color == 2: #light return light - dark else: return False
def compute_utility(board, color): p1, p2 = get_score(board) if color == 1: return p1 - p2 elif color == 2: return p2 - p1 return 0
def compute_utility(board, color): """ Return the utility of the given board state (represented as a tuple of tuples) from the perspective of the player "color" (1 for dark, 2 for light) """ u1, u2 = get_score(board) if color == 1: return u1 - u2 if color == 2: return u2 - u1
def compute_utility(board, color): #IMPLEMENT p1, p2 = get_score(board) # eprint(get_score(board)) # eprint(color) if color == 1: #dark return p1 - p2 else: return p2 - p1 #change this!
def compute_utility(board, color): #IMPLEMENT p1_count, p2_count = get_score(board) #Player color: 1 for dark (goes first), 2 for light. if (color == 1): return p1_count - p2_count else: return p2_count - p1_count
def compute_utility(board, color): # color 1 - dark # color 2 - light # IMPLEMENT dark_score, light_score = get_score(board) # default assuming color 1 utility = dark_score - light_score if color == 2: utility = -utility return utility
def compute_utility(board, color): #IMPLEMENT # get_score(board) returns a tuple (number of dark disks, number of light disks) result = get_score(board) # utility calculated as the number of disks of the player's colour minus the number of disks of the opponent if color == 1: return result[0] - result[1] else: return result[1] - result[0]
def compute_utility(board, color): """ Return the utility of the given board state (represented as a tuple of tuples) from the perspective of the player "color" (1 for dark, 2 for light) """ points = get_score(board) #p1 is dark, p2 is light if color == 1: return points[0] - points[1] else: return points[1] - points[0]