def test_invalid_move_invalid_player(self):
board = Board()
game = Game(board=board, player_1='X', player_2='O')
self.assertEqual(game.next_turn(), 'X')
with self.assertRaises(InvalidMovementException):
game.move('L', row=0, col=0)
def test_init_game():
game = Game(2, "X", "MEOW", "KOTIK")
assert len(game.field) == 2
assert game.field == [["", ""], ["", ""]]
assert game.side == "X"
assert game.gamer_name == "MEOW"
assert game.enemy_name == "KOTIK"
def main():
size = int(input("Board size: "))
num_to_win = int(input("Number to win: "))
stats = {'turn':[], 'runtime':[], 'states_visited':[]}
print("Choosing player X...")
player_x = _pick_agent(Player.X, size, stats=stats)
print("Choosing player O...")
player_o = _pick_agent(Player.O, size, stats=stats)
play = "y"
wins = [0] * 3
while play == "y":
game = Game(player_x, player_o, size, num_to_win)
wins[game.play()] += 1
print("x: {} | o: {} | {} draws".format(wins[Player.X],wins[Player.O],wins[2]))
play = input("Play again? y/[n]: ")
if input("Save data? y/[n]: ") == "y":
folder = "plots/" + input("folder: plots/")
os.mkdir(folder)
ax = sns.violinplot(x="turn", y="runtime", data=stats)
ax.set(xlabel='turn', ylabel='runtime (seconds)')
plt.tight_layout()
plt.savefig(folder + "/runtime")
plt.cla()
ax = sns.violinplot(x="turn", y="states_visited", data=stats)
ax.set(xlabel='turn', ylabel='states visited')
plt.savefig(folder + "/states_visited")
stats_file = open(folder + '/stats', 'w')
df = DataFrame(stats)
means = df.groupby(['turn']).mean()
stats_file.write("Average runtime per turn:\n")
for i in range(len(means)):
stats_file.write("(%d,%f)\n"%(i+1, means['runtime'].loc[i+1].item()))
stats_file.write("\n")
stats_file.write("Average number of states visited per turn (if applicable)\n")
for i in range(len(means)):
try:
stats_file.write("(%d,%d)\n"%(i+1, means['states_visited'].loc[i+1].item()))
except:
pass
stats_file.write("\n")
stats_file.write("Frequency of turns:\n")
for i in range(max(stats['turn'])):
stats_file.write("(%d,%d)\n"%(i+1,stats['turn'].count(i+1)))
stats_file.write("\n")
stats_file.write("x wins: %d\n" % wins[Player.X])
stats_file.write("o wins: %d\n" % wins[Player.O])
stats_file.write("draws: %d\n" % wins[2])
stats_file.close()
def setUp(self):
self.game = Game()
assert (self.game.get_players() == [])
self.game._players[X] = X_TOKEN
assert (self.game.get_players() == [X])
self.game._players[O] = O_TOKEN
assert (self.game.get_players() == [X, O])
def test_win(player_obj):
game = Game(*player_obj)
game.start_game()
assert game.set_move(game.get_current_player(), 0, 0) is False
assert game.set_move(game.get_current_player(), 1, 0) is False
assert game.set_move(game.get_current_player(), 1, 1) is False
assert game.set_move(game.get_current_player(), 2, 0) is False
assert game.set_move(game.get_current_player(), 2, 2) is not False
def test_draw(capsys):
game = Game(4, "X", "MEOW", "KOTIK")
game.move(0, 0, "X")
game.move(0, 2, "O")
game.move(1, 0, "O")
game.move(1, 1, "X")
game.move(2, 2, "O")
assert (
game.draw() ==
" | 1 | 2 | 3 | 4 \nA | X O \nB | O X \nC | O \nD | \n"
)
def test_create_a_game_and_public_interface(self):
board = Board()
game = Game(board=board, player_1='X', player_2='O')
self.assertFalse(game.is_finished())
self.assertFalse(game.has_winner())
self.assertFalse(game.is_tied())
self.assertIsNone(game.get_winner())
self.assertEqual(game.next_turn(), 'X')
self.assertEqual(game.board, board)
def test_check_winner_returns_false(self):
board = Board([
[None, None, None],
['X', None, 'O'],
[None, 'X', None],
])
game = Game(board=board, player_1='X', player_2='O')
self.assertFalse(game.is_finished())
self.assertFalse(game.has_winner())
self.assertFalse(game.is_tied())
self.assertIsNone(game.get_winner())
def test_check_winner_returns_true_second_diagonal(self):
board = Board([
[None, None, 'X'],
[None, 'X', None],
['X', 'O', 'O'],
])
game = Game(board=board, player_1='X', player_2='O')
self.assertTrue(game.is_finished())
self.assertTrue(game.has_winner())
self.assertFalse(game.is_tied())
self.assertEqual(game.get_winner(), 'X')
def test_game_is_tied(self):
board = Board([
['O', 'X', 'X'],
['X', 'O', 'O'],
['X', 'O', 'X'],
])
game = Game(board=board, player_1='X', player_2='O')
self.assertTrue(game.is_finished())
self.assertFalse(game.has_winner())
self.assertTrue(game.is_tied())
self.assertIsNone(game.get_winner())
def init_game(sock: socket.socket, field_size: int, gamer_name: str) -> Game:
while True:
data = sock.recv(BUFFER_SIZE)
command, *arguments = data.decode("utf-8").split(" ")
if command == "HELO":
enemy_name = " ".join(arguments)
sock.sendall(
f"HELO {gamer_name} {field_size}x{field_size}".encode("utf-8"))
return Game(field_size, OWN_SIDE, gamer_name, enemy_name)
else:
raise WrongCommand
def test_invalid_move_game_over_game_is_tied(self):
board = Board([
['O', 'X', 'X'],
['X', 'O', 'O'],
['X', 'O', 'X'],
])
game = Game(board=board, player_1='X', player_2='O')
self.assertTrue(game.is_finished())
self.assertFalse(game.has_winner())
self.assertTrue(game.is_tied())
self.assertIsNone(game.get_winner())
with self.assertRaises(InvalidMovementException):
game.move('X', row=0, col=0)
def main():
print("Choosing player X...")
player_x = _pick_agent(Player.X)
print("Choosing player O...")
player_o = _pick_agent(Player.O)
play = "y"
while play == "y":
game = Game(player_x, player_o)
game.play()
print("check", Game.end_value)
play = input("Play again? y/[n]: ")
print("Averge move time for x: ", x_average_move_time())
print("Averge move time for o: ", o_average_move_time())
def test_invalid_move_game_has_winner(self):
board = Board([
['X', None, None],
['O', 'X', None],
[None, 'O', 'X'],
])
game = Game(board=board, player_1='X', player_2='O')
self.assertTrue(game.is_finished())
self.assertTrue(game.has_winner())
self.assertFalse(game.is_tied())
self.assertEqual(game.get_winner(), 'X')
self.assertEqual(game.next_turn(), 'X')
with self.assertRaises(InvalidMovementException):
game.move('X', row=0, col=2)
def main():
print("Choosing player X...")
player_x = _pick_agent(Player.X)
print("Choosing player O...")
player_o = _pick_agent(Player.O)
size = int(input("Select size of the board >= 3: "))
print("Select number in a row to win, <=",size,": ", end = '')
to_win = int(input(""))
random_board = input("Random board state? y/[n]:")
play = "y"
games = 0
while play == "y":
if(random_board == "y"):
game_board = Board(size, to_win)
game_board.randomize()
winner = game_board.winner
while(winner is not None):
game_board = Board(size, to_win)
game_board.randomize()
winner = game_board.winner
else:
game_board = None
game = Game(player_x, player_o, size, to_win, game_board)
res = game.play()
games += 1
RESULTS[res + 1][1] += 1
for line in RESULTS:
print(*line)
print("")
print("X average runtime: ",player_x.average_runtime)
print("O average runtime: ",player_o.average_runtime)
print("States visited X", player_x.states_visited)
print("States visited O", player_o.states_visited)
play = input("Play again? y/[n]: ")
def games_before_winning_move_and_moves():
empty_grid = [[None] * 3 for _ in range(3)]
result = []
for bot_turn in [0, 1]:
for line in LINES:
for free_cell_idx in range(3):
winning_move = line[free_cell_idx]
grid_with_winning_line = copy.deepcopy(empty_grid)
for i in range(3):
if i != free_cell_idx:
grid_with_winning_line[line[i][0]][line[i]
[1]] = bot_turn
for grid in get_positions_with_one_winning_move(
grid_with_winning_line, bot_turn, line):
game = Game()
game.grid = grid
game.human = 1 - bot_turn
result.append((game, winning_move))
return result
def test_game_makes_valid_moves(self):
board = Board()
game = Game(board=board, player_1='X', player_2='O')
# === First Move ===
self.assertEqual(game.next_turn(), 'X')
game.move('X', row=0, col=0)
row_0 = game.board.get_row(0)
self.assertEqual(row_0, ['X', None, None])
row_1 = game.board.get_row(1)
self.assertEqual(row_1, [None, None, None])
row_2 = game.board.get_row(2)
self.assertEqual(row_2, [None, None, None])
# === Second Move ===
self.assertEqual(game.next_turn(), 'O')
game.move('O', row=1, col=1)
row_0 = game.board.get_row(0)
self.assertEqual(row_0, ['X', None, None])
row_1 = game.board.get_row(1)
self.assertEqual(row_1, [None, 'O', None])
row_2 = game.board.get_row(2)
self.assertEqual(row_2, [None, None, None])
# === Third Move ===
self.assertEqual(game.next_turn(), 'X')
game.move('X', row=2, col=1)
row_0 = game.board.get_row(0)
self.assertEqual(row_0, ['X', None, None])
row_1 = game.board.get_row(1)
self.assertEqual(row_1, [None, 'O', None])
row_2 = game.board.get_row(2)
self.assertEqual(row_2, [None, 'X', None])
def game():
global games
if request.method == POST:
if TOKEN not in request.json:
return "expected token", 404
token = request.json[TOKEN]
if users.get(token) == None:
return "invalid token", 404
game = Game()
game_uuid = uuid4().__str__()
games[game_uuid] = game
return game_uuid, 201
elif request.method == GET:
return jsonify(list(games.keys()))
return f"{request.method} not implemented", 405
def main():
clock = pygame.time.Clock()
game = Game(WIN)
while game.is_active:
clock.tick(FPS)
if game.turn == RED:
_, new_board = minimax(game.get_board(), 3, False)
game.ai_move(new_board)
for event in pygame.event.get():
if event.type == pygame.QUIT:
game.is_active = False
elif event.type == pygame.MOUSEBUTTONDOWN:
x, y = pygame.mouse.get_pos()
row, col = get_row_col_from_mouse(x, y)
game.is_active = game.play(row, col)
game.update()
pygame.quit()
print("Choosing player O...")
player_o = _pick_agent(Player.O)
play = "y"
num_simulations = 1
num_times = int(input("How many simulations?: "))
performance = Performance()
num_x_wins = 0
num_o_wins = 0
num_draws = 0
player_x_total_time = 0
player_o_total_time = 0
while play == "y":
for i in range(num_times):
game = Game(player_x, player_o)
performance = game.play(board_size, k, random_state)
num_x_wins += performance.num_x_wins
num_o_wins += performance.num_o_wins
num_draws += performance.num_draws
player_x_total_time += performance.player_x_total_time
player_o_total_time += performance.player_o_total_time
if num_times > 1:
#stats for carrying out multiple simulations
player_x_average_runtime = player_x_total_time / num_times
player_o_average_runtime = player_o_total_time / num_times
print("Player X's average runtime over " + str(num_simulations) +
" simulations was " + str(player_x_average_runtime) + " seconds")
print("Player O's average runtime over " + str(num_simulations) +
import tkinter as tk
from tic_tac_toe.frame import MainFrame
from tic_tac_toe.game import Game
def set_window(root):
root.title('tic-tac-toe')
root.geometry('310x310+200+200')
root.resizable(False, False)
if __name__ == '__main__':
game = Game()
root = tk.Tk()
set_window(root)
frame = MainFrame(root, game)
root.mainloop()
def test_check_winner_draw_or_no_yet_winner(moves, winner_expected):
game = Game(3, "X", "MEOW", "KOTIK")
for i in moves:
x, y, z = i
game.move(x, y, z)
assert game.check_winner() == winner_expected
def setUp(self):
self.the_game = Game()
def game_obj(player_obj):
return Game(*player_obj)
if action == 'q':
sys.exit(0)
if action == 's':
player1 = input('Enter player1 name: ')
player2 = input('Enter player2 name: ')
p1 = Player(str(player1))
p2 = Player(str(player2))
# Game session loop
game_session_flag = True
while game_session_flag:
# Init game
game = Game(p1, p2)
game.start_game()
# Current game data
last_move = ['', '']
winner = False
messages = []
current_game_flag = True
# Current game loop
while current_game_flag:
# Show current game
flag = show_game(game, last_move, winner, messages)
if flag:
break
elif not flag and flag is not None:
def setUp(self):
self.player_x = DummyAgent()
self.player_o = DummyAgent()
self.game = Game(self.player_x, self.player_o, verbose=False)
"""
A command-line game of tic-tac-toe written in python 2.7.
Main objects are Game for game control, Player for player moves
(including AIPlayer for computer play), and io to handle
everything related to display and input.
"""
from tic_tac_toe.game import Game, GameTied, InvalidMove
from tic_tac_toe.player import Player
from tic_tac_toe.ai_player import AIPlayer
from tic_tac_toe import io
import sys
# Initialize objects
game = Game(3)
players = [Player('X'), AIPlayer('O')]
playing = True # Main loop control needed to break out of multiple levels
io.init()
# Main game loop
while playing:
io.print_board(game)
try:
for player in players:
player.make_move(game)
if game.check_winner(player.symbol):
io.print_board(game)
if players.index(player) == 0:
io.winner()
else:
def test_move_raises_wrong_move_exception_cell_already_taken():
game = Game(2, "X", "MEOW", "KOTIK")
game.move(1, 1)
with pytest.raises(WrongMove) as excinfo:
game.move(1, 1)
assert "Эта клетка уже занята" in str(excinfo.value)
def test_move_success():
game = Game(2, "X", "MEOW", "KOTIK")
game.move(1, 1)
assert game.field[1][1] == game.side
def test_move_raises_wrong_move_exception_cell_not_found(moves, error_message):
game = Game(2, "X", "MEOW", "KOTIK")
with pytest.raises(WrongMove) as excinfo:
x, y = moves
game.move(x, y)
assert "Такой клетки не существует" in str(excinfo.value)
