def process_round(self, state: GameState):
pathogens_without_vaccine = set(state.pathogens).difference(
state.pathogens_with_vaccination)
pathogens_without_vaccine = list(
pathogens_without_vaccine.difference(
state.pathogens_with_vaccination_in_development))
if pathogens_without_vaccine:
# develop all vaccines first
if state.points >= 40:
return develop_vaccine(pathogens_without_vaccine[0].index)
else:
return end_round()
else:
pathogens_with_vaccine = state.pathogens_with_vaccination
if pathogens_with_vaccine:
if state.points >= 5:
# collect all not vaccinated outbreaks
outbreaks_to_vaccinate = []
for city in state.cities:
events: list = city.events
vaccinated_pathogens = list(
map(
lambda event: event.pathogen,
filter(
lambda event: event.event_type ==
"vaccineDeployed", events)))
outbreaks = list(
filter(
lambda event: event.event_type == "outbreak",
events))
outbreaks = list(
filter(
lambda outbreak_event: outbreak_event.pathogen
in pathogens_with_vaccine, outbreaks))
outbreaks = list(
filter(
lambda outbreak_event: outbreak_event.pathogen
not in vaccinated_pathogens, outbreaks))
outbreaks_to_vaccinate.extend(
list(
map(
lambda outbreak_event:
(city, outbreak_event), outbreaks)))
if outbreaks_to_vaccinate:
outbreaks_to_vaccinate.sort(key=self.outbreak_priority,
reverse=True)
outbreak_to_vaccinate = outbreaks_to_vaccinate[0]
return deploy_vaccine(
outbreak_to_vaccinate[1].pathogen.index,
outbreak_to_vaccinate[0].index)
else:
return end_round()
else:
return end_round()
else:
return end_round()
def generate_deployment_action(self, possible_actions: list, state: GameState):
executable_actions = list(filter(lambda action: self.is_action_executable(action, state), possible_actions))
if executable_actions:
action = executable_actions[0]
if action.is_vaccine:
return deploy_vaccine(action.pathogen.index, action.city_id)
else:
return deploy_medication(action.pathogen.index, action.city_id)
else:
return end_round()
def _generate_city_vaccine_actions(
cls, city: City, ordered_available_pathogens: List[Pathogen],
pathogens_with_vaccination: List[Pathogen]):
city_pathogens_with_vaccine = list(
filter(
lambda city_pathogen: city_pathogen in
pathogens_with_vaccination, city.pathogens))
ordered_city_pathogens_with_vaccine = [
actions.deploy_vaccine(pathogen.index, city.index)
if pathogen in city_pathogens_with_vaccine else INVALID_ACTION
for pathogen in ordered_available_pathogens
]
return ordered_city_pathogens_with_vaccine
def process_round(self, state: GameState):
possible_actions = []
points = state.points
for city in state.cities:
if points >= 5:
not_vaccinated_outbreaks = self.get_not_vaccinated_outbreaks_for_city(city)
actions = list(map(
lambda outbreak: self.generate_possible_action(outbreak, city, True,
state.pathogens_with_vaccination),
not_vaccinated_outbreaks))
possible_actions.extend(actions)
if points >= 10:
not_medicated_outbreaks = self.get_not_medicated_outbreaks_for_city(city)
actions = list(map(
lambda outbreak: self.generate_possible_action(outbreak, city, False,
state.pathogens_with_medication),
not_medicated_outbreaks))
possible_actions.extend(actions)
if possible_actions:
possible_actions.sort(key=lambda action: action.priority, reverse=True)
action = possible_actions[0]
pathogen = action.pathogen
if action.is_vaccine:
if pathogen in state.pathogens_with_vaccination:
return deploy_vaccine(pathogen.index, action.city_id)
elif pathogen not in state.pathogens_with_vaccination_in_development:
if points >= 40:
return develop_vaccine(pathogen.index)
else:
return end_round()
else:
return self.generate_deployment_action(possible_actions, state)
else:
if pathogen in state.pathogens_with_medication:
return deploy_medication(pathogen.index, action.city_id)
elif pathogen not in state.pathogens_with_medication_in_development:
if points >= 20:
return develop_medication(pathogen.index)
else:
return end_round()
else:
return self.generate_deployment_action(possible_actions, state)
else:
return end_round()
def test_generate_city_vaccine_actions(
simple_act_state_processor: SimpleActStateProcessor,
city_with_pathogens: City, available_pathogens: List[Pathogen],
pathogens_with_vaccination: List[Pathogen]):
deploy_vaccine_actions = [
actions.deploy_vaccine(pathogen.index, city_with_pathogens.index)
if pathogen in city_with_pathogens.pathogens
and pathogen in pathogens_with_vaccination else INVALID_ACTION
for pathogen in available_pathogens
]
assert simple_act_state_processor._generate_city_vaccine_actions(
city_with_pathogens, available_pathogens,
pathogens_with_vaccination) == deploy_vaccine_actions
assert simple_act_state_processor._generate_city_vaccine_actions(
city_with_pathogens, available_pathogens,
list(reversed(pathogens_with_vaccination))) == deploy_vaccine_actions
assert simple_act_state_processor._generate_city_vaccine_actions(
city_with_pathogens, list(reversed(available_pathogens)),
pathogens_with_vaccination) == list(reversed(deploy_vaccine_actions))