def provide_game_info():
try:
out = WebOut()
resp_string = out.display_greetings_and_game_info().replace(
"\n", "<br>")
conn = sqlite3.connect('game.db')
cur = conn.cursor()
cur.execute("SELECT * FROM game_state")
game_data = cur.fetchone()
current_turn_squares = list(game_data[4])
board = Board()
board.set_all_squares(current_turn_squares)
resp_string += "<br>" + \
out.display_board(board.squares, 9 - len(board.get_empty_square_positions())).replace("\n", "<br>")
resp = make_response(resp_string, 200)
return resp
except Exception as e:
print(e)
finally:
conn.close()
def __init__(self):
self.board = Board()
self.out = SimpleStdOut()
self.input = SimpleStdIn()
# In random against random, player 'O' moves first
self.current_turn_token = O_TOKEN
self.referee = Referee()
self.round = None
def test_getting_empty_positions(self):
squares = ['X', '-', '-', 'X', '-', '-', 'O', '-', '-']
board = Board()
board.set_all_squares(squares)
expected_empty_squares = [1, 2, 4, 5, 7, 8]
self.assertEqual(expected_empty_squares,
board.get_empty_square_positions())
def handle_move():
conn = sqlite3.connect('game.db')
cur = conn.cursor()
try:
# {'token': 'O', 'square': '3'}
data_dict = request.get_json()
if 'reset' in data_dict:
cur.execute(
"UPDATE game_state SET current_turn_token='O', current_board_squares='---------'"
)
conn.commit()
return 'Board reset'
token = data_dict['token']
square = int(data_dict['square'])
# INITIAL GAME STATE
# sqlite> select * from game_state;
# game_id player_one_token player_two_token current_turn_token current_board_squares
# ---------- ---------------- ---------------- ------------------ ---------------------
# 1 O X O ---------
cur.execute("SELECT * FROM game_state")
game_data = cur.fetchone()
current_turn_token = game_data[3]
if token != current_turn_token:
return 'Not your turn yet'
opponent_token = X_TOKEN if token == O_TOKEN else O_TOKEN
current_turn_squares = list(game_data[4])
board = Board()
board.set_all_squares(current_turn_squares)
if square not in board.get_empty_square_positions():
return 'Square taken'
referee = Referee()
if referee.is_winner(board, token) or referee.is_winner(
board, opponent_token):
return 'Game over, send reset'
current_turn_squares[square] = token
# can add WHERE game_id=1
cur.execute("UPDATE game_state SET current_board_squares='" +
''.join(current_turn_squares) + "'")
cur.execute("UPDATE game_state SET current_turn_token='" +
opponent_token + "'")
conn.commit()
return 'Move accepted'
except Exception as e:
traceback.print_exc()
finally:
conn.close()
def test_board_partially_full(self):
squares = ['X', '-', '-', 'O', '-', '-', '-', '-', '-']
board = Board()
board.set_all_squares(squares)
self.assertFalse(board.is_board_empty())
self.assertFalse(board.is_board_full())
class Game:
def __init__(self):
self.board = Board()
self.out = SimpleStdOut()
self.input = SimpleStdIn()
# In random against random, player 'O' moves first
self.current_turn_token = O_TOKEN
self.referee = Referee()
self.round = None
def switch_turns(self):
if self.current_turn_token == O_TOKEN:
self.current_turn_token = X_TOKEN
return
self.current_turn_token = O_TOKEN
def is_game_over(self):
return self.referee.is_winner(self.board, self.current_turn_token) or \
self.board.is_board_full()
def annouce_result(self):
if self.referee.is_winner(self.board, self.current_turn_token):
self.out.display_winner_announcement(self.current_turn_token)
elif self.board.is_board_full():
self.out.display_tie_annoucement()
def run(self):
try:
print(self.out.display_greetings_and_game_info())
print(self.out.current_game_header())
self.out.display_choose_prompt("O")
self.out.display_player_choices()
chosenPlayer = -1
while chosenPlayer == -1:
chosenPlayer = self.input.choose(3)
self.playerO = (RandomPlayer, InteractivePlayer,
MinimaxPlayer)[chosenPlayer](O_TOKEN)
self.out.display_choose_prompt("X")
self.out.display_player_choices()
chosenPlayer = -1
while chosenPlayer == -1:
chosenPlayer = self.input.choose(3)
self.playerX = (RandomPlayer, InteractivePlayer,
MinimaxPlayer)[chosenPlayer](X_TOKEN)
self.out.announce_player(type(self.playerO).__name__, O_TOKEN)
self.out.announce_player(type(self.playerX).__name__, X_TOKEN)
self.out.announce_who_moves_first(O_TOKEN)
self.round = 0
while True:
self.playerO.play(self.board)
self.out.display_board(self.board.get_squares(), self.round)
if self.is_game_over():
break
self.round += 1
self.switch_turns()
self.playerX.play(self.board)
self.out.display_board(self.board.get_squares(), self.round)
if self.is_game_over():
break
self.round += 1
self.switch_turns()
self.annouce_result()
except KeyboardInterrupt:
print("Bye.")
def test_squares_attribute_in_board_is_a_list_of_nine_elements(self):
board = Board()
self.assertEqual(9, len(board.get_squares()))
def test_board_empty(self):
squares = ['-', '-', '-', '-', '-', '-', '-', '-', '-']
board = Board()
board.set_all_squares(squares)
self.assertTrue(board.is_board_empty())
def test_board_full(self):
squares = ['X', 'X', 'O', 'X', 'O', 'O', 'O', 'X', 'X']
board = Board()
board.set_all_squares(squares)
self.assertTrue(board.is_board_full())
def setUp(self):
self.board = Board()
self.referee = Referee()
class TestTTT(unittest.TestCase):
def setUp(self):
self.board = Board()
self.referee = Referee()
def test_X_is_winner_in_first_horizontal(self):
current_turn_token = 'X'
opposite_turn_token = 'O'
squares = ['X', 'X', 'X', 'O', 'O', '-', '-', '-', '-']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_O_is_winner_in_first_horizontal(self):
current_turn_token = 'O'
opposite_turn_token = 'X'
squares = ['O', 'O', 'O', 'X', 'X', '-', '-', '-', '-']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_X_is_winner_in_second_horizontal(self):
current_turn_token = 'X'
opposite_turn_token = 'O'
squares = ['O', 'O', '-', 'X', 'X', 'X', '-', '-', '-']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_O_is_winner_in_second_horizontal(self):
current_turn_token = 'O'
opposite_turn_token = 'X'
squares = ['X', 'X', '-', 'O', 'O', 'O', '-', '-', '-']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_X_is_winner_in_first_vertical(self):
current_turn_token = 'X'
opposite_turn_token = 'O'
squares = ['X', 'O', '-', 'X', 'O', '-', 'X', '-', '-']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_O_is_winner_in_first_vertical(self):
current_turn_token = 'O'
opposite_turn_token = 'X'
squares = ['O', 'X', '-', 'O', 'X', '-', 'O', '-', '-']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_X_is_winner_in_left_diagonal(self):
current_turn_token = 'X'
opposite_turn_token = 'O'
squares = ['X', '-', 'O', '-', 'X', 'O', '-', '-', 'X']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_O_is_winner_in_left_diagonal(self):
current_turn_token = 'O'
opposite_turn_token = 'X'
squares = ['O', '-', 'X', '-', 'O', 'X', '-', '-', 'O']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_X_is_winner_in_right_diagonal(self):
current_turn_token = 'X'
opposite_turn_token = 'O'
squares = ['-', '-', 'X', '-', 'X', 'O', 'X', '-', 'O']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))
def test_O_is_winner_in_right_diagonal(self):
current_turn_token = 'O'
opposite_turn_token = 'X'
squares = ['-', '-', 'O', '-', 'O', 'X', 'O', '-', 'X']
self.board.set_all_squares(squares)
self.assertTrue(self.referee.is_winner(self.board, current_turn_token))
self.assertFalse(
self.referee.is_winner(self.board, opposite_turn_token))