def train(self,
player=Player('X'),
board=Board(),
previous_key=None,
previous_move=None):
memory_key = Model.MEMORY_KEY.format(player.char, board.key)
if memory_key not in self.memory.keys():
self.memory[memory_key] = {
'weights': [0, 0, 0, 0, 0, 0, 0, 0, 0],
'childs': [],
'previous_key': previous_key,
'previous_move': previous_move
}
self._set_all_related(memory_key)
for index in range(9):
_board = Board(board.key)
done, winner = _board.add(player, index)
if done:
if winner:
self._set_weight(
memory_key, index, 3.0 if winner.char == 'X' else
-2.0 if winner.char == 'O' else -1.0)
if winner is False:
self.train(
player=Player('X' if player.char == 'O' else 'O'),
board=_board,
previous_key=memory_key,
previous_move=index)
if not previous_key:
self._cleanup()
def test_no_winner(self):
board = Board()
board.mark_square(0, 2, 'x')
board.mark_square(1, 2, 'o')
board.mark_square(2, 2, 'x')
board.has_winner
self.assertEqual(board.has_winner, "n")
def test_get_symbol(self):
board = Board()
ui = ConsoleUI(board)
human_player = HumanPlayer(board, ui)
human_player.symbol = "S"
assert human_player.get_symbol() == "S"
def test_draw(self):
"""Confirm Board object correctly determines a draw state"""
board = Board()
self.assertFalse(board.checkForDraw())
for i in range(0,9):
board.inputMove(i, "X")
self.assertTrue(board.checkForDraw())
def test_input(self):
"""Confirm inputMove properly encodes game data"""
board = Board()
board.inputMove(5, "X")
self.assertEqual(board.gs[5], "X")
self.assertEqual(board.gs[4], " ")
self.assertEqual(board.gs[6], " ")
def test_minimax(self):
"""
Tests that computer can block human.
"""
board = Board()
computer = Player(board,
'C',
'computer',
is_human=False,
ai_strat=Minimax(board))
human = Player(board, 'H', 'human')
# set up human about to win
board.spaces[0] = human
board.spaces[1] = human
# set up computer to not have win cond
board.spaces[4] = computer
board.spaces[8] = computer
"""
|H|H|2|
|3|C|5|
|6|7|C|
"""
board.CURRENT_PLAYER = computer
board.WAITING_PLAYER = human
self.assertEqual(2, computer.make_play())
def check_lose(board, moves, play_sym):
temp_board = Board()
for move in moves:
temp_board.board = [row[:] for row in board.board]
temp_board.add_move(*move, play_sym)
if temp_board.check_winner()[0]:
return move
def generateindex(self, b=None, s=''):
if b == None:
b = Board()
self.values.update({b.tuplize(): 0.0})
if s == '' or s == b.circle:
next_s = b.cross
else:
next_s = b.circle
for m in b.status['moves']:
b_next = b.copy()
b_next.move(m, next_s)
winner = b_next.winner()
if winner == 'n':
self.generateindex(b_next, next_s)
elif winner == ' ':
value = 0.5
self.values.update({b_next.tuplize(): value})
elif winner == b.cross:
value = 1.0
self.values.update({b_next.tuplize(): value})
else:
value = -1.0
self.values.update({b_next.tuplize(): value})
return self.values
def test_row_last_complete(self):
board = Board()
board.mark_square(0, 2, 'x')
board.mark_square(1, 2, 'x')
board.mark_square(2, 2, 'x')
board.has_winner
self.assertEqual(board.has_winner(), "x")
def test_row_first_complete(self):
board = Board()
board.mark_square(0, 0, 'o')
board.mark_square(1, 0, 'o')
board.mark_square(2, 0, 'o')
board.has_winner
self.assertEqual(board.has_winner, "o")
def test_default_init():
state = (
(None, None, None),
(None, None, None),
(None, None, None),
)
board = Board()
assert board.state == state
def test_game_is_not_over(self):
board = Board()
player = ComputerPlayer(board)
board.set_position(3, player)
board.set_position(4, player)
board.set_position(8, player)
assert board.game_is_over() is False
def test_is_not_three_in_a_row(self):
board = Board()
player = ComputerPlayer(board)
board.set_position(2, player)
board.set_position(4, player)
board.set_position(5, player)
assert board.three_in_a_row(3, 4, 5) is False
def test_render_position_returns_symbol_when_position_is_not_empty(self):
board = Board()
ui = ConsoleUI(board)
player = ComputerPlayer(board)
player.symbol = 'X'
board.set_position(4, player)
assert ui.render_position(4) == 'X'
def test_board_init():
state = (
(None, None, None),
(None, None, None),
(None, None, None),
)
board = Board(state)
assert board.state == state
def test_newboard(self):
"""New boards should be empty"""
board = Board()
self.assertEqual("".join(board.gs), " " * 9)
for i in range(0, 9):
board.inputMove(i, "X")
board.__init__()
self.assertEqual("".join(board.gs), " " * 9)
def test_get_other_player_when_position_not_empty(self):
board = Board()
ui = ConsoleUI(board)
computer = ComputerPlayer(board)
human = HumanPlayer(board, ui)
board.set_position(4, computer)
board.set_position(5, human)
assert computer.get_other_player() == human
def get_best_move(board, comp_sym, play_sym):
best_score, best_move = -10, None
temp_board = Board()
for move in get_open_squares(board):
temp_board.board = [row[:] for row in board.board]
temp_board.add_move(*move, comp_sym)
score = minimax(temp_board, False, comp_sym, play_sym, 1)
if score > best_score:
best_score = score
best_move = move
return best_move
def test_board_print_as_grid(self):
"""
Tests that board is printed as a grid.
"""
board = Board()
board_grid_str = """
|0|1|2|
|3|4|5|
|6|7|8|
"""
self.assertEqual(board_grid_str, board.__str__())
def test_board_get_win_detection(self):
"""
Tests that a board can detect when a win is present.
"""
board = Board()
self.assertFalse(board.get_win())
# create a player and mark a winning move
player = Player(board, 'H', 'human')
winning_move = choice(board.WINNING_POSITIONS)
for space in winning_move:
board.spaces[space] = player
self.assertTrue(board.get_win())
def test_winconditions(self):
"""Make sure all win conditions are valid"""
board = Board()
"""Testing top row win"""
for i in range(0,3):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
"""Testing middle row win"""
for i in range(3, 6):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
"""Testing bottom row win"""
for i in range(6, 9):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
"""Testing left vertical column win"""
for i in range(0, 7, 3):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
"""Testing middle vertical column win"""
for i in range(1, 8, 3):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
"""Testing right vertical column win"""
for i in range(2, 9, 3):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
"""Testing \ diagonal win"""
for i in range(0, 9, 4):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
"""Testing / diagonal win"""
for i in range(2, 7, 2):
board.inputMove(i, "X")
self.assertTrue(board.checkForWinner("X"))
board.__init__
def test_iter(self):
board = Board(['X', 'O', ' ', 'X', ' ', 'O', 'O', 'X', 'O'])
iterator = iter(board)
self.assertEqual(next(iterator), 'X')
self.assertEqual(next(iterator), 'O')
self.assertEqual(next(iterator), ' ')
self.assertEqual(next(iterator), 'X')
self.assertEqual(next(iterator), ' ')
self.assertEqual(next(iterator), 'O')
self.assertEqual(next(iterator), 'O')
self.assertEqual(next(iterator), 'X')
self.assertEqual(next(iterator), 'O')
with self.assertRaises(StopIteration):
next(iterator)
def test_is_full(self):
board = Board()
player = ComputerPlayer(board)
board.set_position(0, player)
board.set_position(1, player)
board.set_position(2, player)
board.set_position(3, player)
board.set_position(4, player)
board.set_position(5, player)
board.set_position(6, player)
board.set_position(7, player)
board.set_position(8, player)
assert board.is_full() is True
def test_no_winner(self):
self.Board = Board()
self.Player = Player(self)
self.Board.mark_square(0, 0, "X")
self.Board.mark_square(0, 1, "0")
self.Board.mark_square(0, 2, "X")
self.Board.mark_square(1, 0, "0")
self.Board.mark_square(1, 1, "X")
self.Board.mark_square(1, 2, "0")
self.Board.mark_square(2, 1, "X")
self.Board.mark_square(2, 2, "0")
print("No Winner Test:")
self.Board.print_board()
print("\n")
self.assertEqual(self.Board.has_winner(), True, "Unit pass for no winner")
def search(self, board: Board = None):
if board is None:
board = Board()
board_hash = hash(board)
if board_hash in self.board_evals:
self.hits += 1
bestmove, bestscore, *_ = self.board_evals[board_hash].values()
return bestscore
if board.game_over():
winner = board.winner()
if not winner:
score = 0
else:
nmoves = sum(bool(sq) for sq in board.board)
score = -10 + nmoves
self.board_evals[board_hash] = {'bestmove': None, 'score': score}
return score
bestscore = -999
bestmove = None
moves = []
scores = []
for move in board.generate_unique_legal_moves():
score = -self.search(move)
if score > bestscore:
bestscore = score
bestmove = move
moves.append(move)
scores.append(score)
self.board_evals[board_hash] = {
'bestmove': bestmove,
'bestscore': bestscore,
'moves': moves,
'scores': scores,
}
return bestscore
def test_minimax_failing_block(self):
"""
|H|1|H|
|3|C|5|
|6|7|8|
"""
board = Board()
computer = Player(board,
'C',
'computer',
is_human=False,
ai_strat=Minimax(board))
computer.ai_strat.MINIMAX_DEPTH = 1
human = Player(board, 'H', 'human')
board.spaces[0] = human
board.spaces[2] = human
board.spaces[4] = computer
board.CURRENT_PLAYER = computer
board.WAITING_PLAYER = human
self.assertEqual(1, computer.make_play())
def minimax(board, maximizing, comp_sym, play_sym, depth):
if board.check_winner() == (True, comp_sym): #computer wins
return 1 / depth
elif board.check_winner()[0]: #player wins
return -1 / depth
elif len(get_open_squares(board)) == 0: #draw
return 0
moves = get_open_squares(board)
scores = []
temp_board = Board()
for move in moves:
temp_board.board = [row[:] for row in board.board]
if maximizing:
player = comp_sym
else:
player = play_sym
temp_board.add_move(*move, player)
scores.append(minimax(temp_board, not maximizing, comp_sym, play_sym, depth + 1))
if maximizing:
return max(scores)
return min(scores)
def play(ai_starts=False):
human = HumanPlayer()
ai = TicTacNET()
scores = [0, 0]
while True:
b = Board()
print(b, end="\n\n")
i = random.randint(0, 1) # Decide who starts.
while not b.is_decided:
player = ai if i & 1 else human
b = player.make_move(b)
print(b, end="\n\n")
i += 1
score = b.score
if score and i & 1:
scores[0] += 1
elif score:
scores[1] += 1
else:
scores[0] += 0.5
scores[1] += 0.5
print("\n\t\033[1mScore: {} - {}\033[0m\n".format(*scores))
import pygame
from tictactoe import Board
import mini2
from mini2 import Tic
#initialization
pygame.init()
board = Board()
tic = Tic()
clock = pygame.time.Clock()
font = pygame.font.SysFont("comicsansms", 72)
#start the game
def game_intro():
intro = True #For generating an infinite loop.
#run the game while unless player press quit or close the game
while intro:
mouse = pygame.mouse.get_pos()
click = pygame.mouse.get_pressed()
#get the mouse click and event
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
print 'Exit 1'
quit()
def search(self, board: Board = None):
if board is None:
board = Board()
player = board.side_to_move()
return self._search(board, player)
