def test_play_monopoly_player_steals_cards():
player_to_act = SimplePlayer(Color.RED)
player_to_steal_from_1 = SimplePlayer(Color.BLUE)
player_to_steal_from_2 = SimplePlayer(Color.ORANGE)
players = [player_to_act, player_to_steal_from_1, player_to_steal_from_2]
state = State(players)
player_deck_replenish(state, player_to_act.color, MONOPOLY)
player_deck_replenish(state, player_to_steal_from_1.color, ORE, 3)
player_deck_replenish(state, player_to_steal_from_1.color, WHEAT, 1)
player_deck_replenish(state, player_to_steal_from_2.color, ORE, 2)
player_deck_replenish(state, player_to_steal_from_2.color, WHEAT, 1)
action_to_execute = Action(player_to_act.color, ActionType.PLAY_MONOPOLY,
ORE)
apply_action(state, action_to_execute)
assert player_num_resource_cards(state, player_to_act.color, ORE) == 5
assert player_num_resource_cards(state, player_to_steal_from_1.color,
ORE) == 0
assert player_num_resource_cards(state, player_to_steal_from_1.color,
WHEAT) == 1
assert player_num_resource_cards(state, player_to_steal_from_2.color,
ORE) == 0
assert player_num_resource_cards(state, player_to_steal_from_2.color,
WHEAT) == 1
def test_can_only_play_one_dev_card_per_turn():
players = [
SimplePlayer(Color.RED),
SimplePlayer(Color.BLUE),
SimplePlayer(Color.WHITE),
SimplePlayer(Color.ORANGE),
]
state = State(players)
player_deck_replenish(state, players[0].color, YEAR_OF_PLENTY, 2)
action = Action(players[0].color, ActionType.PLAY_YEAR_OF_PLENTY,
2 * [BRICK])
apply_action(state, action)
with pytest.raises(ValueError): # shouldnt be able to play two dev cards
apply_action(state, action)
def test_trade_execution():
players = [
SimplePlayer(Color.RED),
SimplePlayer(Color.BLUE),
SimplePlayer(Color.WHITE),
SimplePlayer(Color.ORANGE),
]
state = State(players)
player_deck_replenish(state, players[0].color, BRICK, 4)
trade_offer = tuple([BRICK] * 4 + [ORE])
action = Action(players[0].color, ActionType.MARITIME_TRADE, trade_offer)
apply_action(state, action)
assert player_num_resource_cards(state, players[0].color) == 1
assert sum(state.resource_freqdeck) == 19 * 5 + 4 - 1
def test_moving_robber_steals_correctly():
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
state = State(players)
player_deck_replenish(state, players[1].color, WHEAT, 1)
state.board.build_settlement(Color.BLUE, 3, initial_build_phase=True)
action = Action(players[0].color, ActionType.MOVE_ROBBER,
((2, 0, -2), None, None))
apply_action(state, action)
assert player_num_resource_cards(state, players[0].color) == 0
assert player_num_resource_cards(state, players[1].color) == 1
action = Action(
players[0].color,
ActionType.MOVE_ROBBER,
((0, 0, 0), players[1].color, WHEAT),
)
apply_action(state, action)
assert player_num_resource_cards(state, players[0].color) == 1
assert player_num_resource_cards(state, players[1].color) == 0
def test_cant_buy_more_than_max_card():
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
state = State(players)
with pytest.raises(ValueError): # not enough money
apply_action(
state,
Action(players[0].color, ActionType.BUY_DEVELOPMENT_CARD, None))
player_deck_replenish(state, players[0].color, SHEEP, 26)
player_deck_replenish(state, players[0].color, WHEAT, 26)
player_deck_replenish(state, players[0].color, ORE, 26)
for i in range(25):
apply_action(
state,
Action(players[0].color, ActionType.BUY_DEVELOPMENT_CARD, None))
# assert must have all victory points
assert player_num_dev_cards(state, players[0].color) == 25
assert get_dev_cards_in_hand(state, players[0].color, VICTORY_POINT) == 5
with pytest.raises(ValueError): # not enough cards in bank
apply_action(
state,
Action(players[0].color, ActionType.BUY_DEVELOPMENT_CARD, None))
assert player_num_resource_cards(state, players[0].color) == 3
def test_defeating_your_own_largest_army_doesnt_give_more_vps():
# Arrange: Buy all dev cards
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
state = State(players)
player_deck_replenish(state, players[0].color, SHEEP, 26)
player_deck_replenish(state, players[0].color, WHEAT, 26)
player_deck_replenish(state, players[0].color, ORE, 26)
for i in range(25):
apply_action(
state,
Action(players[0].color, ActionType.BUY_DEVELOPMENT_CARD, None))
assert get_largest_army(state) == (None, None)
assert get_actual_victory_points(state, Color.RED) == 5
# Act - Assert
play_dev_card(state, Color.RED, KNIGHT)
play_dev_card(state, Color.RED, KNIGHT)
play_dev_card(state, Color.RED, KNIGHT)
assert get_largest_army(state) == (Color.RED, 3)
assert get_actual_victory_points(state, Color.RED) == 7
# Act - Assert
play_dev_card(state, Color.RED, KNIGHT)
assert get_largest_army(state) == (Color.RED, 4)
assert get_actual_victory_points(state, Color.RED) == 7
def test_largest_army_calculation_on_tie():
red = SimplePlayer(Color.RED)
blue = SimplePlayer(Color.BLUE)
white = SimplePlayer(Color.WHITE)
state = State([red, blue, white])
player_deck_replenish(state, red.color, KNIGHT, 3)
player_deck_replenish(state, blue.color, KNIGHT, 4)
play_dev_card(state, Color.RED, KNIGHT)
play_dev_card(state, Color.RED, KNIGHT)
play_dev_card(state, Color.RED, KNIGHT)
play_dev_card(state, Color.BLUE, KNIGHT)
play_dev_card(state, Color.BLUE, KNIGHT)
play_dev_card(state, Color.BLUE, KNIGHT)
color, count = get_largest_army(state)
assert color is Color.RED and count == 3
play_dev_card(state, Color.BLUE, KNIGHT)
color, count = get_largest_army(state)
assert color is Color.BLUE and count == 4
def test_play_year_of_plenty_gives_player_resources():
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
state = State(players)
player_to_act = players[0]
player_deck_replenish(state, player_to_act.color, YEAR_OF_PLENTY, 1)
action_to_execute = Action(player_to_act.color,
ActionType.PLAY_YEAR_OF_PLENTY, [ORE, WHEAT])
apply_action(state, action_to_execute)
for card_type in RESOURCES:
if card_type == ORE or card_type == WHEAT:
assert player_num_resource_cards(state, player_to_act.color,
card_type) == 1
assert freqdeck_count(state.resource_freqdeck, card_type) == 18
else:
assert player_num_resource_cards(state, player_to_act.color,
card_type) == 0
assert freqdeck_count(state.resource_freqdeck, card_type) == 19
assert get_dev_cards_in_hand(state, player_to_act.color,
YEAR_OF_PLENTY) == 0
def test_cant_steal_devcards():
# Arrange: Have RED buy 1 dev card (and have no resource cards)
players = [SimplePlayer(Color.RED), SimplePlayer(Color.BLUE)]
state = State(players)
player_deck_replenish(state, Color.RED, WHEAT)
player_deck_replenish(state, Color.RED, ORE)
player_deck_replenish(state, Color.RED, SHEEP)
buy_dev_card(state, Color.RED, KNIGHT)
# Act: Attempt to steal a resource
with pytest.raises(IndexError): # no resource cards in hand
player_deck_random_draw(state, Color.RED)
def test_largest_army_calculation_when_no_one_has_three():
red = SimplePlayer(Color.RED)
blue = SimplePlayer(Color.BLUE)
white = SimplePlayer(Color.WHITE)
state = State([red, blue, white])
player_deck_replenish(state, Color.RED, WHEAT, 2)
player_deck_replenish(state, Color.RED, SHEEP, 2)
player_deck_replenish(state, Color.RED, ORE, 2)
player_deck_replenish(state, Color.BLUE, WHEAT, 1)
player_deck_replenish(state, Color.BLUE, SHEEP, 1)
player_deck_replenish(state, Color.BLUE, ORE, 1)
buy_dev_card(state, Color.RED, KNIGHT)
buy_dev_card(state, Color.RED, KNIGHT)
buy_dev_card(state, Color.BLUE, KNIGHT)
play_dev_card(state, Color.RED, KNIGHT)
color, count = get_largest_army(state)
assert color is None and count is None
