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)