def test_win_condition():
simulation = create_less_random_simulation(
start_player=Character.RESEARCHER)
simulation.state.cures[Virus.BLUE] = True
simulation.state.cures[Virus.BLACK] = True
simulation.state.cures[Virus.YELLOW] = True
assert simulation.state.game_state == GameState.RUNNING
simulation.state.players[Character.RESEARCHER]._city_cards = {
City.BANGKOK,
City.HO_CHI_MINH_CITY,
City.BEIJING,
City.MANILA,
City.HONG_KONG,
}
cure_action = DiscoverCure(target_virus=Virus.RED)
assert cure_action in simulation.get_possible_actions()
simulation.step(cure_action)
cure_virus(
simulation,
[
City.BANGKOK, City.HO_CHI_MINH_CITY, City.BEIJING, City.MANILA,
City.HONG_KONG
],
Character.RESEARCHER,
)
assert simulation.state.game_state == GameState.WIN
def test_two_cards_too_many():
simulation = create_less_random_simulation()
# cheat and pretend virus is eradicated
simulation.state.players[Character.SCIENTIST].cards = {
City.BANGKOK,
City.HO_CHI_MINH_CITY,
City.BEIJING,
City.MANILA,
City.HONG_KONG,
City.SYDNEY,
City.ALGIERS,
City.ATLANTA,
City.BAGHDAD,
}
assert len(simulation.get_possible_actions()
) == 9, simulation.get_possible_actions()
assert all(
map(lambda c: isinstance(c, DiscardCard),
simulation.get_possible_actions()))
simulation.step(simulation.get_possible_actions().pop())
assert len(simulation.get_possible_actions()) == 8
assert all(
map(lambda c: isinstance(c, DiscardCard),
simulation.get_possible_actions()))
assert simulation.state.players[Character.SCIENTIST].num_cards() == 8
simulation.step(simulation.get_possible_actions().pop())
assert simulation.state.players[Character.SCIENTIST].num_cards() == 7
assert len(simulation.get_possible_actions()) > 0
assert any(
map(lambda c: not isinstance(c, DiscardCard),
simulation.get_possible_actions()))
def test_quarantine_specialist():
simulation = create_less_random_simulation(start_player=Character.QUARANTINE_SPECIALIST)
before = simulation.state.cities[City.HO_CHI_MINH_CITY].viral_state[Virus.RED]
outbreaks = simulation.state.outbreaks
simulation.state.infection_deck.insert(0, City.HO_CHI_MINH_CITY)
simulation.state.phase = Phase.INFECTIONS
simulation.step(None)
if before < 3:
assert simulation.state.cities[City.HO_CHI_MINH_CITY].viral_state[Virus.RED] == before + 1
else:
assert simulation.state.outbreaks > outbreaks
before = simulation.state.cities[City.ATLANTA].viral_state[Virus.RED]
outbreaks = simulation.state.outbreaks
simulation.state.infection_deck.insert(0, City.ATLANTA)
simulation.state.phase = Phase.INFECTIONS
simulation.step(None)
assert simulation.state.cities[City.ATLANTA].viral_state[Virus.RED] == before
assert outbreaks == simulation.state.outbreaks
before = simulation.state.cities[City.WASHINGTON].viral_state[Virus.RED]
outbreaks = simulation.state.outbreaks
simulation.state.infection_deck.insert(0, City.WASHINGTON)
simulation.state.phase = Phase.INFECTIONS
simulation.step(None)
assert simulation.state.cities[City.WASHINGTON].viral_state[Virus.RED] == before
assert outbreaks == simulation.state.outbreaks
def test_build_research_station():
simulation = create_less_random_simulation(start_player=Character.SCIENTIST)
simulation.state.players[Character.SCIENTIST]._city_cards = {City.ATLANTA, City.WASHINGTON, City.NEW_YORK}
build = BuildResearchStation(city=City.ATLANTA)
assert build not in simulation.get_possible_actions()
simulation.step(DriveFerry(Character.SCIENTIST, destination=City.WASHINGTON))
assert not simulation.state.cities[City.WASHINGTON].has_research_station()
build = BuildResearchStation(city=City.WASHINGTON)
assert build in simulation.get_possible_actions()
assert simulation.state.research_stations == 5
simulation.step(build)
assert simulation.state.cities[City.WASHINGTON].has_research_station()
assert simulation.state.players[Character.SCIENTIST]._city_cards == {City.ATLANTA, City.NEW_YORK}
assert simulation.state.research_stations == 4
simulation.state.research_stations = 0
simulation.step(DriveFerry(Character.SCIENTIST, City.NEW_YORK))
assert not simulation.state.cities[City.NEW_YORK].has_research_station()
build = BuildResearchStation(city=City.NEW_YORK)
simulation.step(build)
move_station = MoveResearchStation(Character.SCIENTIST, City.ATLANTA)
assert set([MoveResearchStation(Character.SCIENTIST, City.WASHINGTON), move_station]) == set(
simulation.get_possible_actions()
)
simulation.step(move_station)
assert simulation.state.research_stations == 0
assert simulation.state.cities[City.NEW_YORK].has_research_station()
assert not simulation.state.cities[City.ATLANTA].has_research_station()
assert simulation.state.phase == Phase.ACTIONS
def test_cure_virus():
simulation = create_less_random_simulation(
start_player=Character.RESEARCHER)
simulation.state.players[Character.RESEARCHER]._city_cards = {
City.BANGKOK,
City.HO_CHI_MINH_CITY,
City.BEIJING,
City.MANILA,
City.HONG_KONG,
}
cure_action = DiscoverCure(target_virus=Virus.RED)
assert cure_action in simulation.get_possible_actions()
simulation.step(cure_action)
assert len(simulation.get_possible_actions()) == 5
cure_virus(
simulation,
[
City.BANGKOK, City.HO_CHI_MINH_CITY, City.BEIJING, City.MANILA,
City.HONG_KONG
],
Character.RESEARCHER,
)
assert simulation.state.cures[Virus.RED]
assert not simulation.state.cures[Virus.BLUE]
assert not simulation.state.cures[Virus.BLACK]
assert not simulation.state.cures[Virus.YELLOW]
assert len(simulation.state.players[Character.RESEARCHER].cards) == 0
def test_one_card_too_many_with_event_use_event():
simulation = create_less_random_simulation()
# cheat and pretend virus is eradicated
simulation.state.players[Character.SCIENTIST].add_cards([
City.BANGKOK,
City.HO_CHI_MINH_CITY,
City.BEIJING,
City.MANILA,
City.HONG_KONG,
City.SYDNEY,
City.ALGIERS,
EventCard.ONE_QUIET_NIGHT,
])
assert len(simulation.get_possible_actions()) == 9
assert all(
map(lambda c: isinstance(c, DiscardCard) or isinstance(c, Event),
simulation.get_possible_actions()))
event = OneQuietNight(Character.SCIENTIST)
assert event in simulation.get_possible_actions()
simulation.step(event)
assert simulation.state.players[Character.SCIENTIST].num_cards() == 7
assert len(simulation.get_possible_actions()) > 0
assert any(
map(lambda c: not isinstance(c, DiscardCard),
simulation.get_possible_actions()))
def test_outbreak():
simulation = create_less_random_simulation(
start_player=Character.RESEARCHER)
simulation.state.cities[City.ATLANTA].viral_state[Virus.BLUE] = 3
before = simulation.state.outbreaks
assert before == 0
assert simulation.state.infect_city(City.ATLANTA, times=1)
assert simulation.state.cities[City.ATLANTA].viral_state[
Virus.BLUE] == 3
assert simulation.state.outbreaks > before
def test_lose_conditions_no_cubes():
simulation = create_less_random_simulation()
simulation.state.actions_left = 1
simulation.state.phase = Phase.INFECTIONS
simulation.state.infect_city(City.ATLANTA, times=3)
simulation.state.cubes[Virus.BLUE] = 0
assert simulation.state.game_state == GameState.RUNNING
simulation.state.infection_deck.insert(0, City.ATLANTA)
simulation.step(None)
assert simulation.state.game_state == GameState.LOST
def test_lose_conditions_epidemic_counter():
simulation = create_less_random_simulation()
simulation.state.actions_left = 1
simulation.state.phase = Phase.INFECTIONS
simulation.state.infect_city(City.ATLANTA, times=3)
simulation.state.outbreaks = 7
assert simulation.state.game_state == GameState.RUNNING
simulation.state.infection_deck.insert(0, City.ATLANTA)
simulation.step(None)
assert simulation.state.outbreaks >= 8
assert simulation.state.game_state == GameState.LOST
def test_lose_conditions_no_player_cards():
simulation = create_less_random_simulation()
simulation.state.actions_left = 1
simulation.step(
filter_out_events(simulation.get_possible_actions(), Event).pop())
simulation.state.player_deck = [City.ATLANTA]
assert simulation.state.game_state == GameState.RUNNING
assert simulation.state.phase == Phase.DRAW_CARDS
simulation.step(None)
assert simulation.state.game_state == GameState.RUNNING
assert simulation.state.phase == Phase.DRAW_CARDS
simulation.step(None)
assert simulation.state.game_state == GameState.LOST
assert simulation.state.phase == Phase.INFECTIONS
def test_treat_city_with_cure():
simulation = create_less_random_simulation()
# in
simulation.state.infect_city(City.ATLANTA, times=3)
simulation.state.cures[Virus.BLUE] = True
assert simulation.state.cities[City.ATLANTA].viral_state[
Virus.BLUE] == 3
other = TreatDisease(City.ATLANTA, target_virus=Virus.BLUE)
assert other in simulation.get_possible_actions()
simulation.step(other)
assert simulation.state.cities[City.ATLANTA].viral_state[
Virus.BLUE] == 0
def test_dispatcher():
simulation = create_less_random_simulation(start_player=Character.DISPATCHER)
active_player = simulation.state.active_player
simulation.state.players[active_player].city = City.MADRID
dispatch_self = Dispatch(active_player, City.ATLANTA)
assert dispatch_self in simulation.get_possible_actions()
move_other_player: DriveFerry = DriveFerry(Character.SCIENTIST, City.WASHINGTON)
assert move_other_player in simulation.get_possible_actions()
assert Dispatch(Character.SCIENTIST, City.MADRID) in simulation.get_possible_actions()
simulation.step(dispatch_self)
assert simulation.state.players[active_player].city == City.ATLANTA
assert move_other_player in simulation.get_possible_actions()
simulation.step(move_other_player)
assert simulation.state.players[Character.SCIENTIST].city == City.WASHINGTON
def test_government_grant():
simulation = create_less_random_simulation()
active_player = simulation.state.active_player
simulation.state.players[active_player].add_card(
EventCard.GOVERNMENT_GRANT)
assert not simulation.state.cities[City.BAGHDAD].has_research_station()
event = GovernmentGrant(player=active_player, target_city=City.BAGHDAD)
actions = simulation.get_possible_actions()
assert event in actions
assert GovernmentGrant(player=active_player,
target_city=City.ATLANTA) not in actions
simulation.step(event)
assert simulation.state.cities[City.BAGHDAD].has_research_station()
def test_already_cured_combination():
simulation = create_less_random_simulation(
start_player=Character.RESEARCHER)
simulation.state.active_player = Character.RESEARCHER
simulation.state.players[Character.RESEARCHER]._city_cards = {
City.BANGKOK,
City.HO_CHI_MINH_CITY,
City.BEIJING,
City.MANILA,
City.HONG_KONG,
}
simulation.state.cures[Virus.RED] = True
assert DiscoverCure(
target_virus=Virus.RED) not in simulation.get_possible_actions()
def test_medic():
simulation = create_less_random_simulation(start_player=Character.MEDIC)
# test treat disease
simulation.state.infect_city(City.ATLANTA, times=3)
treat = TreatDisease(City.ATLANTA, Virus.BLUE)
assert treat in simulation.get_possible_actions()
simulation.step(treat)
assert simulation.state.cities[City.ATLANTA].viral_state[Virus.BLUE] == 0
# test auto treat
simulation.state.infect_city(City.BANGKOK, times=3)
simulation.state.cities[City.BANGKOK].build_research_station()
assert simulation.state.cities[City.BANGKOK].viral_state[Virus.RED] == 3
simulation.state.players[Character.MEDIC].city = City.BANGKOK
simulation.state.players[Character.MEDIC]._city_cards = {
City.BANGKOK,
City.HO_CHI_MINH_CITY,
City.BEIJING,
City.MANILA,
City.HONG_KONG,
}
cure_action = DiscoverCure(target_virus=Virus.RED)
assert cure_action in simulation.get_possible_actions()
simulation.step(cure_action)
cure_virus(
simulation,
[City.BANGKOK, City.HO_CHI_MINH_CITY, City.BEIJING, City.MANILA, City.HONG_KONG],
Character.MEDIC,
)
assert simulation.state.cities[City.BANGKOK].viral_state[Virus.RED] == 0
simulation.state.cubes[Virus.RED] = 12
simulation.state.infect_city(City.HO_CHI_MINH_CITY, times=3)
assert simulation.state.cities[City.HO_CHI_MINH_CITY].viral_state[Virus.RED] == 3
move = DriveFerry(Character.MEDIC, City.HO_CHI_MINH_CITY)
assert move in simulation.get_possible_actions()
simulation.step(move)
assert simulation.state.cities[City.HO_CHI_MINH_CITY].viral_state[Virus.RED] == 0
simulation.state.infection_deck.insert(0, City.HO_CHI_MINH_CITY)
simulation.state.phase = Phase.INFECTIONS
simulation.step(None)
assert simulation.state.cities[City.HO_CHI_MINH_CITY].viral_state[Virus.RED] == 0
def test_operations_export():
simulation = create_less_random_simulation(start_player=Character.OPERATIONS_EXPERT)
simulation.state.players[Character.OPERATIONS_EXPERT]._city_cards = {City.BANGKOK, City.HO_CHI_MINH_CITY}
operations_flight = OperationsFlight(Character.OPERATIONS_EXPERT, City.MADRID, discard_card=City.BANGKOK)
assert operations_flight in simulation.get_possible_actions()
simulation.step(operations_flight)
assert simulation.state.players[Character.OPERATIONS_EXPERT].city == City.MADRID
assert not simulation.state.players[Character.OPERATIONS_EXPERT].operations_expert_has_charter_flight()
build_research_station = BuildResearchStation(City.MADRID)
assert build_research_station in simulation.get_possible_actions()
simulation.step(build_research_station)
assert simulation.state.cities[City.MADRID].has_research_station()
assert simulation.state.players[Character.OPERATIONS_EXPERT]._city_cards == {City.HO_CHI_MINH_CITY}
assert not any(filter(lambda a: isinstance(a, OperationsFlight), simulation.get_possible_actions()))
def test_airlift():
simulation = create_less_random_simulation()
active_player = simulation.state.active_player
simulation.state.players[active_player].add_card(EventCard.AIRLIFT)
event = Airlift(player=active_player,
target_player=Character.RESEARCHER,
destination=City.MANILA)
actions = simulation.get_possible_actions()
assert event in actions
simulation.step(event)
assert simulation.state.players[
Character.RESEARCHER].city == City.MANILA
assert EventCard.AIRLIFT not in simulation.state.players[
active_player].cards
assert EventCard.AIRLIFT in simulation.state.player_discard_pile
def test_resilient_population():
simulation = create_less_random_simulation()
active_player = simulation.state.active_player
simulation.state.players[active_player].add_card(
EventCard.RESILIENT_POPULATION)
discard_pile_top_card = simulation.state.infection_discard_pile[0]
event = ResilientPopulation(player=active_player,
discard_city=discard_pile_top_card)
actions = simulation.get_possible_actions()
assert len(set(simulation.state.infection_discard_pile)) == len(
simulation.state.infection_discard_pile)
assert len(
list(filter(lambda a: isinstance(a, ResilientPopulation),
actions))) == len(
simulation.state.infection_discard_pile)
assert event in actions
simulation.step(event)
assert discard_pile_top_card not in simulation.state.infection_discard_pile
def test_researcher():
simulation = create_less_random_simulation(start_player=Character.RESEARCHER)
simulation.state.players[Character.RESEARCHER]._city_cards = {City.BANGKOK, City.HO_CHI_MINH_CITY}
share_knowledge = ShareKnowledge(Character.RESEARCHER, City.BANGKOK, Character.SCIENTIST)
assert share_knowledge in simulation.get_possible_actions()
assert (
ShareKnowledge(Character.RESEARCHER, City.HO_CHI_MINH_CITY, Character.SCIENTIST)
in simulation.get_possible_actions()
)
simulation.step(share_knowledge)
assert simulation.state.players[Character.RESEARCHER].cards == {City.HO_CHI_MINH_CITY}
assert simulation.state.players[Character.SCIENTIST].cards == {City.BANGKOK}
simulation.state.active_player = Character.SCIENTIST
assert share_knowledge not in simulation.get_possible_actions()
assert (
ShareKnowledge(Character.RESEARCHER, City.HO_CHI_MINH_CITY, Character.SCIENTIST)
in simulation.get_possible_actions()
)
def test_contingency_planner():
simulation = create_less_random_simulation(start_player=Character.CONTINGENCY_PLANNER)
active_player = simulation.state.active_player
simulation.state.player_discard_pile = [EventCard.ONE_QUIET_NIGHT]
ability = ReserveCard(EventCard.ONE_QUIET_NIGHT)
assert ability in simulation.get_possible_actions()
simulation.step(ability)
assert simulation.state.players[active_player].contingency_planner_card == EventCard.ONE_QUIET_NIGHT
assert EventCard.ONE_QUIET_NIGHT in simulation.state.players[active_player].cards
assert EventCard.ONE_QUIET_NIGHT not in simulation.state.player_discard_pile
event = OneQuietNight(player=active_player)
actions = simulation.get_possible_actions()
assert event in actions
simulation.step(event)
assert simulation.state.one_quiet_night
assert EventCard.ONE_QUIET_NIGHT not in simulation.state.players[active_player].cards
assert simulation.state.players[active_player].contingency_planner_card is None
assert EventCard.ONE_QUIET_NIGHT not in simulation.state.player_discard_pile
def test_give_card_sharing():
simulation = create_less_random_simulation()
active_player = simulation.state.active_player
other_player = simulation.state.get_next_player()
simulation.state.players[active_player].add_card(City.ATLANTA)
sharing_action = ShareKnowledge(card=City.ATLANTA,
player=active_player,
target_player=other_player)
assert sharing_action in simulation.get_possible_actions()
simulation.step(sharing_action)
assert City.ATLANTA not in simulation.state.players[
active_player].cards
assert City.ATLANTA in simulation.state.players[other_player].cards
assert sharing_action not in simulation.get_possible_actions()
def test_forecast():
simulation = create_less_random_simulation()
active_player = simulation.state.active_player
simulation.state.players[active_player].add_card(EventCard.FORECAST)
our_shuffle = simulation.state.infection_deck[:6].copy()
random.shuffle(our_shuffle)
event = Forecast(player=active_player)
actions = simulation.get_possible_actions()
assert event in actions
simulation.step(event)
assert EventCard.FORECAST not in simulation.state.players[
active_player].cards
for idx, card in enumerate(our_shuffle):
order = ChooseCard(active_player, card)
assert order in simulation.get_possible_actions()
assert len(list(simulation.get_possible_actions())) == 6 - idx
simulation.step(order)
assert our_shuffle == simulation.state.infection_deck[:6]
def test_multiple_cure_combinations():
simulation = create_less_random_simulation(
start_player=Character.RESEARCHER)
simulation.state.active_player = Character.RESEARCHER
cure_cards = [
City.BANGKOK, City.HO_CHI_MINH_CITY, City.BEIJING, City.MANILA,
City.HONG_KONG, City.SYDNEY
]
simulation.state.players[Character.RESEARCHER].cards = set(
cure_cards).union({EventCard.ONE_QUIET_NIGHT})
assert DiscoverCure(
target_virus=Virus.RED) in simulation.get_possible_actions()
simulation.step(DiscoverCure(target_virus=Virus.RED))
actions = simulation.get_possible_actions()
choices = {
ChooseCard(Character.RESEARCHER, card)
for card in cure_cards
}
assert choices == set(actions)
assert len(actions) == len(choices)
def test_player_change():
simulation = create_less_random_simulation()
active_player = simulation.state.active_player
assert simulation.state.get_next_player() != active_player
simulation.state.active_player = simulation.state.get_next_player()
assert simulation.state.get_next_player() == active_player
