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))