def test_create_sample_speed(benchmark):
players = [
SimplePlayer(Color.RED),
SimplePlayer(Color.BLUE),
SimplePlayer(Color.WHITE),
SimplePlayer(Color.ORANGE),
]
game = Game(players)
for _ in range(30):
game.play_tick()
sample = benchmark(create_sample, game, players[1].color)
assert isinstance(sample, dict)
assert len(sample) > 0
def test_second_placement_takes_cards_from_bank():
players = [
SimplePlayer(Color.RED),
SimplePlayer(Color.BLUE),
SimplePlayer(Color.WHITE),
SimplePlayer(Color.ORANGE),
]
game = Game(players)
assert sum(game.state.resource_freqdeck) == 19 * 5
while not any(
a.action_type == ActionType.ROLL for a in game.state.playable_actions
):
game.play_tick()
assert sum(game.state.resource_freqdeck) < 19 * 5
def test_end_turn_goes_to_next_player(fake_roll_dice):
fake_roll_dice.return_value = (1, 2) # not a 7
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
game = Game(players)
actions = []
while not any(
a.action_type == ActionType.ROLL for a in game.state.playable_actions
):
actions.append(game.play_tick())
p0_color = game.state.colors[0]
p1_color = game.state.colors[1]
assert (
game.state.current_prompt == ActionPrompt.PLAY_TURN
and game.state.current_color() == p0_color
)
assert game.state.playable_actions == [Action(p0_color, ActionType.ROLL, None)]
game.execute(Action(p0_color, ActionType.ROLL, None))
assert game.state.current_prompt == ActionPrompt.PLAY_TURN
assert game.state.current_color() == p0_color
assert player_has_rolled(game.state, p0_color)
assert Action(p0_color, ActionType.END_TURN, None) in game.state.playable_actions
game.execute(Action(p0_color, ActionType.END_TURN, None))
assert game.state.current_prompt == ActionPrompt.PLAY_TURN
assert game.state.current_color() == p1_color
assert not player_has_rolled(game.state, p0_color)
assert not player_has_rolled(game.state, p1_color)
assert game.state.playable_actions == [Action(p1_color, ActionType.ROLL, None)]
def test_copy():
"""Play 30 moves, copy game, ensure they look the same but not the same."""
players = [
SimplePlayer(Color.RED),
SimplePlayer(Color.BLUE),
SimplePlayer(Color.WHITE),
SimplePlayer(Color.ORANGE),
]
game = Game(players)
for i in range(30):
game.play_tick()
game_copy = game.copy()
assert json.dumps(game, cls=GameEncoder) == json.dumps(game_copy,
cls=GameEncoder)
assert game_copy != game
def test_discard_config(fake_roll_dice):
fake_roll_dice.return_value = (1, 6)
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
game = Game(players, discard_limit=10)
while not any(
a.action_type == ActionType.ROLL for a in game.state.playable_actions
):
game.play_tick()
until_nine = 9 - player_num_resource_cards(game.state, players[1].color)
player_deck_replenish(game.state, players[1].color, WHEAT, until_nine)
assert player_num_resource_cards(game.state, players[1].color) == 9
game.play_tick() # should be p0 rolling.
assert game.state.playable_actions != [
Action(players[1].color, ActionType.DISCARD, None)
]
def test_seven_cards_dont_trigger_discarding(fake_roll_dice):
fake_roll_dice.return_value = (1, 6)
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
# Play initial build phase
game = Game(players)
while not any(
a.action_type == ActionType.ROLL for a in game.state.playable_actions
):
game.play_tick()
until_seven = 7 - player_num_resource_cards(game.state, players[1].color)
player_deck_replenish(game.state, players[1].color, WHEAT, until_seven)
assert player_num_resource_cards(game.state, players[1].color) == 7
game.play_tick() # should be player 0 rolling.
assert not any(
a.action_type == ActionType.DISCARD for a in game.state.playable_actions
)
def test_can_play_for_a_bit(): # assert no exception thrown
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
game = Game(players)
for _ in range(10):
game.play_tick()
def test_initial_build_phase():
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
game = Game(players)
actions = []
while not any(
a.action_type == ActionType.ROLL for a in game.state.playable_actions
):
actions.append(game.play_tick())
p0_color = game.state.colors[0]
assert (
actions[0].action_type == ActionType.BUILD_SETTLEMENT
and actions[0].color == p0_color
)
assert (
actions[1].action_type == ActionType.BUILD_ROAD and actions[1].color == p0_color
)
assert (
actions[2].action_type == ActionType.BUILD_SETTLEMENT
and actions[2].color != p0_color
)
assert (
actions[3].action_type == ActionType.BUILD_ROAD and actions[3].color != p0_color
)
assert (
actions[4].action_type == ActionType.BUILD_SETTLEMENT
and actions[4].color != p0_color
)
assert (
actions[5].action_type == ActionType.BUILD_ROAD and actions[5].color != p0_color
)
assert (
actions[6].action_type == ActionType.BUILD_SETTLEMENT
and actions[6].color == p0_color
)
assert (
actions[7].action_type == ActionType.BUILD_ROAD and actions[7].color == p0_color
)
assert (
game.state.current_prompt == ActionPrompt.PLAY_TURN
and game.state.current_color() == p0_color
)
assert game.state.player_state["P0_ACTUAL_VICTORY_POINTS"] == 2
assert game.state.player_state["P1_ACTUAL_VICTORY_POINTS"] == 2
assert game.state.player_state["P0_VICTORY_POINTS"] == 2
assert game.state.player_state["P1_VICTORY_POINTS"] == 2
# assert there are 4 houses and 4 roads
settlements = [
building
for building in game.state.board.buildings.values()
if building[1] == BuildingType.SETTLEMENT
]
assert len(settlements) == 4
# assert should be house-road pairs, or together
paths = game.state.board.continuous_roads_by_player(players[0].color)
assert len(paths) == 1 or (
len(paths) == 2 and len(paths[0]) == 1 and len(paths[1]) == 1
)
# assert should have resources from last house.
# can only assert <= 3 b.c. player might place on a corner desert
assert player_num_resource_cards(game.state, players[0].color) <= 3
assert player_num_resource_cards(game.state, players[1].color) <= 3