def main(): """ create an instance of TicTacToe class""" t = TicTacToe() #get the value of whose turn it is X or O board_state = random.choice([t.STATES.NAUGHT_TURN, t.STATES.CROSS_TURN]) """ use a while loop to intrectively play TicTacToe and save the board state run loop until someone wins or its draw get the valid user input for location in form of row,col call place_marker funtion on user input and print the updated board state """ while board_state != t.STATES.NAUGHT_WON and board_state != t.STATES.CROSS_WON and board_state != t.STATES.DRAW: print(board_state) val = input('Enter location in format row,column:').split(',') turn = 'x' if (board_state == t.STATES.CROSS_TURN) else 'o' row = int(val[0]) col = int(val[1]) if row not in range(0,3) or col not in range(0,3) or t.board[row][col] != ' ': print('Please enter valid location in format row,column') continue board_state = t.place_marker(turn,row,col) print(t.board[0]) print(t.board[1]) print(t.board[2]) print(board_state)
def onObjectTalked(self, obj, phrase): "Callback when an object in the room has been kicked" used = False if obj != None and obj.getName() == "Wizard" and obj.getState( ) == AdventureGameObjectWizard.State.readyForGame: ttt = TicTacToe() winner = ttt.start() if winner == 1: print("\nCongratulations, you won!") print( "Take this magic sword, it will pierce anything, even a troll!" ) print("Good bye now!") print("\nThe wizard teleports away.") self.gameHandler.inventory.add(AdventureGameObjectMagicSword()) self.removeObject("Wizard") elif winner == 2: print("\nThe wizard wins") print( "Just talk to me if you want to try again, I got all the time in the world." ) else: print("\nIt's a tie!") print( "Just talk to me if you want to try again, I got all the time in the world." ) used = True return used
def play_x(board: TicTacToe) -> int: """ Plays the game until a player wins based on the win function :return: The player that won :rtype: int """ while not board.winner and not board.cats: board.make_move(position=get_move(board)) print(f"Player: {board.get_symbol(board.turn % board.players + 2)}") print(board.print_board()) try: move = map( lambda x: int(x), input(">> ").replace("(", "").replace(")", "").split(",")) except (TypeError, ValueError): print("Please use numbers in the form (x,y)") else: if len(list(move)) != 2: print("Please make a move in the form (x,y)") else: valid = board.make_move(position=(next(move), next(move))) print("") print( f"Player {board.get_symbol(player=(board.turn - 1) % board.players + 1)} wins!!" ) print(board.print_board()) return (board.turn - 1) % board.players + 1 if not board.cats else 0
class GameManager_GUI: def __init__(self): self.ttt = TicTacToe() CANVAS_SIZE = 300 self.TILE_SIZE = CANVAS_SIZE / 3 self.root = tkinter.Tk() self.root.title("틱택토") # setTitle이 아닌, 그냥 title self.root.geometry(str(CANVAS_SIZE) + "x" + str(CANVAS_SIZE)) # "300x300" self.root.resizable(width=False, height=False) # 창크기 변경 x self.canvas = tkinter.Canvas(self.root, bg="white", width=CANVAS_SIZE, height=CANVAS_SIZE) self.canvas.pack() self.images = dict() self.images["O"] = tkinter.PhotoImage(file="img/O.gif") self.images["X"] = tkinter.PhotoImage(file="img/X.gif") self.canvas.bind("<Button-1>", self.click_handler) def click_handler(self, event): row = int(event.y // self.TILE_SIZE) # 교과서 : math.floor(event.y / self.TILE_SIZE) col = int(event.x // self.TILE_SIZE) self.ttt.set(row, col) # print(self.ttt) # draw_board() self.draw_board() #check_winner() if self.ttt.check_winner() == "O": messagebox.showinfo("게임오버", "O win !") self.root.quit() elif self.ttt.check_winner() == "X": messagebox.showinfo("게임오버", "X win !") self.root.quit() elif self.ttt.check_winner() == "d": messagebox.showinfo("게임오버", "무승부") self.root.quit() def draw_board(self): # clear self.canvas.delete("all") x = 0 y = 0 for i, v in enumerate(self.ttt.board): if v == ".": pass elif v == "O": self.canvas.create_image(x, y, anchor="nw", image=self.images["O"]) elif v == "X": self.canvas.create_image(x, y, anchor="nw", image=self.images["X"]) x += self.TILE_SIZE if i % 3 == 2: x = 0 y += self.TILE_SIZE def play(self): self.root.mainloop()
def test_result_should_return_dot_if_no_winner(self): game = TicTacToe([ 'XO.', '.Ox', '.X.', ]) self.assertEqual('.', game.result())
def test_result_should_return_winner_if_row_is_complete(self): game = TicTacToe([ 'XXX', '.Ox', '.X.', ]) self.assertEqual('X', game.result())
def test_1(): # random vs random O_win = 0 X_win = 0 draw = 0 for i in range(100): game = TicTacToe() p1 = RandomPlayer(game, 'O') p2 = RandomPlayer(game, 'X') while not game.is_finished(): p1.make_move() p2.make_move() if game.result == 'O': O_win += 1 elif game.result == 'X': X_win += 1 else: draw += 1 print('Random vs random:') print('O: ', O_win) print('X: ', X_win) print('draw: ', draw)
def make_move(self, ttt: TicTacToe): # explore - make a random move if np.random.rand() < self.epsilon: while True: coord = np.random.randint(3, size=2) x = coord[0] y = coord[1] if ttt.make_move(x, y, self.symbol) or ttt.game_over(): return # let the network predict the next move state = ttt.get_state() one_hot = self.one_hot_encoded(state, ttt) values = self.model.predict(np.asarray([one_hot]))[0] high = -1000 # value of field field = -1 # index of field for i in range(len(state)): # select best move if state[i] == 0: if values[i] > high: high = values[i].copy() field = i x = field % 3 y = field // 3 if ttt.make_move(x, y, self.symbol): return else: raise Exception("dafuq?")
def test_3(): # full minimax vs full minimax O_win = 0 X_win = 0 draw = 0 states_tree = minimax_full(State()) for i in range(100): game = TicTacToe() p1 = FullPlayer(game, 'O', states_tree) p2 = FullPlayer(game, 'X', states_tree) while not game.is_finished(): p1.make_move() p2.make_move() if game.result == 'O': O_win += 1 elif game.result == 'X': X_win += 1 else: draw += 1 print('Full minimax vs Full minimax:') print('O: ', O_win) print('X: ', X_win) print('draw: ', draw)
class TicTacToeComprehensiveTestCase(TestCase): def setUp(self): self.game = TicTacToe([ 'XOXOXO', 'O..O.X', '.XXO..', 'OOXO.O', 'X.XO.X', '..XOX.', ]) def test_board_should_be_correct(self): self.assertTrue(self.game.is_correct()) def test_should_not_detect_complete_row(self): self.assertIsNone(self.game.check_rows()) def test_should_not_detect_complete_diagonal(self): self.assertIsNone(self.game.check_diagonals()) def test_should_detect_complete_column(self): self.assertEqual('O', self.game.check_columns()) def test_should_return_winner_based_on_complete_column(self): self.assertEqual('O', self.game.result())
def test_start_game(self): steps_1 = step_gen(["11", "12", "22", "23", "33"]) with patch('builtins.input', lambda :next(steps_1)),\ patch('sys.stdout', StringIO()) as p: self.game.start_game() self.assertEqual(p.getvalue().strip()[-len("Player X won!"):], "Player X won!") self.game = TicTacToe() steps_2 = step_gen(["12", "31", "33", "22", "21", "13"]) with patch('builtins.input', lambda :next(steps_2)),\ patch('sys.stdout', StringIO()) as p: self.game.start_game() self.assertEqual(p.getvalue().strip()[-len("Player O won!"):], "Player O won!") self.game = TicTacToe() steps_3 = step_gen( ["11", "21", "31", "22", "12", "13", "32", "33", "23"]) with patch('builtins.input', lambda :next(steps_3)),\ patch('sys.stdout', StringIO()) as p: self.game.start_game() self.assertEqual(p.getvalue().strip()[-len("Draw!"):], "Draw!")
class Gamemanager: def __init__(self): self.ttt = TicTacToe() def play(self): #show_bord #반복하자 while True: #위치를 입력 받자 row = int(input("row: ")) col = int(input("col: ")) #말을 놓자 self.ttt.set(row,col) print(self.ttt) #check_winner() if self.ttt.check_winner() == "o": print("O 승리,ㅊㅋㅊㅋ") break elif self.ttt.check_winner() == "x": print("x 승리,ㅊㅋㅊㅋ") break elif self.ttt.check_wiiner() == "d": print("무승부") break
def monte_carlo(self, board, depth=None): if depth is None: depth = [] ttt = TicTacToe() ttt.copy(board) # ランダムに自分の一手を行う position = self.pick_one(ttt) ttt.set(position, self.t) if ttt.eval() == TicTacToe.ON_PROGRESS: # 敵の手もランダムに一手を行う t_enemy = TicTacToe.O if self.t == TicTacToe.X else TicTacToe.X position_enemy = self.pick_one(ttt) ttt.set(position_enemy, t_enemy) depth = depth + [position] # 結果を判定。決着がつかないなら再帰的に繰り返す result = ttt.eval() if result != TicTacToe.ON_PROGRESS: return { "position": depth[0], "game_result": result, "moves": depth } return self.monte_carlo(ttt.board, depth)
class GameManager: def __init__(self): self.ttt = TicTacToe() def play(self): print(self.ttt) while True: row = int(input("row : ")) col = int(input("col : ")) self.ttt.set(row, col) print(self.ttt) if self.ttt.check_winner() == "0": print(" O win!!!") break elif self.ttt.chenck_winner() == "X": print("X win!!!") break elif self.ttt.check_winner() == "d": print("무승부") break
class TicTacToeApp(EasyFrame): """Displays a tictactoe board in the window.""" def __init__(self): """Sets up the window and the panels.""" EasyFrame.__init__(self, title="TicTacToe") self.model = TicTacToe() self.addButton("New Game", row=3, column=0, columnspan=3, command=self.newGame) color = "black" number = 0 self.squares = list() for row in range(3): for column in range(3): square = TTTSquare(parent=self, width=50, height=50, background=color, number=number, model=self.model) self.addCanvas(square, row=row, column=column) number += 1 if color == "black": color = "white" else: color = "black" self.squares.append(square) def newGame(self): """Re-starts a new Tic Tac Toe game.""" self.model.newGame() for square in self.squares: square.clear()
def __init__(self): """Sets up the window and the panels.""" EasyFrame.__init__(self, title="TicTacToe") self.model = TicTacToe() self.addButton("New Game", row=3, column=0, columnspan=3, command=self.newGame) color = "black" number = 0 self.squares = list() for row in range(3): for column in range(3): square = TTTSquare(parent=self, width=50, height=50, background=color, number=number, model=self.model) self.addCanvas(square, row=row, column=column) number += 1 if color == "black": color = "white" else: color = "black" self.squares.append(square)
class GameManager: def __init__(self): self.ttt = TicTacToe() def play(self): #show board print(self.ttt) #반복하자 while (True): # 위치를 입력받자 row = int(input("row : ")) col = int(input("col : ")) # 말을 놓자 self.ttt.set(row, col) print(self.ttt) # check_winner() #결과 출력하자 if self.ttt.check_winner() == "O": print("O 승리, ㅊㅋㅊㅋ") break elif self.ttt.check_winner() == "X": print("X 승리, ㅊㅋㅊㅋ") break elif self.ttt.check_winner() == "d": print("무승부") break
def move(): # Get the current state of the game current_state = store.lrange(session['uuid'], 0, -1) current_state.reverse() player_board = json.loads(request.args['board']) player = request.args['player'] # find out if there are more than 1 differences in between the last state and this one if difference(current_state, player_board) > 1: return json.dumps({"status": "NOTVALID"}) # Prevent cheating ai = enemy(player) ttt = TicTacToe(player_board) # Check to see if the game is over after the player made a move gameover = is_gameOver(ttt) if gameover: return json.dumps({"status": "OVER", "winner": gameover}) move = determine_move(ttt, ai) ttt.set_move(move, ai) # Set the new state in the store store.delete(session["uuid"]) store.lpush(session['uuid'], *ttt.get_board()) # check to see if the game is over after the AI made a move gameover = is_gameOver(ttt) if gameover: return json.dumps({"status": "MOVE", "move": str(move), "gameover": True, "winner": gameover}) # Get the next move return json.dumps({"status": "MOVE", "move": str(move), "gameover": False, "winner": None})
def test_dgn_rl(self): """ test the dgn_rl_checker for winning and loosing conditoin """ t = TicTacToe() board: List[List[str]] = [['x', 'o', 'x'], ['o', 'x', 'x'], ['o', 'x', 'x']] self.assertTrue(t.dgn_rl_checker(board) == (False, )) board = [['x', 'o', 'x'], ['o', 'x', 'x'], ['x', ' ', ' ']]
def main(): args = get_args() if args.mode in ('hh', 'hc') and args.quiet: parser.error('--quiet cannot be used with mode set either to hh or hc') if not args.quiet: print("Enter 'name,char' {0}. " "For example, 'John Smith,{1}'".format(CHARS, CHARS[0])) name1, char1 = input('Player1: ').split(',') name2, char2 = input('Player2: ').split(',') else: name1, char1 = 'player1', CHARS[0] name2, char2 = 'player2', CHARS[1] if args.mode == 'hh': player1 = HumanPlayer(name1, char1) player2 = HumanPlayer(name2, char2) elif args.mode == 'hc': player1 = HumanPlayer(name1, char1) player2 = ComputerPlayer(name2, char2) else: player1 = ComputerPlayer(name1, char1, verbose=args.verbose) player2 = ComputerPlayer(name2, char2, verbose=args.verbose) game = TicTacToe(player1, player2, verbose=not args.quiet, record_states=args.record) game.play(args.number)
def test_5(): # random vs minimax depth = 4 O_win = 0 X_win = 0 draw = 0 for i in range(100): game = TicTacToe() p1 = RandomPlayer(game, 'O') p2 = MinimaxPlayer(game, 'X', 4) while not game.is_finished(): p1.make_move() p2.make_move() if game.result == 'O': O_win += 1 elif game.result == 'X': X_win += 1 else: draw += 1 print('Random (O) vs minimax depth = 4 (X):') print('O: ', O_win) print('X: ', X_win) print('draw: ', draw)
def test_recieve_input(self): player = AIPlayer() game = TicTacToe(player, Player()) options = game.possible_movements() action = player.recieve_input(options) self.assertGreaterEqual(action, 0) self.assertLessEqual(action, len(options))
def test_winner(self): game = TicTacToe() assert game.winner() is None for i in range(3): game.turn((0, i)) game.turn((1, i)) assert game.winner() is 1
def test_correct_board_should_return_true_if_board_is_square(self): game = TicTacToe([ '...', '...', '...', ]) self.assertTrue(game.is_correct())
class TestTicTacToe(unittest.TestCase): def setUp(self) -> None: self.game = TicTacToe() def test_set_current_player(self): self.assertIs(self.game.set_current_player(), self.game.player1) # @unittest.skip("WIP") def test_check_draw_condition(self): self.game.board.grid[0][0] = 'X' self.game.board.grid[0][1] = 'X' self.game.board.grid[0][2] = 'X' self.game.board.grid[1][0] = 'O' self.game.board.grid[1][1] = 'X' self.game.board.grid[1][2] = 'O' self.game.board.grid[2][0] = 'X' self.game.board.grid[2][1] = 'O' self.game.board.grid[2][2] = 'X' self.assertTrue(True, self.game.check_draw_condition()) def test_switch_players_turn(self): self.game.switch_players_turn() self.assertEqual(False, self.game.player1.turn) self.assertEqual(True, self.game.player2.turn)
class GameManager: def __init__(self): self.ttt = TicTacToe() def play(self): #게임판 보여주기 print(self.ttt) while True: #row, col 입력받기 row = int(input("row : ")) col = int(input("col : ")) self.ttt.set(row, col) print(self.ttt) #check_winner 면 끝내자 if self.ttt.check_winner() == "o": print("o Win!") break elif self.ttt.check_winner() == "x": print("x Win!") break elif self.ttt.check_winner() == "d": print("무승부") break
def test_check_columns_should_return_none_if_column_is_incomplete(self): game = TicTacToe([ 'X...', 'X...', 'X...', '....', ]) self.assertIsNone(game.check_columns())
def test_naught_won(self): """ test the place_marker for naugth_won state by filling in board """ t = TicTacToe() self.assertEqual(t.place_marker('o', 2, 2), t.STATES.CROSS_TURN) self.assertEqual(t.place_marker('x', 0, 0), t.STATES.NAUGHT_TURN) self.assertEqual(t.place_marker('o', 0, 2), t.STATES.CROSS_TURN) self.assertEqual(t.place_marker('x', 1, 1), t.STATES.NAUGHT_TURN) self.assertEqual(t.place_marker('o', 1, 2), t.STATES.NAUGHT_WON)
def test_policy_to_tensor(self): board = TicTacToe() policy = [((1, 1), 0.1), ((0, 2), 0.9)] expected = np.zeros((3, 3, 1)) expected[1, 1, 0] = 0.1 expected[0, 2, 0] = 0.9 self.assertTrue( np.isclose(board.policy_to_tensor(policy), expected).all())
def test_evaluate_winner_row(self): player1 = Player() game = TicTacToe(player1, Player()) game.player_in_turn = 0 game.board.set_cell(0, 0, "x") game.board.set_cell(0, 1, "x") game.board.set_cell(0, 2, "x") self.assertEqual(player1, game.evaluate_winner())
def test_check_rows_should_return_none_if_row_is_incomplete(self): game = TicTacToe([ 'XXX.', 'X...', '.OOO', '....', ]) self.assertIsNone(game.check_rows())
def test_ai_vs_ai(self): o, x = DepthFirstSearchAI('O'), DepthFirstSearchAI('X') tictactoe = TicTacToe(o, x) while True: score = tictactoe.round() if score is not None: break self.assertEqual(score, 0, "AI vs AI game must always end up in a tie:\n" + str(tictactoe))
def payment(state): game = TicTacToe(state.grid) if game.is_finished(): if game.result == 'O': return 1 if game.result == 'X': return -1 return 0
def simulate(moves, human_first): T = TicTacToe() for move in moves: self.ri.return_value = str(move) moves = [T.human_move, T.computer_move] for i in range(2): moves[(i + human_first) % 2]() winner = T.tic_tac_toe(T.board) if winner: return winner == T.computer or winner == "cat" return True
def post(self): # should run at most 1/s try: tie_counter = 0; Message = "%s%s" % ("Round Start: ", self.request.get('tournament_entries')) print >>sys.stderr, Message #log = TournamentLog(message = Message) #log.put() round_entries = [] print >>sys.stderr, "Round Entries Created" round_winners = [] print >>sys.stderr, "Round Winners Created" round_entries = json.loads(self.request.get('tournament_entries')) print >>sys.stderr, "Round Entries Loaded" while len(round_entries) >= 2: player1 = round_entries.pop() print >>sys.stderr,"Pop" player2 = round_entries.pop() print >>sys.stderr,"Pop" p1_AI = getUserRuleDict(player1, 'tictactoe') p2_AI = getUserRuleDict(player2, 'tictactoe') print >>sys.stderr,"AIs Loaded" result = TicTacToe.runMatch(player1,player2,player1,p1_AI,p2_AI) while result["winner"] == "Tie Game" and tie_counter < 20: result = TicTacToe.runMatch(player1,player2,player1,p1_AI,p2_AI) print >>sys.stderr, "Tie" tie_counter = tie_counter + 1 if result["winner"] == "Tie Game": round_winners.append(player1) else: round_winners.append(str(result["winner"])) #Message = "%s%s" % ("Round Winner: ", str(result["winner"])) print >>sys.stderr, result["winner"] #log = TournamentLog(message = Message) #log.put() # Need to do something about adding basic scores with person who gets the by print >>sys.stderr, "Prepping Exit" by = "None" if len(round_entries) == 1: by = round_entries.pop() Message = "%s%s" % ("Assigning By:", str(by)) print >>sys.stderr, Message #log = TournamentLog(message = Message) #log.put() # Determine if another round is necessary or if winner can be declared print >>sys.stderr, "Exiting" taskqueue.add(url='/score', params={'tournament_entries': json.dumps(round_winners), 'by': by}, countdown=180) except: self.response.clear() self.response.set_status(500) print >>sys.stderr, "Round Interrupted"
def tictactoe(state): len(state) == 9 or abort(404) all(s in 'xo-' for s in state) or abort(404) if (not state.count('x') == state.count('o') and not state.count('x') == state.count('o') + 1): abort(404) board = TicTacToe(state) move = request.args.get('move', '') if move: if board.completed(): abort(422) move = 'abc'.index(move[0]), '012'.index(move[1]) if move not in board.empty(): abort(422) board = board.move(move) return redirect(url_for('tictactoe', state=str(board))) board_dict = { 'class': 'tictactoe-board', 'properties': { 'repr': str(board), 'turn': board.turn(), 'winner': board.winner(), 'completed': board.completed(), 'state': board, }, 'links': [ {'rel': ['self'], 'href': url_for('tictactoe', state=str(board))}, {'rel': ['games'], 'href': url_for('games')} ] } if not board.completed(): board_dict['actions'] = [ { 'name': 'tictactoe-move', 'title': 'Make your move', 'method': 'GET', 'href': url_for('tictactoe', state=str(board)), 'fields': [ { 'name': 'move', 'type': 'select', 'options': [ {'value': 'abc'[r] + str(c)} for r,c in board.empty() ] } ] } ] return jsonify(board_dict)
def _test_local_return(self): appurl = 'DEFAULT_TICTACTOE' function = 'get_new_board' result = TicTacToe.local_return(appurl, function, {}) self.assertEqual(True, 'board' in result) function = 'is_board_valid' next_result = TicTacToe.local_return(appurl, function, result) if not next_result: self.assertTrue(False) function=='is_move_valid' d = {'board':'***/n***/n***', 'move':'X**/n***/n***'} result = TicTacToe.local_return(appurl, function, d) self.assertEqual(True, 'valid' in result)
def get(self): action = self.request.get('action') if action== 'getSystemUserList': users = db.GqlQuery("SELECT * FROM User WHERE type='system'").fetch(5000) result = [] for user in users: result.append([user.id,user.score]) self.response.out.write('{"data":'+json.dumps(result)+'}') if action== 'getHumanUserList': users = db.GqlQuery("SELECT * FROM User WHERE type='user'").fetch(5000) result = [] for user in users: result.append([user.id,user.score]) self.response.out.write('{"data":'+json.dumps(result)+'}') if action== 'getUserList': users = db.GqlQuery("SELECT * FROM User").fetch(5000) result = [] for user in users: result.append([user.id,user.score]) self.response.out.write('{"data":'+json.dumps(result)+'}') if action == 'getStrategy': self.response.out.write(json.dumps(getUserRuleDict(self.request.get('player'),self.request.get('game')))) if action== 'runMatch': result = TicTacToe.runMatches(self.request.get('p1'), self.request.get('p2'), 20) self.response.out.write('{"result":'+json.dumps(result)+'}') if action== 'checkUserName': userName = self.request.get('userName').lower() existingUser = db.GqlQuery("SELECT * FROM User WHERE id=:1",userName).fetch(500) if existingUser: self.response.out.write('Already taken') else: self.response.out.write('Okay')
def __init__(self, player1, player2): self.create() self.layout() self.show() self.player1 = player1 self.player2 = player2 self.tictactoe = TicTacToe()
def post(self): action = self.request.get('action') if action == 'makeNewStrategy': ruleBoardList = eval(self.request.get('ruleBoardList')) # addedRule = TicTacToe.addCustomRule(ruleBoard, self.request.get('title'), self.request.get('desc'), self.request.get('user'), self.request.get('translationInvariant'), self.request.get('flipping'), self.request.get('rowPermutation'), self.request.get('columnPermutation'), self.request.get('rotation')) addedRule = TicTacToe.addCustomRuleList(ruleBoardList, self.request.get('title'), self.request.get('desc'), self.request.get('user')) userAI = getAI(self.request.get('user'),'tictactoe') result = userAI.addRule(addedRule) print >>sys.stderr, json.dumps(result) self.response.out.write(json.dumps(result)) # True or False
def get(self): action = self.request.get('action') if action == 'getStrategy': self.response.out.write(json.dumps(getUserRuleDict(self.request.get('player'),self.request.get('game')))) elif action == 'getPublicStrategyDict': dict = getBuiltInRuleDict(self.request.get('game')) self.response.out.write(json.dumps(dict)) elif action == 'findBestStrategy': result = TicTacToe.findBestStrategy(json.loads(self.request.get('board')),self.request.get('user'),self.request.get('turn')) self.response.out.write(json.dumps(result)) elif action == 'findMatchingStrategy': result = TicTacToe.findMatchingStrategy(json.loads(self.request.get('board')), self.request.get('turn'), self.request.get('loc')) self.response.out.write(json.dumps(result)) elif action == 'enableStrategy': # append a builtIn strategy to the user's AI data result = TicTacToe.activateBuiltInRule(self.request.get('player'), self.request.get('strategyToEnable')) self.response.out.write(json.dumps(result)) elif action == 'deleteRule': # append a builtIn strategy to the user's AI data result = TicTacToe.deleteRule(self.request.get('player'), self.request.get('strategyToDelete')) self.response.out.write(json.dumps(result)) elif action == 'changeOrder': user_id = self.request.get('player') game_title = self.request.get('game') keyStringList = json.loads(self.request.get('newStrategy')) userAI = getAI(user_id,game_title) self.response.out.write(userAI.updateByKeyStringList(keyStringList)) elif action == 'a': self.response.out.write("hi") userAI = AI.get_by_key_name('ingrahaj_tictactoe') print userAI self.response.out.write(userAI.data) elif action == '': self.response.out.write("no action") pass else: self.response.out.write("unrecognized action: "+action) # ignore this pass
def get_message(self, channel, message, user): players = self.user_manager.get_users_mentioned(message) players.add(user) if len(players) > 2: self.msg_writer.send_message( "You may not have more than two players currently", channel ) return tokens = message.split() size = 3 length = 3 match_type = False move = "" for token in tokens: if TicTacToeManager.size_command in token: numbers = re.search(r'\d+', token) if numbers: size = int(re.search(r'\d+', token).group()) elif TicTacToeManager.length_command in token: numbers = re.search(r'\d+', token) if numbers: length = int(re.search(r'\d+', token).group()) elif token == TicTacToeManager.bolton_command: match_type = TicTacToeManager.bolton_command elif token == TicTacToeManager.pvp_command: match_type = TicTacToeManager.pvp_command else: move = token if match_type: game = TicTacToe(size, length, match_type, players) self.game_manager.add_game( game, players, channel, TicTacToeManager.name ) self.msg_writer.send_message(game.starting_message(), channel) else: self.game_manager.process_message( players, channel, TicTacToeManager.name, move, user )
def get(self): ''' this signup module will receive ajax call from lobby.html ''' # read given user id and password # create User object defined in datastore.py # assign usr id and password and save it # send back success message print >>sys.stderr, "Sign up process start" namePattern = re.compile(r"[a-zA-Z][a-zA-Z0-9]{2,16}$") id = self.request.get('id') if namePattern.match(self.request.get('id'))==None: self.response.out.write("User name(3~16 characters) should contain only alphabets and numbers(not for the first character).") return existingUser = db.GqlQuery("SELECT * FROM User WHERE id=:1",id).get() if existingUser: self.response.out.write(id+" already exists. Try a different name please.") return user = User(key_name=id, id = id, email = self.request.get('email'), type = 'user', password = self.request.get('password'), botKind = self.request.get('botKind'), botName = self.request.get('botName'), score = 0) result = user.put() print >>sys.stderr, result if result: AI(key_name=id+"_tictactoe", user = id, game = "tictactoe").put() TicTacToe.activateBuiltInRuleByTitle(id, 'Take Random') self.sess = sessions.Session() self.sess['loggedInAs'] = user.id; self.response.out.write("yes") return else: self.response.out.write("no") return
def instance(name, bot, exploratory, rounds): print("task: name:", name, "bot:", bot, "exploratory:", exploratory, "rounds:", rounds) start_time = time.process_time() env = environment.Environment(discount=1.0, q_init=0.5) first_player = player.Player(name=1, exploratory=exploratory, environment=env) second_player = player.Player(name=2, exploratory=exploratory, environment=env) first_bot = bot(environment=env, player=first_player) second_bot = bot(environment=env, player=second_player) game = TicTacToe() # play the first bot against the second bot, self learning !! # the game should last .. long # report every 1000 rounds report = 1000 # play until ends # the first bot makes move, alternate this afterwards start_turn = first_bot.player.name for round in range(rounds): # do the training # playing against each other # from the start # the players will alternatively begin game.restart(start=start_turn) whose_turn = start_turn start_turn = start_turn % 2 + 1 first_bot.restart() second_bot.restart() while not game.is_end(): # keep playing # the first bot makes move if first_bot.player.name is whose_turn: current_bot = first_bot else: current_bot = second_bot current_state = game.table action = current_bot.take_turn(current_state) # next player comes into play whose_turn = whose_turn % 2 + 1 game.turn(action) # make the robot to learn something a bit # this will make the bots learn about the result of the game current_state = game.table first_bot.take_turn(current_state) second_bot.take_turn(current_state) if round % report is 0: # make report print("exploratory : ", exploratory, "percent: ", round / rounds * 100) # write the q_table into a file # only the fist_bot is important filename = "results/" + name + "-" + str(exploratory) + "-" + str(rounds) + ".txt" print("saving into file:", filename) json.dump(first_bot.q_table, open(filename, "w")) print("finished exploratory: ", exploratory, " time: ", time.process_time() - start_time) return 0
def best_move(tictactoe: TicTacToe, recursion_level: int=1) -> Tuple[int, TicTacToe.Tile]: best_score, best_tile = -math.inf, None for tile in tictactoe.choices(): tictactoe.set(tile) score = tictactoe.score(tile) if score is None: opponent_score, opponent_tile = best_move(tictactoe, recursion_level + 1) score = -opponent_score else: score /= recursion_level if score > best_score: best_score, best_tile = score, tile tictactoe.unset(tile) return best_score, best_tile
from tictactoe import TicTacToe t = TicTacToe() t.go()
proj_root = normpath(join(abspath(sys.path[0]), "../../../..")) sys.path.append(join(proj_root, "clients/Python")) sys.path.append(join(proj_root, "samples/tictactoe/clients/Python")) import grebe from tictactoe import TicTacToe if not (3 <= len(sys.argv) <= 4): print("Invalid number of args", file=sys.stderr) sys.exit(1) username = sys.argv[1] server = sys.argv[2] port = int(sys.argv[3]) if len(sys.argv) == 4 else 13579 client = TicTacToe(server, port) open_cells = [(r, c) for r in (1, 2, 3) for c in (1, 2, 3)] try: role, _, _ = client.login(username, "") if role == "P1": move = random.choice(open_cells) open_cells.remove(move) client.move(*move) while True: p1move, p2move = client.waitForNextTurn() opmove = p2move if role == "P1" else p1move open_cells.remove(opmove)
sys.path.append(os.path.abspath('../tic-tac-toe-thegame')) from tictactoe import TicTacToe __author__ = 'phizaz' bot_desc = { 'name': 'BotRLBetterDiscovery', 'exploratory': 1, 'rounds': 100000, } bot = Bot(name=1, q_table=Tools.load_source(bot_desc)) # bot starts first, but alternatively afterwards start_turn = bot.name while True: game = TicTacToe() game.restart(start=start_turn) whose_turn = start_turn start_turn = start_turn % 2 + 1 print('game start : ') while True: if whose_turn is bot.name: # bot action action = bot.take_turn(game.table) else: # user action action = (int(input('row:')), int(input('col:'))) game.turn(action) game.display() whose_turn = whose_turn % 2 + 1
class TestTicTacToe(unittest.TestCase): def setUp(self): self.T = TicTacToe() __builtins__.raw_input = Mock() self.ri = __builtins__.raw_input def tearDown(self): self.T = None def test_human_move_char(self): """Test that the human_move does not accept input outside of range""" self.ri.return_value = "c" assert False == self.T.human_move() def test_human_move_taken(self): self.T.board[0][0] = "x" self.ri.return_value = "0" assert False == self.T.human_move() def test_human_move_acceptable(self): """Test that the human_move accepts all possible input""" for i in range(9): self.ri.return_value = str(i) T = TicTacToe() assert self.T.human_move() == True T = None def test_win(self): """Test that a winner is detected""" self.T.board[0] = ["x"] * 3 assert self.T.tic_tac_toe(self.T.board) def test_winner_1(self): """Horizontal winner found""" self.T.board[0] = ["x"] * 3 assert self.T.tic_tac_toe(self.T.board)[0][0] == "x" def test_winner_2(self): """Vertical winner found""" self.T.board[0][0] = self.T.board[1][0] = self.T.board[2][0] = "x" assert self.T.tic_tac_toe(self.T.board) == "x" def test_winner_3(self): """Diagonal winner found""" self.T.board[0][2] = "o" self.T.board[1][1] = "o" self.T.board[2][0] = "o" assert self.T.tic_tac_toe(self.T.board) == "o" def sim(self, prep, win): for move in prep: self.T.board[move[0]][move[1]] = "x" assert win == self.T.win(self.T.board, "x") # test win possibilities def test_win_top_row(self): self.sim(((0, 1), (0, 2)), (0, 0)) def test_win_mid_row(self): self.sim(((1, 0), (1, 2)), (1, 1)) def test_win_bottom_row(self): self.sim(((2, 0), (2, 1)), (2, 2)) def test_win_left_col(self): self.sim(((0, 1), (0, 2)), (0, 0)) def test_win_mid_col(self): self.sim(((1, 0), (1, 2)), (1, 1)) def test_win_right_col(self): self.sim(((2, 0), (2, 1)), (2, 2)) def test_win_first_diag(self): self.sim(((0, 0), (1, 1)), (2, 2)) def test_win_second_diag(self): self.sim(((0, 2), (2, 0)), (1, 1)) # Test fork def test_fork_1(self): self.T.board[0][1] = "x" self.T.board[1][0] = "x" self.T.board[0][0] = "o" assert self.T.fork(self.T.board, "x") == (1, 1) def test_fork_2(self): self.T.board[0][0] = "x" self.T.board[2][2] = "x" self.T.board[1][1] = "o" self.T.board[0][2] = "o" assert self.T.fork(self.T.board, "x") == (2, 0) def test_block_fork_1(self): self.T.board[0][0] = "x" self.T.board[2][2] = "x" self.T.board[1][1] = "o" assert self.T.bock_fork() == (0, 1) def test_block_fork_1(self): self.T.board[0][1] = "x" self.T.board[1][0] = "x" self.T.board[1][1] = "o" assert self.T.block_fork() == (0, 0) def test_center(self): assert self.T.center() == (1, 1) def test_opposite_corner_1(self): self.T.board[0][0] = "x" assert self.T.opposite_corner() == (2, 2) def test_opposite_corner_2(self): self.T.board[2][0] = "x" assert self.T.opposite_corner() == (0, 2) def test_empty_corner_1(self): assert self.T.empty_corner() == (0, 0) def test_empty_corner_2(self): self.T.board[0][0] = "x" self.T.board[0][2] = "x" assert self.T.empty_corner() == (2, 0) def test_empty_side_1(self): self.T.board[0][1] = "x" assert self.T.empty_side() == (1, 0)
def initGame(self): self.player = QTicTacToe.QPlayer('O') ArtificialIntelligence = QTicTacToe.AIs["Depth First Search AI"] self.ai = ArtificialIntelligence('X') self.ticTacToe = TicTacToe(o=self.player, x=self.ai)
def play(self, scenario: List[str], o: TicTacToe.Player, x: TicTacToe.Player): tictactoe = TicTacToe.build(scenario, o=o, x=x) tile = x.play() correct = self.find(scenario, '#') self.assertEqual((tile.row, tile.column), correct)
class TicTacToeBoard(object): def __init__(self, player1, player2): self.create() self.layout() self.show() self.player1 = player1 self.player2 = player2 self.tictactoe = TicTacToe() def create(self): self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_default_size(400, 400) self.window.connect("destroy", self.destroy) self.window.connect("delete_event", self.delete_event) self.table = gtk.Table(rows=3, columns=3, homogeneous=True) self.buttons = [gtk.Button(label=" - ") for i in xrange(9)] for index, button in enumerate(self.buttons): button.position = index button.connect('clicked', self.button_clicked) def layout(self): for i in xrange(3): for j in xrange(3): self.table.attach(self.buttons[i * 3 + j], j, j + 1, i, i + 1) self.window.add(self.table) def show(self): for button in self.buttons: button.show() self.table.show() self.window.show() def is_gameover(self): if self.tictactoe.is_gameover(): if self.tictactoe.winner == self.player1.marker: msg = 'You wins!' elif self.tictactoe.winner == self.player2.marker: msg = 'Computer wins!' else: msg = 'Game over with Draw' md = gtk.MessageDialog(self.window, 0, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, msg) md.run() md.destroy() return True return False def button_clicked(self, widget): if not self.is_gameover(): if widget.position not in self.tictactoe: md = gtk.MessageDialog(self.window, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, "Invalid move. Retry") md.run() md.destroy() else: widget.set_label(self.player1.marker) self.tictactoe.mark(self.player1.marker, widget.position) if not self.is_gameover(): move_position, _ = self.player2.maximized_move( self.tictactoe) self.tictactoe.mark(self.player2.marker, move_position) self.buttons[move_position].set_label(self.player2.marker) self.is_gameover() def destroy(self, widget, data=None): gtk.main_quit() def delete_event(self, widget, event, data=None): return False def play(self): gtk.main()
def setUp(self): self.T = TicTacToe() __builtins__.raw_input = Mock() self.ri = __builtins__.raw_input
import random from board import Board from randomai import RandomAI from pseudorandomai import PseudoRandomAI from humanai import HumanAI from tictactoe import TicTacToe if __name__ == "__main__": while True: board = Board() ttt = TicTacToe() print "Choose the match-up:" print "Type 1 for Random AI v/s Pseudo Random AI" print "Type 2 for Pseudo Random AI v/s Pseudo Random AI" print "Type 3 for Random AI v/s You" print "Type 4 for Pseudo Random AI v/s You" print "Type 5 for a 2 player game" choice = int( raw_input( "Type in your choice: ")) if choice == 1: ttt.start(board, RandomAI(), PseudoRandomAI()) elif choice == 2: ttt.start(board, PseudoRandomAI(), PseudoRandomAI()) elif choice == 3: humanPlayer = HumanAI() ttt.start(board, RandomAI(), humanPlayer) elif choice == 4: humanPlayer = HumanAI() ttt.start(board, humanPlayer, PseudoRandomAI()) elif choice == 5: humanPlayer1 = HumanAI() humanPlayer2 = HumanAI()
def __init__(self, h=7, v=6, k=4): TicTacToe.__init__(self, h, v, k)
class QTicTacToe(QWidget): class QTileButton(QPushButton): SymbolMap = {'-': " ", 'O': "◯", 'X': "☓"} def __init__(self, parent, tile): super(QTicTacToe.QTileButton, self).__init__(parent) self.tile = tile self.setFocusPolicy(Qt.NoFocus) self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) self.setContextMenuPolicy(Qt.CustomContextMenu) def clickEvent(self): self.parent().round(self.tile) self.repaint() def marked(self): self.setEnabled(self.tile.player is None) self.setText(self.SymbolMap[str(self.tile)]) self.update() def resizeEvent(self, resizeEvent: QResizeEvent): font = self.font() font.setBold(True) font.setPixelSize(round(0.50 * min(self.width(), self.height()))) self.setFont(font) def sizeHint(self) -> QSize: return QSize(40, 40) class QPlayer(TicTacToe.Player): tile = None def play(self): return self.tile AIs = {"Depth First Search AI": DepthFirstSearchAI} def __init__(self): super(QTicTacToe, self).__init__() self.ticTacToe = None self.player, self.ai = None, None self.initGame() self.initUI() self.show() def initGame(self): self.player = QTicTacToe.QPlayer('O') ArtificialIntelligence = QTicTacToe.AIs["Depth First Search AI"] self.ai = ArtificialIntelligence('X') self.ticTacToe = TicTacToe(o=self.player, x=self.ai) def initUI(self): self.setWindowTitle(self.tr("Tic-Tac-Toe")) layout = QVBoxLayout() self.setLayout(layout) gridLayout = QGridLayout() gridLayout.setSpacing(3) aiComboBox = QComboBox(self) aiComboBox.addItems([self.tr(ai) for ai in self.AIs]) aiComboBox.currentTextChanged.connect(self.selectAI) layout.addWidget(aiComboBox) layout.addLayout(gridLayout) for tile in self.ticTacToe: button = QTicTacToe.QTileButton(self, tile) gridLayout.addWidget(button, tile.row, tile.column) button.clicked.connect(button.clickEvent) tile.delegate = button def round(self, tile: TicTacToe.Tile): QApplication.setOverrideCursor(Qt.WaitCursor) self.player.tile = tile score = self.ticTacToe.round(True) QApplication.restoreOverrideCursor() if score is not None: if score == +1: QMessageBox.information(self, self.tr("Victory!"), self.tr("You won :)"), QMessageBox.Ok) if score == 0: QMessageBox.warning(self, self.tr("Tie!"), self.tr("You tied :|"), QMessageBox.Ok) if score == -1: QMessageBox.critical(self, self.tr("Defeat!"), self.tr("You lost :("), QMessageBox.Ok) self.ticTacToe.reset(True) def selectAI(self, name: str): ArtificialIntelligence = QTicTacToe.AIs[name] self.ai = ArtificialIntelligence(self.ticTacToe, self.ai.symbol) self.ticTacToe.x = self.ai def sizeHint(self) -> QSize: return QSize(180, 220)
def _test_get_players(self): result = TicTacToe.get_players() self.assertEqual(True, len(result)>0)
from tictactoe import TicTacToe game = TicTacToe() game.run()
def test_display(self): game = TicTacToe() for i in range(3): game.turn((0, i)) game.turn((1, i)) game.display()