def _handle_tested_conditional_layers_updated(self,
event,
resolver=None,
from_startup=False):
if resolver is None:
resolver = GlobalResolver()
layers_to_test = self._test_event_to_conditional_layers[event]
layers_to_destroy = set()
layers_to_load = set()
for (conditional_layer, tests) in layers_to_test:
is_active = conditional_layer in self._active_street_conditional_layers
if tests.run_tests(resolver):
if not is_active:
layers_to_load.add(conditional_layer)
if is_active:
layers_to_destroy.add(conditional_layer)
elif is_active:
layers_to_destroy.add(conditional_layer)
speed = ConditionalLayerRequestSpeedType.GRADUALLY if services.current_zone(
).is_zone_running else ConditionalLayerRequestSpeedType.IMMEDIATELY
for layer_to_destroy in layers_to_destroy:
if self._tested_layer_processing_type.get(
layer_to_destroy) and self._defer_counter > 0:
self.add_conditional_layer_processing_callback(
self.destroy_street_layer, (layer_to_destroy, speed))
else:
self.destroy_street_layer(layer_to_destroy, speed)
for layer_to_load in layers_to_load:
if self._tested_layer_processing_type.get(
layer_to_load) and self._defer_counter > 0:
self.add_conditional_layer_processing_callback(
self.load_street_layer, (layer_to_load, speed))
else:
self.load_street_layer(layer_to_load, speed)
def activate_holiday(self, from_load=False, from_customization=False):
if self._state >= HolidayState.RUNNING:
logger.error(
'Tradition {} is trying to be put into the Running state, but is already in {} which is farther along.',
self, self._state)
return
self._deactivate_pre_holiday()
self._state = HolidayState.RUNNING
if self.holiday_buffs:
services.sim_spawner_service().register_sim_spawned_callback(
self.on_sim_spawned)
for sim_info in services.sim_info_manager().instanced_sims_gen():
for buff in self.holiday_buffs:
buff_handle = sim_info.add_buff(
buff, buff_reason=self.holiday_buff_reason)
if buff_handle is not None:
self._buffs_added[sim_info.sim_id].append(buff_handle)
for (key, event) in enumerate(self.events):
self._create_event_alarm(key, event)
if not from_load:
resolver = GlobalResolver()
for actions in self.lifecycle_actions:
actions.try_perform(
resolver, TraditionActivationEvent.TRADITION_ADD
if from_customization else
TraditionActivationEvent.HOLIDAY_ACTIVATE)
if self.drama_nodes_to_score:
sim_timeline = services.time_service().sim_timeline
self._drama_node_processor = sim_timeline.schedule(
elements.GeneratorElement(self._process_scoring_gen))
drama_scheduler = services.drama_scheduler_service()
for drama_node in self.drama_nodes_to_run:
drama_scheduler.run_node(drama_node, resolver)
def load_street_layers(self, street_cls, editmode=False):
resolver = GlobalResolver()
tests_to_register = []
for tested_conditional_layer in street_cls.tested_conditional_layers:
if editmode and not tested_conditional_layer.test_on_managed_world_edit_mode_load:
continue
self._tested_layer_processing_type[
tested_conditional_layer.
conditional_layer] = tested_conditional_layer.process_after_event_handled
tests = tested_conditional_layer.tests
conditional_layer = tested_conditional_layer.conditional_layer
should_be_loaded = tests.run_tests(resolver)
is_loaded = self.is_layer_loaded(conditional_layer)
if should_be_loaded:
self._active_street_conditional_layers.add(conditional_layer)
if not is_loaded:
self.load_conditional_layer(conditional_layer)
elif conditional_layer.client_only:
self._set_client_layer(conditional_layer, True)
elif not should_be_loaded and is_loaded:
self._active_street_conditional_layers.discard(
conditional_layer)
self.destroy_conditional_layer(conditional_layer)
for test in tests:
key_events_for_conditional_layer = set(
event for (event, _) in itertools.chain(
test.get_test_events_to_register(),
test.get_custom_event_registration_keys()))
for key_event in key_events_for_conditional_layer:
self._test_event_to_conditional_layers[key_event].append(
(conditional_layer, tests))
tests_to_register.append(test)
if tests_to_register:
services.get_event_manager().register_tests(
self, tests_to_register)
def on_state_activated(self, reader=None, preroll_time_override=None):
super().on_state_activated(reader=reader, preroll_time_override=preroll_time_override)
for situation in self._owner.get_running_festival_situations():
situation.put_on_cooldown()
if self.notification is None:
return
resolver = GlobalResolver()
notification = self.notification(services.active_sim_info(), resolver=resolver)
notification.show_dialog()
def on_zone_load(self):
self._should_suppress_travel_sting = False
if self.introduction is not None:
if not self._introduction_shown:
resolver = GlobalResolver()
if self.introduction.tests.run_tests(resolver):
dialog = self.introduction.dialog(None, resolver=resolver)
dialog.show_dialog()
self._introduction_shown = True
self._should_suppress_travel_sting = self.introduction.dialog.audio_sting is not None
def _pre_festival_alarm_callback(self, _):
self._try_and_start_festival()
services.get_event_manager().process_events_for_household(TestEvent.FestivalStarted, services.active_household())
if self.starting_notification is not None:
resolver = GlobalResolver()
starting_notification = self.starting_notification(services.active_sim_info(), resolver=resolver)
starting_notification.show_dialog(response_command_tuple=tuple([CommandArgType.ARG_TYPE_INT, self.guid64]))
if self.additional_drama_nodes:
sim_timeline = services.time_service().sim_timeline
self._additional_nodes_processor = sim_timeline.schedule(elements.GeneratorElement(self._process_scoring_gen))
def get_possible_replacement_situation(self, situation_type):
resolver = GlobalResolver()
for narrative in self._active_narratives:
replacement_map = narrative.situation_replacements
if situation_type not in replacement_map:
continue
replacement_data = replacement_map[situation_type]
if replacement_data.replacement_tests.run_tests(resolver):
return replacement_data.replacement
return situation_type
def get_weighted_situations(cls, predicate=lambda _: True):
resolver = GlobalResolver()
def get_weight(item):
if not predicate(item.situation):
return 0
if not item.tests.run_tests(resolver):
return 0
return item.weight_multipliers.get_multiplier(resolver)*item.situation.weight_multipliers.get_multiplier(resolver)
weighted_situations = tuple((get_weight(item), (item.situation, dict(item.params.items()))) for item in cls.weighted_situations)
return weighted_situations
def get_desired_sim_count(self):
desire = self._desired_siutations
if desire is None:
return TunedIntervalLiteral(0)
resolver = GlobalResolver()
sim_count_multiplier = self.desired_sim_count_multipliers.get_multiplier(
resolver)
lower_bound = round(desire.desired_sim_count.lower_bound *
sim_count_multiplier)
upper_bound = round(desire.desired_sim_count.upper_bound *
sim_count_multiplier)
return TunedInterval(lower_bound, upper_bound)
def start(self):
if self.dialog_on_activation is not None:
resolver = GlobalResolver()
if self.dialog_on_activation.tests.run_tests(resolver):
dialog = self.dialog_on_activation.dialog(None,
resolver=resolver)
dialog.show_dialog()
if self.audio_sting is not None:
play_tunable_audio(self.audio_sting)
if self.sim_info_loots is not None:
services.narrative_service().add_sliced_sim_info_loots(
self.sim_info_loots.loots,
self.sim_info_loots.save_lock_tooltip)
def can_be_given_as_goal(cls, actor, situation, **kwargs):
if actor is not None:
resolver = event_testing.resolver.DataResolver(
actor.sim_info, None)
result = cls._pre_tests.run_tests(resolver)
if not result:
return result
else:
resolver = GlobalResolver()
environment_test_result = cls._environment_pre_tests.run_tests(
resolver)
if not environment_test_result:
return environment_test_result
return TestResult.TRUE
def _get_end_notification_resolver_and_tokens(self):
sims = [
sim for sim in self.all_sims_in_situation_gen()
if sim.get_stat_value(self.contest_statistic) > 0
]
if not sims:
return (GlobalResolver(), tuple())
sims.sort(
key=lambda item:
(item.get_stat_value(self.contest_statistic), item.is_selectable),
reverse=True)
gold_sim = sims[0]
return (SingleSimResolver(gold_sim.sim_info),
(gold_sim.get_stat_value(self.contest_statistic), ))
def _get_expected_number_of_fans(self):
if self._celebrity_container_situation is None:
return 0
fans_cap = self.fans_cap(resolver=GlobalResolver())
if fans_cap <= 0:
return 0
expected_fans = 0
for sim in self._celebrity_container_situation.all_sims_in_situation_gen(
):
expected_fans += self._get_num_fans_for_fame_level(
self._get_fame_level(sim))
if expected_fans >= fans_cap:
break
return min(expected_fans, fans_cap)
def deactivate_holiday(self, from_customization=False):
if self._state != HolidayState.RUNNING:
logger.error(
'Tradition {} is trying to deactivate the tradition, but it is in the {} state, not that one.',
self, self._state)
self._state = HolidayState.SHUTDOWN
if self.holiday_buffs:
services.sim_spawner_service().unregister_sim_spawned_callback(
self.on_sim_spawned)
self._remove_all_buffs()
for alarm in self._event_alarm_handles.values():
alarms.cancel_alarm(alarm)
self._event_alarm_handles.clear()
resolver = GlobalResolver()
for actions in self.lifecycle_actions:
actions.try_perform(
resolver,
TraditionActivationEvent.TRADITION_REMOVE if from_customization
else TraditionActivationEvent.HOLIDAY_DEACTIVATE)
def _do_change(self, from_finalize=False):
if not self._is_on_active_street():
if not from_finalize:
self._change_pending = True
return
self._change_pending = False
change_layer = not self.tests or self.tests.run_tests(
StreetResolver(self._street))
if change_layer:
self.layer.change_conditional_layer(
invert_show=not self.policy.enacted)
if from_finalize:
return
if not change_layer and not self.always_show_dialog:
return
dialog = self.active_street_enact_dialog if self.policy.enacted else self.active_street_repeal_dialog
if dialog is not None:
dialog = dialog(None, resolver=GlobalResolver())
dialog.show_dialog()
def _start_special_bar_event(self, scheduler, alarm_data, extra_data):
tested_situation = alarm_data.entry.situation
situation = tested_situation.situation
if not situation.situation_meets_starting_requirements():
return
situation_manager = services.get_zone_situation_manager()
if any(situation is type(running_situation) for running_situation in
situation_manager.running_situations()):
return
tests = tested_situation.tests
if tests:
resolver = GlobalResolver()
if not tests.run_tests(resolver):
return
guest_list = SituationGuestList(invite_only=True)
situation_manager.create_situation(situation,
guest_list=guest_list,
user_facing=False,
scoring_enabled=False,
creation_source=self.instance_name)
def _start_welcome_wagon(self, _):
situation_manager = services.get_zone_situation_manager()
if situation_manager.is_user_facing_situation_running():
self._schedule_welcome_wagon()
return
active_household = services.active_household()
for sim_info in active_household.can_live_alone_info_gen():
if sim_info.is_instanced():
break
else:
self._schedule_welcome_wagon()
return
resolver = GlobalResolver()
if not NPCHostedSituationService.WELCOME_WAGON_TUNING.welcome_wagon_start_tests.run_tests(
resolver):
active_household.needs_welcome_wagon = False
return
narrative_service = services.narrative_service()
welcome_wagon_situation = narrative_service.get_possible_replacement_situation(
NPCHostedSituationService.WELCOME_WAGON_TUNING.situation)
if welcome_wagon_situation is NPCHostedSituationService.WELCOME_WAGON_TUNING.situation:
region = services.current_region()
if region.welcome_wagon_replacement is not None:
welcome_wagon_situation = region.welcome_wagon_replacement
guest_list = welcome_wagon_situation.get_predefined_guest_list()
if guest_list is None:
active_household.needs_welcome_wagon = False
return
game_clock_services = services.game_clock_service()
if game_clock_services.clock_speed == ClockSpeedMode.SUPER_SPEED3:
game_clock_services.set_clock_speed(ClockSpeedMode.NORMAL)
situation_id = situation_manager.create_situation(
welcome_wagon_situation,
guest_list=guest_list,
user_facing=False,
scoring_enabled=False)
if not (situation_id is None
or not welcome_wagon_situation.sets_welcome_wagon_flag):
active_household.needs_welcome_wagon = False
def callback(_):
event.event.perform(GlobalResolver())
del self._event_alarm_handles[key]
def _get_end_notification_resolver_and_tokens(self):
return (GlobalResolver(), tuple())
def run_auto_voting_tests(self, test_set):
if not services.street_service().enable_automatic_voting:
return False
if not test_set:
return True
return test_set.run_tests(GlobalResolver())
def on_ready_to_move(self):
if self._tests_to_continue.run_tests(GlobalResolver()):
self._move_objects()
self._change_state(self._waiting_to_move_state())
else:
self._self_destruct()
def modify_objects(self, object_criteria=None):
objects_to_destroy = []
num_modified = 0
modifications = defaultdict(CompoundTestList)
for mod in self.modifications:
if not random_chance(mod.chance * 100):
continue
if mod.global_tests and not mod.global_tests.run_tests(
GlobalResolver()):
continue
if mod.tests:
modifications[mod.action].extend(mod.tests)
if mod.weighted_tests:
weighted_tests = []
for test_weight_pair in mod.weighted_tests:
weighted_tests.append(
(test_weight_pair.weight, test_weight_pair.tests))
modifications[mod.action].extend(
weighted_random_item(weighted_tests))
if not modifications:
return num_modified
all_objects = list(services.object_manager().values())
for obj in all_objects:
if obj.is_sim:
continue
if object_criteria is not None and not object_criteria(obj):
continue
resolver = SingleObjectResolver(obj)
modified = False
for (action, tests) in modifications.items():
if not tests.run_tests(resolver):
continue
modified = True
action_type = action.action_type
if action_type == ModifyAllLotItems.DESTROY_OBJECT:
objects_to_destroy.append(obj)
break
elif action_type == ModifyAllLotItems.SET_STATE:
new_state_value = action.action_value
if obj.state_component and obj.has_state(
new_state_value.state):
obj.set_state(new_state_value.state,
new_state_value,
immediate=True)
if action_type in (
ModifyAllLotItems.INVENTORY_TRANSFER,
ModifyAllLotItems.DELIVER_BILLS):
element = action.action_value()
element._do_behavior()
elif action_type == ModifyAllLotItems.SET_ON_FIRE:
fire_service = services.get_fire_service()
fire_service.spawn_fire_at_object(obj)
elif action_type == ModifyAllLotItems.CLEANUP_VEHICLE:
if self._should_cleanup_vehicle(obj):
objects_to_destroy.append(obj)
if action_type == ModifyAllLotItems.LOOT:
for loot_action in action.loot_actions:
loot_action.apply_to_resolver(resolver)
else:
raise NotImplementedError
else:
raise NotImplementedError
elif action_type == ModifyAllLotItems.LOOT:
for loot_action in action.loot_actions:
loot_action.apply_to_resolver(resolver)
else:
raise NotImplementedError
else:
raise NotImplementedError
elif action_type in (ModifyAllLotItems.INVENTORY_TRANSFER,
ModifyAllLotItems.DELIVER_BILLS):
element = action.action_value()
element._do_behavior()
elif action_type == ModifyAllLotItems.SET_ON_FIRE:
fire_service = services.get_fire_service()
fire_service.spawn_fire_at_object(obj)
elif action_type == ModifyAllLotItems.CLEANUP_VEHICLE:
if self._should_cleanup_vehicle(obj):
objects_to_destroy.append(obj)
if action_type == ModifyAllLotItems.LOOT:
for loot_action in action.loot_actions:
loot_action.apply_to_resolver(resolver)
else:
raise NotImplementedError
else:
raise NotImplementedError
elif action_type == ModifyAllLotItems.LOOT:
for loot_action in action.loot_actions:
loot_action.apply_to_resolver(resolver)
else:
raise NotImplementedError
else:
raise NotImplementedError
if modified:
num_modified += 1
for obj in objects_to_destroy:
obj.destroy(source=self,
cause='Destruction requested by modify lot tuning')
objects_to_destroy = None
return num_modified
def _handle_notification(self, notification, zone_id):
if notification is not None and services.current_zone_id() == zone_id:
notification = notification(None, resolver=GlobalResolver())
notification.show_dialog()
def _get_target(self):
resolver = GlobalResolver()
return resolver.get_participant(self.participant)
