def main(): #print(evaluation([['X', 'O', 'X'], ['O', 'X', 'O'], ['X', '', '']])) clock = pygame.time.Clock() game = Game(WIN) run = True while run: z = game.check_if_end() # print(game.copy_board()) if z: print(game.score) pygame.time.wait(500) if game.turn == "O": x = minimax(game.copy_board(), True, 1)[1] game.set_board(x) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False if event.type == pygame.MOUSEBUTTONDOWN: game.select(get_row_col(pygame.mouse.get_pos())) game.draw()
def test_is_winner(self): game = Game() game.grid = [ BoxType.nought, BoxType.cross, BoxType.cross, BoxType.nought, BoxType.empty, BoxType.empty, BoxType.nought, BoxType.empty, BoxType.empty, ] self.assertTrue(game.is_winner) game.grid = [ BoxType.nought, BoxType.cross, BoxType.cross, BoxType.nought, BoxType.nought, BoxType.empty, BoxType.cross, BoxType.nought, BoxType.cross, ] self.assertFalse(game.is_winner)
def test_unsupported_operation_validation(self): game = Game() game.players = [Player, Player] with self.assertRaises(SchemaError) as error: WebsocketHandler.validate_request( json.dumps({ "operation": "foo", "payload": { "turn": 0, }, }), game, ) self.assertEqual(error.exception.code, "Unsupported operation.") result = WebsocketHandler.validate_request( json.dumps({ "operation": "turn", "payload": { "turn": 0, }, }), game, ) self.assertDictEqual( result, { "operation": "turn", "payload": { "turn": 0, }, }, )
class GamePool: _awaiting: Game | None = None def __init__(self, player: Player): self._player: Player = player self._game: Game | None = None async def __aenter__(self) -> Game: if GamePool._awaiting: self._game, GamePool._awaiting = GamePool._awaiting, None self._game.add_player(self._player) self._game.toss() else: self._game = Game() self._game.add_player(self._player) GamePool._awaiting = self._game return self._game async def __aexit__( self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, ) -> None: if GamePool._awaiting is self._game: GamePool._awaiting = None if self._game is not None: if self._game.status == GameStatus.in_progress: self._game.status = GameStatus.unfinished await publish_game_state(self._game) for player in self._game.players: await player.ws.close()
async def __aenter__(self) -> Game: if GamePool._awaiting: self._game, GamePool._awaiting = GamePool._awaiting, None self._game.add_player(self._player) self._game.toss() else: self._game = Game() self._game.add_player(self._player) GamePool._awaiting = self._game return self._game
def test_to_json(self): game = Game() self.assertDictEqual( game.to_json(), { "whose_turn": None, "grid": [BoxType.empty] * Game.grid_size * Game.grid_size, "winner": None, "status": GameStatus.awaiting, }, )
def test_bo_is_not_empty_validation(self): game = Game() game.grid = [BoxType.nought] * Game.grid_size * Game.grid_size with self.assertRaises(SchemaError) as error: WebsocketHandler.validate_request( json.dumps({ "operation": "turn", "payload": { "turn": 0, }, }), game, ) self.assertEqual(error.exception.code, "Box is not empty. Try again.")
def test_turn(self): game = Game() ws = web.WebSocketResponse() game.add_player(Player(id=str(uuid.uuid4()), ws=ws)) game.add_player(Player(id=str(uuid.uuid4()), ws=ws)) game.toss() player = [p for p in game.players if p.id != game.whose_turn.id][0] with self.assertRaises(NotYourTurnError): game.turn(player, 0) player = game.whose_turn game.turn(player, 0) self.assertTrue(game.whose_turn.id != player.id) self.assertEqual(game.grid[0], player.box_type)
def test_turn_without_second_player_validation(self): game = Game() with self.assertRaises(SchemaError) as error: WebsocketHandler.validate_request( json.dumps({ "operation": "turn", "payload": { "turn": 0, }, }), game, ) self.assertEqual(error.exception.code, "Turn is applicable for two players game")
def test_wrong_turn_number_validation(self): game = Game() with self.assertRaises(SchemaError) as error: WebsocketHandler.validate_request( json.dumps({ "operation": "turn", "payload": { "turn": 9, }, }), game, ) self.assertEqual(error.exception.code, "Please type a number from 1 to 9.")
def test_toss(self): game = Game() ws = web.WebSocketResponse() game.add_player(Player(id=str(uuid.uuid4()), ws=ws)) game.add_player(Player(id=str(uuid.uuid4()), ws=ws)) game.toss() for player in game.players: self.assertNotEqual(player.box_type, BoxType.empty) self.assertIn(game.whose_turn, game.players) self.assertEqual(game.status, GameStatus.in_progress)
def main(): dateTimeObj = datetime.now() print(dateTimeObj) xbot = AbBot(Player.x) obot = InvinciBot(Player.o) game = Game(15) print ("abbot (x) vs invincibot (o)") game.simulate(xbot, obot) xbot = InvinciBot(Player.x) obot = AbBot(Player.o) game = Game(15) print ("invincibot (x) vs abbot (o)") game.simulate(xbot, obot) dateTimeObj = datetime.now() print(dateTimeObj)
def main(): try: # Check args for dimension argument board_size = int(sys.argv[sys.argv.index('-d') + 1]) except: if len(sys.argv) > 1: print(f'USAGE: {sys.argv[0]} [-d <board size>]') sys.exit(0) board_size = 3 # Decide who goes first player_turn = coin_flip() if player_turn: print('You are X') else: print('You are O') # Create new Game game = Game(player_turn, board_size) # Keep playing while game has not ended while not game.ended: game.print_board() # Make sure the player inputs a valid move: while True: try: move = int(input('Your turn! Play a space: ')) if move < 0 or move >= len(game.board): raise ValueError if game.board[move] == -1: break print('You cannot choose a non-empty space.') except ValueError: print('Invalid index.') # Update game with chosen move game.player_turn(move) # Print game results print('\n--------------------------\n') print(game.result) game.print_board(print_indices=False)
async def publish_game_state(game: Game) -> None: payload = {"data": {"event": "game_state", "payload": game.to_json()}} await publish(payload, game.players)
def test_missing_key_validation(self): game = Game() with self.assertRaises(SchemaError) as error: WebsocketHandler.validate_request( json.dumps({"operation": "turn"}), game) self.assertEqual(error.exception.code, "Missing key: 'payload'")
def main(): dateTimeObj = datetime.now() print(dateTimeObj) xbot = AbBot(Player.x) obot = RandomBot(Player.o) game = Game(15) print("abbot (x) vs randombot (o)") game.simulate(xbot, obot) xbot = RandomBot(Player.x) obot = AbBot(Player.o) game = Game(15) print("randombot (x) vs abbot (o)") game.simulate(xbot, obot) xbot = AbBot(Player.x) obot = AbBot(Player.o) game = Game(15) print("abbot (x) vs abbot (o)") game.simulate(xbot, obot) dateTimeObj = datetime.now() print(dateTimeObj)
def main(): xbot = RandomBot(Player.x) obot = RandomBot(Player.o) game = Game(1000) game.simulate(xbot, obot)
def main(): xbot = RandomBot(Player.x) obot = OneLayerBot(Player.o) game = Game(1000) print ("randombot (x) vs onelayerbot (o)") game.simulate(xbot, obot) xbot = OneLayerBot(Player.x) obot = RandomBot(Player.o) game = Game(1000) print ("onelayerbot (x) vs randombot (o)") game.simulate(xbot, obot) xbot = OneLayerBot(Player.x) obot = OneLayerBot(Player.o) game = Game(1000) print ("onelayerbot (x) vs onelayerbot (o)") game.simulate(xbot, obot)