def test_move_handmaid(self):
"""Deploy the handmaid and survive attack"""
game = Game.new(4, 2)
action = PlayerAction(Card.handmaid, 0, Card.noCard, Card.noCard)
game, _ = game.move(action)
players = game.players()
player = players[0]
self.assertTrue(PlayerTools.is_playing(player))
self.assertFalse(PlayerActionTools.is_blank(player.actions[0]))
self.assertEqual(player.actions[0], action)
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
action_attack = PlayerAction(Card.guard, 0, Card.prince, Card.noCard)
game, _ = game.move(action_attack)
players = game.players()
target = players[0]
player = players[1]
self.assertTrue(PlayerTools.is_playing(player))
self.assertTrue(PlayerTools.is_playing(target))
self.assertFalse(PlayerActionTools.is_blank(player.actions[0]))
self.assertEqual(player.actions[0], action_attack)
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
for action in target.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
def compare_agents(lambda_01, lambda_02, games_to_play=51, seed=451):
"""
Returns number of times agent created from lambda_01
wins over agent created from lambda_02 (which plays all the other
positions)
"""
wins = 0
for idx in range(games_to_play):
game = Game.new(4, seed + idx)
agent_one = (lambda_01)(seed + idx)
agent_two = (lambda_02)(seed + idx)
while game.active():
if not game.is_current_player_playing():
game = game.skip_eliminated_player()
continue
if game.player_turn() == 0:
action = agent_one.move(game)
else:
action = agent_two.move(game)
game, _ = game.move(action)
if game.is_winner(0):
wins = wins + 1
return wins
def test_move_guard_success(self):
"""Getting a guard move, with a right guess"""
game = Game.new()
action = PlayerAction(Card.guard, 3, Card.handmaid, 0)
self.assertEqual(len(game.opponents()), 3)
self.assertListEqual(game.opponent_turn(), [1, 2, 3])
game, _ = game.move(action)
self.assertEqual(game.round(), 0)
self.assertEqual(game.player_turn(), 1)
self.assertEqual(game.cards_left(), 10)
self.assertTrue(game.active())
self.assertFalse(game.over())
players = game.players()
player = players[0]
target = players[3]
recent_action = player.actions[0]
self.assertListEqual(game.opponent_turn(), [0, 2])
self.assertEqual(len(game.opponents()), 2)
self.assertFalse(PlayerTools.is_playing(target))
self.assertEqual(recent_action, action)
self.assertEqual(player.hand_card, Card.handmaid)
self.assertFalse(PlayerActionTools.is_blank(recent_action))
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
def play(seed, previous_actions):
"""Play a game"""
game = Game.new(4, seed)
previous_actions = np.array([], dtype=np.uint8) if len(previous_actions) < 1 else \
np.array([int(i) for i in previous_actions.split(",")], dtype=np.uint8)
previous_actions = PlayerActionTools.from_np_many(previous_actions)[::-1]
actions = []
while game.active():
if not game.is_current_player_playing():
game = game.skip_eliminated_player()
continue
display(game, actions)
try:
if len(previous_actions) > 0:
action = previous_actions.pop()
else:
print(" What card to play?")
action = get_action()
actions.append(action)
game, _ = game.move(action)
except ValueError:
print("Invalid move - Exit with Ctrl-C")
display(game, actions)
print("Game Over : Player {} Wins!".format(game.winner()))
def compare_agents(lambda_01, lambda_02, games_to_play=51, seed=451):
"""
Returns number of times agent created from lambda_01
wins over agent created from lambda_02 (which plays all the other
positions)
"""
wins = 0
if lambda_01 is lambda_02:
# Playing against yourself is nonsensical
return 0
for idx in range(games_to_play):
game = Game.new(4, seed + idx)
agent_one = (lambda_01)(seed + idx)
agent_two = (lambda_02)(seed + idx)
while game.active():
if not game.is_current_player_playing():
game = game.skip_eliminated_player()
continue
if game.player_turn() == 0:
action = agent_one.move(game)
else:
action = agent_two.move(game)
game, _ = game.move(action)
if game.is_winner(0):
wins = wins + 1
print('%s won against %s %.1f%% of games' %
(agent_one, agent_two, wins * 100 / games_to_play))
return wins
def test_end_elimination(self):
"""Reach the end of a game by elimination"""
game = Game.new(4, 0)
game, _ = game.move(
PlayerAction(Card.guard, 1, Card.priest, Card.noCard))
game = game.skip_eliminated_player()
game, _ = game.move(
PlayerAction(Card.guard, 3, Card.countess, Card.noCard))
game, _ = game.move(
PlayerAction(Card.handmaid, 3, Card.noCard, Card.noCard))
game, _ = game.move(
PlayerAction(Card.countess, 0, Card.noCard, Card.noCard))
game = game.skip_eliminated_player()
game, _ = game.move(
PlayerAction(Card.baron, 3, Card.noCard, Card.noCard))
game, _ = game.move(
PlayerAction(Card.guard, 2, Card.handmaid, Card.noCard))
self.assertFalse(game.over())
game, _ = game.move(
PlayerAction(Card.princess, 0, Card.noCard, Card.noCard))
self.assertEqual(game.cards_left(), 4)
self.assertTrue(game.over())
def play_with_agents(seed, *agents):
all_players = [None, AgentRandom()]
game = Game.new(len(all_players), seed)
actions = []
while game.active():
if not game.is_current_player_playing():
game = game.skip_eliminated_player()
continue
display(game, actions)
current_player = all_players[game.player_turn()]
if current_player:
action = current_player.move(game)
actions.append(action)
game, _ = game.move(action)
else:
try:
print(" What card to play?")
action = get_action()
actions.append(action)
game, _ = game.move(action)
except ValueError:
print("Invalid move - Exit with Ctrl-C")
display(game, actions)
print("Game Over : Player {} Wins!".format(game.winner()))
def test_new(self):
"""Getting a new game"""
game = Game.new()
self.assertEqual(game.draw_card(), Card.guard)
self.assertEqual(game.round(), 0)
self.assertEqual(game.player_turn(), 0)
self.assertEqual(game.cards_left(), 11)
self.assertTrue(game.active())
self.assertFalse(game.over())
def test_last_player_win(self):
"""Win the game by knocking out the opposing player"""
game = Game.new(2, 3)
action = PlayerAction(Card.guard, 1, Card.king, 0)
game, _ = game.move(action)
self.assertEqual(game.round(), 0)
self.assertEqual(game.cards_left(), 12)
self.assertFalse(game.active())
self.assertTrue(game.over())
self.assertEqual(0, game.winner())
def find_seed(cards_str):
"""Play a game"""
cards = set([int(s) for s in cards_str.split(',')])
results = 0
for idx in range(5000):
game = Game.new(4, idx)
# available_cards = set([player.hand_card for player in game.players()] + [game.draw_card()])
available_cards = set([game.players()[0].hand_card] +
[game.draw_card()])
if cards.issubset(available_cards):
print("Found at {: >5}".format(idx))
results += 1
if results > 5:
return
def replay(seed, action_sequence=None):
"""Generate a game from a recorded set of actions"""
action_sequence = action_sequence if action_sequence is not None else []
action_sequence = np.array(action_sequence, dtype=np.uint8)
action_sequence = PlayerActionTools.from_np_many(action_sequence)[::-1]
game = Game.new(4, seed)
while len(action_sequence) > 0:
if not game.is_current_player_playing():
game = game.skip_eliminated_player()
else:
action = action_sequence.pop()
game = game._move(action)
return game
def test_move_prince_self(self):
"""Use prince to force self discard"""
game = Game.new(4, 2)
action = PlayerAction(Card.prince, 0, Card.noCard, Card.noCard)
action_other = PlayerAction(Card.handmaid, 0, Card.noCard, Card.noCard)
game, _ = game.move(action)
players = game.players()
player = players[0]
self.assertTrue(PlayerTools.is_playing(player))
self.assertFalse(PlayerActionTools.is_blank(player.actions[0]))
self.assertFalse(PlayerActionTools.is_blank(player.actions[1]))
self.assertEqual(player.actions[0], action)
self.assertEqual(player.actions[1], action_other)
for action in player.actions[2:]:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_princess(self):
"""Commit suicide by discarding the princess"""
game = Game.new(4, 11)
action = PlayerAction(Card.princess, 0, Card.noCard, Card.noCard)
game, _ = game.move(action)
players = game.players()
player = players[0]
self.assertFalse(PlayerTools.is_playing(player))
self.assertFalse(PlayerActionTools.is_blank(player.actions[0]))
self.assertFalse(PlayerActionTools.is_blank(player.actions[1]))
self.assertEqual(player.actions[0],
PlayerAction(Card.baron, 0, Card.noCard, Card.noCard))
self.assertEqual(player.actions[1], action)
for action in player.actions[2:]:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_baron_failure(self):
"""Getting a baron move, with a failure"""
game = Game.new(4, 48)
action = PlayerAction(Card.baron, 1, Card.noCard, Card.noCard)
game, _ = game.move(action)
players = game.players()
player = players[0]
target = players[1]
self.assertFalse(PlayerTools.is_playing(player))
self.assertTrue(PlayerTools.is_playing(target))
self.assertFalse(PlayerActionTools.is_blank(player.actions[0]))
self.assertFalse(PlayerActionTools.is_blank(player.actions[1]))
for action in player.actions[2:]:
self.assertTrue(PlayerActionTools.is_blank(action))
for action in target.actions:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_king(self):
"""Use king to swap hands with the target"""
game = Game.new(4, 0)
action = PlayerAction(Card.king, 1, Card.noCard, Card.noCard)
game, _ = game.move(action)
players = game.players()
player = players[0]
target = players[1]
self.assertTrue(PlayerTools.is_playing(player))
self.assertFalse(PlayerActionTools.is_blank(player.actions[0]))
self.assertEqual(player.actions[0], action)
self.assertEqual(player.hand_card, Card.priest)
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
self.assertTrue(PlayerTools.is_playing(target))
self.assertEqual(target.hand_card, Card.guard)
for action in target.actions:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_prince_other(self):
"""Use prince to force another to discard"""
game = Game.new(4, 2)
action = PlayerAction(Card.prince, 1, Card.noCard, Card.noCard)
action_target = PlayerAction(Card.guard, 0, Card.noCard, Card.noCard)
game, _ = game.move(action)
players = game.players()
player = players[0]
target = players[1]
self.assertTrue(PlayerTools.is_playing(player))
self.assertFalse(PlayerActionTools.is_blank(player.actions[0]))
self.assertEqual(player.actions[0], action)
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
self.assertTrue(PlayerTools.is_playing(target))
self.assertFalse(PlayerActionTools.is_blank(target.actions[0]))
self.assertEqual(target.actions[0], action_target)
for action in target.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_baron_success(self):
"""Getting a baron move, with a success"""
game = Game.new(4, 48)
action = PlayerAction(Card.baron, 3, Card.noCard, Card.noCard)
game, _ = game.move(action)
players = game.players()
player = players[0]
target = players[3]
recent_action = player.actions[0]
self.assertTrue(PlayerTools.is_playing(player))
self.assertFalse(PlayerTools.is_playing(target))
self.assertEqual(recent_action, action)
self.assertFalse(PlayerActionTools.is_blank(recent_action))
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
self.assertFalse(PlayerActionTools.is_blank(target.actions[0]))
for action in target.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_priest(self):
"""Getting a priest move"""
game = Game.new(4, 5)
action = PlayerAction(Card.priest, 1, Card.noCard, Card.noCard)
action_expected = PlayerAction(Card.priest, 1, Card.noCard, Card.guard)
game, _ = game.move(action)
self.assertEqual(game.round(), 0)
self.assertEqual(game.player_turn(), 1)
self.assertEqual(game.cards_left(), 10)
self.assertTrue(game.active())
self.assertFalse(game.over())
players = game.players()
player = players[0]
target = players[1]
recent_action = player.actions[0]
self.assertTrue(PlayerTools.is_playing(target))
self.assertEqual(recent_action, action_expected)
self.assertFalse(PlayerActionTools.is_blank(recent_action))
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_guard_guess_guard(self):
"""Getting a guard move and guessing guard"""
game = Game.new()
action = PlayerAction(Card.guard, 1, Card.guard, 0)
game, _ = game.move(action)
self.assertEqual(game.round(), 0)
self.assertEqual(game.player_turn(), 0)
self.assertEqual(game.cards_left(), 11)
self.assertTrue(game.active())
self.assertFalse(game.over())
players = game.players()
player = players[0]
target = players[1]
recent_action = player.actions[0]
self.assertTrue(PlayerTools.is_playing(player))
self.assertEqual(player.hand_card, Card.handmaid)
self.assertEqual(game.deck()[0], Card.guard)
self.assertTrue(PlayerActionTools.is_blank(recent_action))
for action in player.actions:
self.assertTrue(PlayerActionTools.is_blank(action))
def test_move_guard_failure(self):
"""Getting a guard move, with a wrong guess"""
game = Game.new()
action = PlayerAction(Card.guard, 1, Card.handmaid, 0)
game, _ = game.move(action)
self.assertEqual(game.round(), 0)
self.assertEqual(game.player_turn(), 1)
self.assertEqual(game.cards_left(), 10)
self.assertTrue(game.active())
self.assertFalse(game.over())
players = game.players()
player = players[0]
target = players[1]
recent_action = player.actions[0]
self.assertTrue(PlayerTools.is_playing(target))
self.assertEqual(recent_action, action)
self.assertEqual(player.hand_card, Card.handmaid)
self.assertFalse(PlayerActionTools.is_blank(recent_action))
for action in player.actions[1:]:
self.assertTrue(PlayerActionTools.is_blank(action))