def test_utility(self): # X wins player_board = \ [[self.X, self.O, self.O], [self.O, self.O, self.X], [self.X, self.X, self.X]] self.assertEqual(1, ttt.utility(player_board)) # O wins player_board = \ [[self.X, self.O, self.X], [self.O, self.O, self.X], [self.X, self.O, self.X]] self.assertEqual(-1, ttt.utility(player_board)) # tie player_board = \ [[self.O, self.X, self.X], [self.X, self.O, self.O], [self.X, self.O, self.X]] self.assertEqual(0, ttt.utility(player_board)) player_board = \ [[self.X, self.O, self.X], [self.O, self.O, self.EMPTY], [self.X, self.EMPTY, self.EMPTY]] self.assertEqual(0, ttt.utility(player_board))
def game_loop(): WIDTH = 3 b = ttt.make_board(WIDTH) while ttt.utility(b) is None: ttt.display(b) ### Human moves # sanitize user input user_move = ttt.prompt_move() while not ttt.valid_move(user_move, b): user_move = ttt.prompt_move() # process move b[user_move[0]][user_move[1]] = 'O' # end game if human plays winning move ttt.display(b) if ttt.utility(b) is None: ### AI moves current_node = SearchNode(None, None, b) best_node = minimax(current_node, -9999999999, 9999999999, maximize=True) b = best_node.board
def test_utility(self): utility_4 = ttt.utility(self.board_4) self.assertEqual(utility_4, 1) utility_5 = ttt.utility(self.board_5) self.assertEqual(utility_5, -1) utility_6 = ttt.utility(self.board_6) self.assertEqual(utility_6, 1)
def test_utility(self): board = [[tictactoe.O, tictactoe.X, tictactoe.O], [tictactoe.X, tictactoe.O, tictactoe.X], [tictactoe.X, tictactoe.O, tictactoe.X]] utilityScore = tictactoe.utility(board) print(utilityScore)
def game_over(self): score = tictactoe.utility(self.state) if score == tictactoe.RESULT_X_WINS: msg = "Player x wins" elif score == tictactoe.RESULT_O_WINS: msg = "Player o wins" else: msg = "It's a draw" messagebox.showinfo("Game Over", msg) self.reset()
def max_value(state, depth=0): if ttt.terminal(state): return (None, ttt.utility(state)) v = (None, -2) for action in ttt.actions(state): v = max( v, (action, min_value(ttt.result(state, action), depth + 1)[1] - (depth / 10)), key=lambda x: x[1]) return v
def test_utility(self): # Game is a tie board = [ [tictactoe.X, tictactoe.O, tictactoe.O], [tictactoe.O, tictactoe.X, tictactoe.X], [tictactoe.X, tictactoe.X, tictactoe.O], ] self.assertEqual(tictactoe.utility(board), 0) # X has won board = [ [tictactoe.X, tictactoe.EMPTY, tictactoe.EMPTY], [tictactoe.O, tictactoe.X, tictactoe.O], [tictactoe.EMPTY, tictactoe.EMPTY, tictactoe.X], ] self.assertEqual(tictactoe.utility(board), 1) # O has won board = [ [tictactoe.X, tictactoe.EMPTY, tictactoe.EMPTY], [tictactoe.O, tictactoe.O, tictactoe.O], [tictactoe.X, tictactoe.EMPTY, tictactoe.X], ] self.assertEqual(tictactoe.utility(board), -1)
def minimax(current_node, a, b, maximize=True): # check if we're at a leaf node util = ttt.utility(current_node.board) if util is not None: # the game is over, return the reward # ttt.display(current_node.board) return SearchNode(current_node, util, current_node.board) if maximize: child_node = SearchNode(current_node, -9999999999, current_node.board) # if it's our turn, return the move that maximizes utility for state in ttt.successors(current_node.board, 'X'): child_node = max(child_node, minimax(SearchNode(current_node, None, state), a, b, not maximize), key=lambda node: node.utility) # Alpha-Beta pruning if child_node.utility >= b: return child_node a = max(a, child_node.utility) return child_node else: child_node = SearchNode(current_node, 9999999999, current_node.board) # If opponent's turn, return the move that minimizes utility for state in ttt.successors(current_node.board, 'O'): child_node = min(child_node, minimax(SearchNode(current_node, None, state), a, b, not maximize), key=lambda node: node.utility) # Alpha-Beta pruning if child_node.utility <= a: return child_node b = min(b, child_node.utility) return child_node
from tictactoe import actions, result, winner, terminal, utility, minimax X = "X" O = "O" EMPTY = None board = [[EMPTY, EMPTY, EMPTY], [EMPTY, EMPTY, EMPTY], [EMPTY, EMPTY, EMPTY]] board = [[X, X, O], [O, X, O], [X, EMPTY, EMPTY]] print(winner(board)) print(terminal(board)) print(utility(board)) print(minimax(board))
import tictactoe as t board = t.initial_state() board[0][2] = t.X board[1][1] = t.X board[2][0] = t.X print(t.utility(board)) print(t.terminal(board)) print(board) for row in board: print(row.count(t.O)) print (t.player(board)) print(t.actions(board)) for a in t.actions(board): print(t.result(board,a))
def test_utiltity_X_wins(): board = [["X", "O", EMPTY], ["O", "X", "O"], ["X", EMPTY, "X"]] assert ttt.utility(board) == 1
def test_utiltity_nobody_wins(): board = [["X", "O", "O"], ["O", "X", "X"], ["X", "X", "O"]] assert ttt.utility(board) == 0
from tictactoe import utility, EMPTY, X, O print( utility([[EMPTY, EMPTY, EMPTY], [EMPTY, EMPTY, EMPTY], [EMPTY, EMPTY, EMPTY]]))
def test_utility_tie(self): board = [[X, X, O], [O, O, X], [X, O, X]] self.assertEqual(utility(board), 0)
def test_utility_o_wins(self): board = [[O, O, O], [X, X, EMPTY], [O, X, X]] self.assertEqual(utility(board), -1)
from tictactoe import actions, terminal, utility, winner, player, initial_state board = initial_state() utility(board)
from tictactoe import initial_state from tictactoe import player from tictactoe import actions from tictactoe import result from tictactoe import winner from tictactoe import terminal from tictactoe import utility from tictactoe import minimax board = initial_state() actions = actions(board) winner = winner(board) terminal = terminal(board) utility = utility(board) minimax = minimax(board) print(minimax)
assert all_actions == ttt.actions(empty_board) # First move first_move = deepcopy(empty_board) first_move[0][0] = X assert ttt.result(empty_board, (0, 0)) == first_move winner_boardX = deepcopy(first_move) winner_boardX[0][1] = X winner_boardX[0][2] = X assert not ttt.terminal(empty_board) assert ttt.terminal(winner_boardX) assert ttt.winner(winner_boardX) == X assert ttt.utility(winner_boardX) == 1 winner_boardO = deepcopy(empty_board) winner_boardO[0][1] = O winner_boardO[1][1] = O winner_boardO[2][1] = O assert ttt.terminal(winner_boardO) assert ttt.winner(winner_boardO) == O assert ttt.utility(winner_boardO) == -1 winner_board_diagonal = deepcopy(empty_board) winner_board_diagonal[2][0] = O winner_board_diagonal[1][1] = O winner_board_diagonal[0][2] = O winner_board_diagonal[0][0] = X
from tictactoe import X, O, EMPTY, utility tie1 = [[O, X, O], [O, X, O], [X, O, X]] x1 = [[X, X, X], [O, X, O], [X, O, X]] o1 = [[O, O, O], [X, X, O], [X, O, X]] if utility(tie1) == 0: print("Tie test works") else: print("Tie test failed") if utility(x1) == 1: print("X test works") else: print("X test failed") if utility(o1) == -1: print("O test works") else: print("O test failed")
def game(): board = ttt.initial_state() user = input("X or O? ") game_over = ttt.terminal(board) def print_board(board): print("") print(board[0]) print(board[1]) print(board[2]) while game_over is False: """"" If the user is X and the ai is O """ "" if user == "X": player = ttt.player(board) if player == "X": print_board(board) square = int(input("Which square (0-8)? ")) if square < 3 and square > -1 and board[0][square] == None: board = ttt.result(board, ("(0, " + str(square) + ")")) elif square > 5 and square < 9 and board[2][square - 6] == None: board = ttt.result(board, (2, square - 6)) elif square > 2 and square < 6 and board[1][square - 3] == None: board = ttt.result(board, (1, square - 3)) else: print("Try again.\n") game_over = ttt.terminal(board) elif player == "O": board = ttt.result(board, ttt.minimax(board)) game_over = ttt.terminal(board) """"" If the user is O and the ai is X """ "" if user == "O": player = ttt.player(board) if player == "X": board = ttt.result(board, ttt.minimax(board)) game_over = ttt.terminal(board) elif player == "O": print_board(board) square = int(input("Which square (0-8)? ")) if square < 3 and square > -1 and board[0][square] == None: board = ttt.result(board, ("(0, " + str(square) + ")")) elif square > 5 and square < 9 and board[2][square - 6] == None: board = ttt.result(board, (2, square - 6)) elif square > 2 and square < 6 and board[1][square - 3] == None: board = ttt.result(board, (1, square - 3)) else: print("Try again.\n") game_over = ttt.terminal(board) """"" Once the while loop is broken (when a terminal state of the board is reached) then it prints the results of the game """ "" print_board(board) if ttt.utility(board) != 0: if ttt.utility(board) == 1: print("X has won!") else: print("O has won!") else: print("Tie!")
def testUtility(self): self.assertEqual(ttt.utility(board_tie), 0) self.assertEqual(ttt.utility(board_win_horizontally), 1) self.assertEqual(ttt.utility(board_win_vertically), -1) self.assertEqual(ttt.utility(board_win_diagonally), 1)
def test_utility(board, utility): assert tictactoe.utility(board) == utility