def _move(self, game):
'''Return move which ends in score hole'''
self._idx = self._idx + 1
random.seed(self._seed + self._idx)
game_clone, rot_flag = game.clone_turn()
move_options = Agent.valid_indices(game_clone)
distance = list(
map(
lambda move_slot: AgentExact._hole_to_score(
move_slot, game_clone.clone()), move_options))
available_scores = list(
map(
lambda move_slot: AgentExact._score_of_move(
move_slot, game_clone.clone()), move_options))
final_options = [
move for exact, move in zip(distance, move_options) if exact == 1
]
if not final_options:
score_max = max(available_scores)
final_options = [
move for score, move in zip(available_scores, move_options)
if score == score_max
]
final_move = Game.rotate_board(rot_flag,
random.choice(final_options))
else:
final_move = Game.rotate_board(rot_flag, max(final_options))
return final_move
def test_move_p2(self):
'''Test move correctly picks 2nd player move'''
game = Game()
game.move(5)
self.assertEqual(game.turn_player(), 2)
move = AgentExact().move(game)
self.assertEqual(move, 8)
def test_player1(self):
for i in range(0, 6):
self.assertTrue(Game.idx_player_1(i))
for i in range(-50, 0):
self.assertFalse(Game.idx_player_1(i))
for i in range(6, 200):
self.assertFalse(Game.idx_player_1(i))
def test_move_p2(self):
"""Test move picks a max move for player 2"""
game = Game()
game.move(4)
self.assertEqual(game.turn_player(), 2)
move = AgentMax().move(game)
self.assertEqual(move, 10)
def test_player2(self):
for i in range(-20, 7):
self.assertFalse(Game.idx_player_2(i))
for i in range(7, 13):
self.assertTrue(Game.idx_player_2(i))
for i in range(13, 200):
self.assertFalse(Game.idx_player_2(i))
def test_random_move_02(self):
"""Test multiple moves"""
game = Game()
agent = AgentRandom(454)
move = agent.move(game)
self.assertEqual(move, 5)
game.move(move)
move = agent.move(game)
self.assertEqual(move, 12)
def test_player_one_takes_a_turn(self):
current_player = 1
mock_mancala_board = mock.Mock()
mock_player_one = mock.Mock()
mock_player_two = mock.Mock()
mock_mancala_board.game_over.return_value = True
mock_player_one.play.return_value = False
game = Game(mock_mancala_board, mock_player_one, mock_player_two)
game.play(current_player)
assert mock_player_one.play.call_count == 1
def test_player_one_takes_an_extra_turn(self):
current_player = 1
mock_mancala_board = mock.Mock()
mock_player_one = mock.Mock()
mock_player_two = mock.Mock()
mock_mancala_board.game_over.side_effect = [False, True]
mock_player_one.play.side_effect = [True, False]
game = Game(mock_mancala_board, mock_player_one, mock_player_two)
game.play(current_player)
assert mock_player_one.play.call_count == 2
def test_move_11(self):
g = Game()
g.move(0)
g.move(11)
self.assertEqual(g._board, [1, 6, 5, 5, 5, 4, 0, 4, 4, 4, 4, 0, 5, 1])
self.assertEqual(g.score(), (0, 1))
self.assertEqual(g.turn_player(), 1)
self.assertEqual(g.history(),
[[4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 0],
[0, 5, 5, 5, 5, 4, 0, 4, 4, 4, 4, 4, 4, 0]])
def _handle_combo(combo, seed, games_to_play):
wins = 0
for idx in range(0, games_to_play):
game = Game()
agent_one = (combo[0][1])(seed + idx)
agent_two = (combo[1][1])(seed + idx)
while not game.over():
if game.turn_player() == 1:
game.move(agent_one.move(game))
else:
game.move(agent_two.move(game))
if game.score()[0] > game.score()[1]:
wins = wins + 1
return (combo[0][0], combo[1][0], wins)
def test_does_not_switch_players_when_game_over_occurs_on_a_players_extra_turn(
self):
expected_game_log = "[[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [23, 19]]"
current_player = 1
mock_mancala_board = mock.Mock()
mock_player_one = mock.Mock()
mock_player_two = mock.Mock()
mock_mancala_board.game_log = expected_game_log
mock_mancala_board.game_over.side_effect = [False, True]
mock_player_one.play.side_effect = [True, False]
game = Game(mock_mancala_board, mock_player_one, mock_player_two)
game.play(current_player)
assert not mock_player_two.play.called
def test_Illegal_empty(self):
g = Game()
g.move(0)
g.move(7)
g.move(0)
self.assertEqual(g._board, [0, 5, 5, 5, 5, 4, 0, 0, 5, 5, 5, 5, 4, 0])
self.assertEqual(g.score(), (0, 0))
self.assertEqual(g.turn_player(), 1)
def test_capture_p2_not_okay_opp_side(self):
g = Game()
g._board = [1, 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 1, 0, 0]
g._player_one = False
g.move(11)
self.assertEqual(g._board, [0, 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 2])
self.assertEqual(g.score(), (0, 2))
self.assertEqual(g.turn_player(), 1)
def test_capture_p2_not_okay_empty_opp(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 1, 2]
g._player_one = False
g.move(7)
self.assertEqual(g._board, [1, 0, 0, 0, 0, 1, 2, 0, 1, 0, 0, 0, 1, 2])
self.assertEqual(g.score(), (2, 2))
self.assertEqual(g.turn_player(), 1)
def test_capture_p2_not_okay_grand_slam(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1]
g._player_one = False
g.move(11)
self.assertEqual(g._board, [1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1])
self.assertEqual(g.score(), (1, 1))
self.assertEqual(g.turn_player(), 1)
def test_p2_Win_exact(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 1, 5, 1, 0, 0, 0, 0, 1, 24]
g._player_one = False
g.move(12)
self.assertEqual(g._board, [1, 0, 0, 0, 0, 1, 5, 1, 0, 0, 0, 0, 0, 25])
self.assertEqual(g.score(), (5, 25))
self.assertTrue(g.over())
def test_p2_Win_over(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 1, 5, 1, 0, 0, 0, 0, 15, 24]
g._player_one = False
g.move(12)
self.assertEqual(g._board, [3, 1, 1, 1, 1, 2, 5, 2, 1, 1, 1, 1, 1, 26])
self.assertEqual(g.score(), (5, 26))
self.assertTrue(g.over())
def game(client, session):
game = Game(player_1="Tester", player_2="Checker")
session.add(game)
session.commit()
yield game
session.delete(game)
session.commit()
def _move(self, game):
'''Return move which ends in score hole'''
assert not game.over()
self._idx += 1
game_clone, rot_flag = game.clone_turn()
move_options = Agent.valid_indices(game_clone)
state = self.env.force(game_clone)
state = torch.from_numpy(state).type(self._dtype)
cx = Variable(torch.zeros(1, 400).type(self._dtype), volatile=True)
hx = Variable(torch.zeros(1, 400).type(self._dtype), volatile=True)
_, logit, (hx, cx) = self._model((Variable(state.unsqueeze(0),
volatile=True), (hx, cx)))
prob = F.softmax(logit)
scores = [(action, score)
for action, score in enumerate(prob[0].data.tolist())
if action in move_options]
valid_actions = [action for action, _ in scores]
valid_scores = np.array([score for _, score in scores])
final_move = self.np_random.choice(valid_actions,
1,
p=valid_scores /
valid_scores.sum())[0]
return Game.rotate_board(rot_flag, final_move)
def test_returns_the_game_logs_on_game_over(self):
expected_game_board_log = "[[4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4], [0, 0]]"
expected_game_state_log = "game state log"
current_player = 1
mock_mancala_board = mock.Mock()
mock_player_one = mock.Mock()
mock_player_two = mock.Mock()
mock_mancala_board.game_over.return_value = True
mock_mancala_board.game_board_log = expected_game_board_log
mock_mancala_board.game_state_log = expected_game_state_log
mock_player_one.play.return_value = False
game = Game(mock_mancala_board, mock_player_one, mock_player_two)
assert game.play(current_player) == [
expected_game_board_log, expected_game_state_log
]
def _move(self, game):
"""Return best value from Min_Max"""
self._idx = self._idx + 1
random.seed(self._seed + self._idx)
game_clone, rot_flag = game.clone_turn()
move_options = Agent.valid_indices(game_clone)
available_scores = list(
map(lambda move_slot:
AgentMinMax._min_max(
self._depth,
game_clone,
move_slot,
-sys.maxsize,
sys.maxsize
),
move_options))
score_max = max(available_scores)
final_options = [move for score, move in
zip(available_scores, move_options)
if score == score_max]
final_move = Game.rotate_board(rot_flag, random.choice(final_options))
return final_move
def test_side_02_empty(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 7, 20, 0, 0, 0, 0, 0, 3, 10]
g._player_one = False
g.move(12)
self.assertEqual(g._board,
[0, 0, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 11])
self.assertEqual(g.score(), (30, 11))
self.assertTrue(g.over())
def test_creates_a_new_game():
mock_mancala_board = mock.Mock()
mock_player_one = mock.Mock()
mock_player_two = mock.Mock()
game = Game(mock_mancala_board, mock_player_one, mock_player_two)
assert game.game == mock_mancala_board
assert game.players == [mock_player_one, mock_player_two]
def test_capture_p1_okay(self):
g = Game()
g._board = [1, 0, 0, 4, 0, 0, 0, 2, 3, 0, 0, 1, 0, 0]
g.move(0)
self.assertEqual(g._board, [0, 0, 0, 4, 0, 0, 2, 2, 3, 0, 0, 0, 0, 0])
self.assertEqual(g.score(), (2, 0))
self.assertEqual(g.turn_player(), 2)
def test_capture_p1_not_okay_empty_opp(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 1, 2]
g.move(0)
self.assertEqual(g._board, [0, 1, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 1, 2])
self.assertEqual(g.score(), (2, 2))
self.assertEqual(g.turn_player(), 2)
def test_capture_p1_not_okay_grand_slam(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1]
g.move(0)
self.assertEqual(g._board, [0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1])
self.assertEqual(g.score(), (1, 1))
self.assertEqual(g.turn_player(), 2)
def test_capture_score_not_okay(self):
g = Game()
g._board = [1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 5]
g.move(5)
self.assertEqual(g._board, [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 5])
self.assertEqual(g.score(), (1, 5))
self.assertEqual(g.turn_player(), 1)
def test_p1_Win_exact(self):
g = Game()
g._board = [1, 0, 0, 0, 0, 1, 24, 0, 0, 0, 0, 0, 3, 5]
g.move(5)
self.assertEqual(g._board, [1, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 3, 5])
self.assertEqual(g.score(), (25, 5))
self.assertTrue(g.over())
def test_p1_Win_over(self):
g = Game()
g._board = [1, 0, 0, 0, 15, 1, 24, 0, 0, 0, 0, 0, 3, 5]
g.move(4)
self.assertEqual(g._board, [2, 1, 1, 1, 1, 3, 26, 1, 1, 1, 1, 1, 4, 5])
self.assertEqual(g.score(), (26, 5))
self.assertTrue(g.over())
def test_capture_p1_not_okay_opp_side(self):
g = Game()
g._board = [1, 0, 0, 4, 1, 3, 0, 2, 0, 0, 0, 1, 0, 0]
g.move(5)
self.assertEqual(g._board, [1, 0, 0, 4, 1, 0, 1, 3, 1, 0, 0, 1, 0, 0])
self.assertEqual(g.score(), (1, 0))
self.assertEqual(g.turn_player(), 2)
