def on_update(self):
super().on_update()
if not services.sim_spawner_service().batch_spawning_complete:
return _ZoneSpinUpStateResult.WAITING
client = services.client_manager().get_first_client()
services.sim_info_manager().on_spawn_sim_for_zone_spin_up_completed(
client)
services.venue_service().get_zone_director(
).on_spawn_sim_for_zone_spin_up_completed()
services.current_zone(
).venue_service.handle_active_lot_changing_edge_cases()
services.get_zone_situation_manager(
).on_all_sims_spawned_during_zone_spin_up()
club_service = services.get_club_service()
if club_service is not None:
club_service.on_finish_waiting_for_sim_spawner_service()
else:
current_zone_id = services.current_zone_id()
household = services.active_household()
if household.home_zone_id != current_zone_id:
sim_info_manager = services.sim_info_manager()
traveled_sims = sim_info_manager.get_traveled_to_zone_sim_infos(
)
if len(traveled_sims) > 1:
services.ensemble_service(
).create_travel_ensemble_if_neccessary(traveled_sims)
services.ensemble_service().on_all_sims_spawned_during_zone_spin_up()
return _ZoneSpinUpStateResult.DONE
def _destroy(self):
if self._neighbor_door_id is not None:
apartment_door = services.object_manager().get(self._neighbor_door_id)
if apartment_door is not None:
apartment_door.set_state(self.loud_door_state_off.state, self.loud_door_state_off)
services.get_zone_situation_manager().remove_sim_from_auto_fill_blacklist(self._neighbor_sim_id)
super()._destroy()
def on_activate(self, reader=None):
super().on_activate(reader)
repo_person = self.owner.repo_person()
if repo_person is not None:
services.get_zone_situation_manager().make_sim_leave_now_must_run(
repo_person)
self.owner._self_destruct()
def on_activate(self, reader=None):
super().on_activate(reader)
sim = self.owner.adoption_officer_sim()
if sim is not None:
services.get_zone_situation_manager().make_sim_leave_now_must_run(
sim)
self.owner._self_destruct()
def reset(_connection=None):
services.get_zone_situation_manager().reset()
for sim in services.sim_info_manager().instanced_sims_gen():
try:
sim.reset_role_tracker()
except Exception:
logger.error('Error while resetting role tracker for sim {}', sim)
def _create_situation(self, additional_sims_to_bring=()):
guest_list = self._situation_to_run.get_predefined_guest_list()
if guest_list is None:
if self._require_predefined_guest_list:
return
host_sim_info = self._get_host(additional_sims_to_bring)
if host_sim_info is None:
return
guest_list = SituationGuestList(invite_only=True, host_sim_id=host_sim_info.id)
else:
host_sim_info = self._get_host(additional_sims_to_bring)
if host_sim_info is None:
return
if self._NPC_hosted_situation_player_job is not None:
guest_list.add_guest_info(SituationGuestInfo.construct_from_purpose(self._receiver_sim_info.id, self._NPC_hosted_situation_player_job, SituationInvitationPurpose.INVITED))
if self._NPC_host_job is not None:
guest_list.add_guest_info(SituationGuestInfo.construct_from_purpose(host_sim_info.id, self._NPC_host_job, SituationInvitationPurpose.INVITED))
if additional_sims_to_bring:
additional_sims_job = self._chosen_dialog.bring_other_sims.situation_job
for sim_info in additional_sims_to_bring:
guest_list.add_guest_info(SituationGuestInfo.construct_from_purpose(sim_info.id, additional_sims_job, SituationInvitationPurpose.INVITED))
if self._NPC_hosted_situation_use_player_sim_as_filter_requester:
guest_list.filter_requesting_sim_id = self._receiver_sim_info.id
services.get_zone_situation_manager().create_situation(self._situation_to_run, guest_list=guest_list, zone_id=self._get_zone_id(), scoring_enabled=self._NPC_hosted_situation_scoring_enabled, user_facing=self._user_facing)
with telemetry_helper.begin_hook(telemetry_writer, TELEMETRY_HOOK_SITUATION_ACCEPTED, sim_info=self._receiver_sim_info) as hook:
hook.write_guid(TELEMETRY_SITUATION_TYPE_ID, self._situation_to_run.guid64)
hook.write_int(TELEMETRY_GUEST_COUNT, len(additional_sims_to_bring))
def _make_greeted(self):
resolver = self.get_resolver()
dialog = self._success_notification(self.sim, resolver)
dialog.show_dialog()
services.get_zone_situation_manager().make_waiting_player_greeted(
self.sim)
self._try_make_always_welcomed(self.sim)
def __call__(self, situation_state):
situation_state.owner._self_destruct()
guest_list = self.new_situation.get_predefined_guest_list()
if guest_list is None:
guest_list = SituationGuestList(invite_only=True)
services.get_zone_situation_manager().create_situation(
self.new_situation, guest_list=guest_list, user_facing=False)
def _create_travel_group_changed_situation_if_nessesary(self):
if self.situation_to_create_on_travel_group_changed is None:
return
current_zone = services.current_zone()
if not current_zone.is_first_visit_to_zone and not current_zone.travel_group_changed_between_save_and_load():
return
services.get_zone_situation_manager().create_situation(self.situation_to_create_on_travel_group_changed, user_facing=False, creation_source=self.instance_name)
def on_destroy(self):
if self._celebrity_container_situation is not None:
services.get_zone_situation_manager().destroy_situation_by_id(
self._celebrity_container_situation_id)
if self._fan_situation_alarm_handle is not None:
alarms.cancel_alarm(self._fan_situation_alarm_handle)
self._fan_situation_alarm_handle = None
def _create_next_situation(self):
worker_sim = next(self.all_sims_in_job_gen(self.default_job()), None)
if worker_sim is not None:
if worker_sim.is_on_active_lot() and self._visit_duration != False:
services.get_zone_situation_manager().create_visit_situation(worker_sim, duration_override=self._visit_duration)
return
services.get_zone_situation_manager().make_sim_leave(worker_sim)
def _on_remove_sim_from_situation(self, sim):
if not services.current_zone().is_zone_running:
super()._on_remove_sim_from_situation(sim)
return
sim_job = self.get_current_job_for_sim(sim)
services.get_zone_situation_manager().add_sim_to_auto_fill_blacklist(
sim.id, sim_job=sim_job)
(pet_sim_info,
pet_owner_sim_info) = self._get_pet_and_owner_sim_infos()
pet_sim_info.remove_linked_sim(pet_owner_sim_info.sim_id)
pet_owner_sim_info.remove_linked_sim(pet_sim_info.sim_id)
pet_owner = self.get_pet_owner()
is_pet_owner = False if pet_owner is None else sim is pet_owner
super()._on_remove_sim_from_situation(sim)
business_manager = services.business_service(
).get_business_manager_for_zone()
if business_manager is not None and is_pet_owner:
business_manager.remove_customer(
sim, review_business=self._should_leave_review)
customer_msg = Business_pb2.BusinessCustomerUpdate()
customer_msg.sim_id = pet_owner_sim_info.sim_id
op = GenericProtocolBufferOp(
DistributorOps_pb2.Operation.BUSINESS_CUSTOMER_REMOVE,
customer_msg)
Distributor.instance().add_op_with_no_owner(op)
def force_neighbors_home(_connection=None):
client = services.client_manager().get_first_client()
active_household = client.household
if active_household is not None:
active_household_home_zone_id = active_household.home_zone_id
active_household_home_world_id = services.get_persistence_service(
).get_world_id_from_zone(active_household_home_zone_id)
send_home = active_household_home_zone_id == services.current_zone().id
blacklist_all_jobs_time = services.time_service(
).sim_now + date_and_time.create_time_span(days=7)
for sim_info in services.sim_info_manager().values():
if sim_info.is_selectable:
continue
sim_info_home_zone_id = sim_info.household.home_zone_id
sim_info_home_world_id = services.get_persistence_service(
).get_world_id_from_zone(sim_info_home_zone_id)
if sim_info_home_world_id == active_household_home_world_id:
services.get_zone_situation_manager(
).add_sim_to_auto_fill_blacklist(
sim_info.id,
None,
blacklist_all_jobs_time=blacklist_all_jobs_time)
if send_home:
if sim_info.zone_id != active_household_home_zone_id:
if sim_info.zone_id != sim_info_home_zone_id:
sim_info.inject_into_inactive_zone(
sim_info_home_zone_id)
def reset(_connection=None):
services.get_zone_situation_manager().reset()
for sim in services.sim_info_manager().instanced_sims_gen():
try:
sim.reset_role_tracker()
except Exception:
logger.error('Error while resetting role tracker for sim {}', sim)
def on_deactivate(self):
if self._infection_spread > 0:
services.get_zone_situation_manager().create_situation(
self._post_welcome_wagon_situation,
user_facing=False,
scoring_enabled=False)
super().on_deactivate()
def __call__(self, sim_infos, host_sim_info=None):
npc_infos = []
selectable_and_resident_infos = []
for sim_info in sim_infos:
if sim_info.is_npc and not sim_info.lives_here:
npc_infos.append(sim_info)
else:
selectable_and_resident_infos.append(sim_info)
if npc_infos:
player_lot_id = services.active_household_lot_id()
active_lot_id = services.active_lot_id()
if active_lot_id == player_lot_id:
if self.player_sim_lot is not None:
self.player_sim_lot(npc_infos, host_sim_info)
if services.get_zone_situation_manager().is_player_greeted():
if self.npc_lot_greeted is not None:
self.npc_lot_greeted(npc_infos, host_sim_info)
if self.npc_lot_ungreeted is not None:
self.npc_lot_ungreeted(npc_infos, host_sim_info)
elif self.npc_lot_ungreeted is not None:
self.npc_lot_ungreeted(npc_infos, host_sim_info)
elif services.get_zone_situation_manager().is_player_greeted():
if self.npc_lot_greeted is not None:
self.npc_lot_greeted(npc_infos, host_sim_info)
if self.npc_lot_ungreeted is not None:
self.npc_lot_ungreeted(npc_infos, host_sim_info)
elif self.npc_lot_ungreeted is not None:
self.npc_lot_ungreeted(npc_infos, host_sim_info)
for sim_info in selectable_and_resident_infos:
while sim_info.get_sim_instance() is None:
op = distributor.ops.TravelBringToZone([sim_info.sim_id, 0, services.current_zone().id, 0])
distributor.system.Distributor.instance().add_op_with_no_owner(op)
def on_npc_start_work(self):
sim = self._career.sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS)
if sim is not None:
career = self._career
sim_info = career.sim_info
current_track = career.current_track_tuning
if current_track.goodbye_notification is not None and sim_info.goodbye_notification is not None:
class _UiDialogNotificationCareerGoodbye:
def __init__(self, *args, **kwargs):
self._dialog = current_track.goodbye_notification(
*args, **kwargs)
def show_dialog(self, *args, **kwargs):
self._dialog.show_dialog(
*args,
additional_tokens=career.get_career_text_tokens(),
**kwargs)
sim_info.try_to_set_goodbye_notification(
_UiDialogNotificationCareerGoodbye)
if self._career.put_sim_in_career_rabbit_hole():
return
services.get_zone_situation_manager().make_sim_leave_now_must_run(
sim)
career.attend_work()
def on_activate(self, reader=None):
super().on_activate(reader=reader)
inspector = self.owner.inspector_person()
self.owner.notify_result_and_push_bill_modifier()
if inspector is not None:
services.get_zone_situation_manager().make_sim_leave_now_must_run(inspector)
self.owner._self_destruct()
def _update_speed(self, immediate=False):
for speed_request in self.game_speed_requests_gen():
if not speed_request.validity_check is None:
if speed_request.validity_check():
new_speed = speed_request.speed
break
new_speed = speed_request.speed
break
else:
logger.error(
'No valid game speeds in the game speed controllers: {}',
self.speed_controllers,
owner='bhill')
new_speed = ClockSpeedMode.PAUSED
old_speed = self._clock_speed
if old_speed == new_speed:
return
self._update_time_spent_in_speed(old_speed)
self._clock_speed = new_speed
if new_speed == ClockSpeedMode.NORMAL and self.clock_speed_multiplier_type != ClockSpeedMultiplierType.DEFAULT:
self._set_clock_speed_multiplier_type(
ClockSpeedMultiplierType.DEFAULT, do_sync=False)
if new_speed == ClockSpeedMode.SUPER_SPEED3:
services.get_zone_situation_manager().ss3_make_all_npcs_leave_now()
self._sync_clock_and_broadcast_gameclock(immediate=immediate)
if new_speed == ClockSpeedMode.PAUSED:
gc2_triggered = pythonutils.try_highwater_gc()
if gc2_triggered:
logger.debug('Pausing the game has triggered highwater GC2.',
owner='manus')
def _create_next_situation(self):
worker_sim = next(self.all_sims_in_job_gen(self.default_job()), None)
if worker_sim is not None:
if worker_sim.is_on_active_lot() and self._visit_duration != False:
services.get_zone_situation_manager().create_visit_situation(
worker_sim, duration_override=self._visit_duration)
return
services.get_zone_situation_manager().make_sim_leave(worker_sim)
def _start_background_event(self, scheduler, alarm_data, extra_data=None):
entry = alarm_data.entry
situation = entry.situation
situation_manager = services.get_zone_situation_manager()
if self._active_background_event_id is not None and self._active_background_event_id in situation_manager:
situation_manager.destroy_situation_by_id(self._active_background_event_id)
situation_id = services.get_zone_situation_manager().create_situation(situation, user_facing=False, spawn_sims_during_zone_spin_up=True)
self._active_background_event_id = situation_id
def callback(sim_infos, callback_event_data):
if sim_infos:
for sim_info in sim_infos:
services.get_zone_situation_manager().add_debug_sim_id(sim_info.id)
sims.sim_spawner.SimSpawner.spawn_sim(sim_info, None)
sims4.commands.output('Spawned {} with id {}'.format(sim_info, sim_info.id), _connection)
else:
sims4.commands.output('No filter with {}'.format(callback_event_data), _connection)
def _on_remove_sim_from_situation(self, sim):
sim_job = self.get_current_job_for_sim(sim)
super()._on_remove_sim_from_situation(sim)
self._remove_purchase_intent()
self._customer = None
services.get_zone_situation_manager().add_sim_to_auto_fill_blacklist(
sim.id, sim_job)
self._self_destruct()
def _end_holiday(self):
active_household = services.active_household()
if not active_household.holiday_tracker.is_holiday_cancelled(
self.holiday_id):
self._unregister_situation_ended_callbacks()
for situation_id in self._situation_ids:
services.get_zone_situation_manager().destroy_situation_by_id(
situation_id)
active_household.holiday_tracker.deactivate_holiday()
def end_vacation(self):
active_household = services.active_household()
current_zone_id = services.current_zone_id()
current_region_id = get_region_description_id_from_zone_id(
current_zone_id)
rental_region_id = get_region_description_id_from_zone_id(
self._zone_id)
if current_region_id != rental_region_id or not active_household.any_member_belong_to_travel_group_id(
self.id):
at_home = current_zone_id == active_household.home_zone_id
for sim_info in self:
if active_household.id == sim_info.household_id and at_home:
if not sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
SimSpawner.spawn_sim(sim_info)
if sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
services.get_zone_situation_manager(
).make_sim_leave_now_must_run(
sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS))
else:
sim_info.inject_into_inactive_zone(
sim_info.household.home_zone_id)
elif sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
services.get_zone_situation_manager(
).make_sim_leave_now_must_run(
sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS))
else:
sim_info.inject_into_inactive_zone(
sim_info.household.home_zone_id)
services.travel_group_manager(
).destroy_travel_group_and_release_zone(self, return_objects=True)
return
for instanced_sim in active_household.instanced_sims_gen():
instanced_sim.queue.cancel_all()
travel_info = InteractionOps_pb2.TravelSimsToZone()
travel_info.zone_id = active_household.home_zone_id
active_sims_on_zone = [
active_sim_info for active_sim_info in active_household
if active_sim_info.zone_id == current_zone_id
]
for sim_info in itertools.chain(self, active_sims_on_zone):
if active_household.id == sim_info.household_id:
if sim_info.sim_id not in travel_info.sim_ids:
travel_info.sim_ids.append(sim_info.sim_id)
else:
sim_info.inject_into_inactive_zone(
sim_info.household.home_zone_id)
distributor.system.Distributor.instance().add_event(
Consts_pb2.MSG_TRAVEL_SIMS_TO_ZONE, travel_info)
services.game_clock_service().set_clock_speed(ClockSpeedMode.PAUSED)
services.travel_group_manager().destroy_travel_group_and_release_zone(
self)
def on_activate(self, reader):
super().on_activate(reader)
if reader is None:
service_sim = self.owner.service_sim()
self.owner._on_leaving_situation(self._leave_role_reason)
if service_sim is None:
logger.warn('Service sim is None for {}.', self)
return
services.get_zone_situation_manager().make_sim_leave_now_must_run(
service_sim)
def on_activate(self, reader):
super().on_activate(reader)
if self.owner.neighor_saved_me_buff:
if self.owner._fire_brigade_put_out_fire:
for sim_info in services.active_household().instanced_sims_gen():
sim_info.add_buff_from_op(self.owner.neighor_saved_me_buff.buff_type, self.owner.neighor_saved_me_buff.buff_reason)
if self.owner.visit_afterwards:
for fire_brigade_volunteer in self.owner.get_fire_brigade_sim_infos():
services.get_zone_situation_manager().create_visit_situation(fire_brigade_volunteer)
self.owner._self_destruct()
def _start_background_event(self, scheduler, alarm_data, extra_data=None):
entry = alarm_data.entry
situation = entry.situation
situation_manager = services.get_zone_situation_manager()
if self._active_background_event_id is not None and self._active_background_event_id in situation_manager:
situation_manager.destroy_situation_by_id(
self._active_background_event_id)
situation_id = services.get_zone_situation_manager().create_situation(
situation, user_facing=False, spawn_sims_during_zone_spin_up=True)
self._active_background_event_id = situation_id
def __call__(self, interaction, picked_sim_ids):
guest_list = SituationGuestList(invite_only=True)
adoption_service = services.get_adoption_service()
for sim_id in picked_sim_ids:
replacement_sim_info = adoption_service.convert_base_sim_info_to_full(sim_id)
if replacement_sim_info is None:
sim_id_to_adopt = sim_id
else:
sim_id_to_adopt = replacement_sim_info.sim_id
guest_list.add_guest_info(SituationGuestInfo(sim_id_to_adopt, self.adoptee_situation_job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP, reservation=True))
services.get_zone_situation_manager().create_situation(self.situation_type, guest_list=guest_list, user_facing=False)
def on_update(self):
super().on_update()
self._countdown -= 1
if self._countdown <= 0:
services.active_lot().on_hit_their_marks()
services.sim_spawner_service().on_hit_their_marks()
services.get_zone_situation_manager(
).on_hit_their_marks_during_zone_spin_up()
services.current_zone().on_hit_their_marks()
return _ZoneSpinUpStateResult.DONE
services.game_clock_service().advance_for_hitting_their_marks()
return _ZoneSpinUpStateResult.WAITING
def callback(sim_infos, callback_event_data):
if sim_infos:
for sim_info in sim_infos:
services.get_zone_situation_manager().add_debug_sim_id(
sim_info.id)
sims.sim_spawner.SimSpawner.spawn_sim(sim_info, None)
sims4.commands.output(
'Spawned {} with id {}'.format(sim_info, sim_info.id),
_connection)
else:
sims4.commands.output(
'No filter with {}'.format(callback_event_data), _connection)
def on_activate(self, reader=None):
super().on_activate(reader=reader)
inspector = self.owner.inspector_person()
if inspector is not None:
services.get_zone_situation_manager().make_sim_leave_now_must_run(inspector)
service_npc_type = self.owner._service_npc_type
now = services.time_service().sim_now
household = self.owner._hiring_household
service_record = household.get_service_npc_record(service_npc_type.guid64)
service_record.time_last_finished_service = now
self._service_npc = None
self.owner._self_destruct()
def _create_situation(sim_infos):
guest_list = SituationGuestList(invite_only=True,
host_sim_id=host_sim_id)
for sim_info in sim_infos:
guest_info = situation_guest_list.SituationGuestInfo.construct_from_purpose(
sim_info.sim_id, situation_job,
situation_guest_list.SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
services.get_zone_situation_manager().create_situation(
self.situation_to_create,
guest_list=guest_list,
user_facing=False)
def on_sim_added(self, sim_info):
if self._state != HolidayState.RUNNING:
return
holiday_goals = list(
tradition.situation_goal
for tradition in services.holiday_service().get_holiday_traditions(
self.holiday_id))
situation_id = self._create_holiday_situation(sim_info, holiday_goals)
if situation_id:
services.get_zone_situation_manager().register_for_callback(
situation_id, SituationCallbackOption.END_OF_SITUATION,
self._on_holiday_situation_ended)
def create_sims(cls, sim_creators, household=None, tgt_client=None, generate_deterministic_sim=False, sim_position:sims4.math.Vector3=None, sim_spawner_tags=None, account=None, is_debug=False, skip_offset=False, additional_fgl_search_flags=None, creation_source:str='Unknown'):
(sim_info_list, _) = cls.create_sim_infos(sim_creators, household=household, starting_funds=DEFAULT, tgt_client=tgt_client, account=account, generate_deterministic_sim=generate_deterministic_sim)
offset = 0.0
for sim_info in sim_info_list:
if sim_position is not None:
sim_position = sims4.math.Vector3(*sim_position)
if not skip_offset:
offset = 2.0
sim_position.y = terrain.get_terrain_height(sim_position.x, sim_position.z)
if is_debug:
services.get_zone_situation_manager().add_debug_sim_id(sim_info.id)
cls.spawn_sim(sim_info, sim_position, sim_spawner_tags=sim_spawner_tags, additional_fgl_search_flags=additional_fgl_search_flags, is_debug=is_debug)
while sim_info.account is not None and tgt_client is not None:
tgt_client.add_selectable_sim_info(sim_info)
def _create_NPC_hosted_situation(dialog):
if not dialog.accepted:
with telemetry_helper.begin_hook(writer, TELEMETRY_HOOK_SITUATION_REJECTED, sim=player_sim) as hook:
hook.write_guid('type', chosen_situation.guid64)
return
guest_list = SituationGuestList(host_sim_id=NPC_sim_id)
if chosen_situation.NPC_hosted_situation_use_player_sim_as_filter_requester:
guest_list.filter_requesting_sim_id = player_sim.id
guest_list.add_guest_info(SituationGuestInfo.construct_from_purpose(player_sim.id, chosen_situation.NPC_hosted_situation_player_job, SituationInvitationPurpose.INVITED))
chosen_zone_id = chosen_situation.get_venue_location()
services.get_zone_situation_manager().create_situation(chosen_situation, guest_list=guest_list, zone_id=chosen_zone_id)
self.add_cooldown(self._cooldown)
with telemetry_helper.begin_hook(writer, TELEMETRY_HOOK_SITUATION_ACCEPTED, sim=player_sim) as hook:
hook.write_guid('type', chosen_situation.guid64)
def _send_service_npc(self, scheduler, alarm_data, situation_creation_params):
household = situation_creation_params.hiring_household
service_npc_type = situation_creation_params.service_npc_type
if not self._auto_scheduled_services_enabled and service_npc_type.auto_schedule_on_client_connect():
return
service_record = household.get_service_npc_record(service_npc_type.guid64)
preferred_sim_id = service_record.get_preferred_sim_id()
situation_type = service_npc_type.situation
user_specified_data_id = situation_creation_params.user_specified_data_id
now = services.time_service().sim_now
if service_record.time_last_started_service is not None and alarm_data.start_time is not None:
alarm_start_time_absolute = date_and_time_from_week_time(now.week(), alarm_data.start_time)
if service_record.time_last_started_service >= alarm_start_time_absolute:
return
service_record.time_last_started_service = now
service_record.time_last_finished_service = None
duration = alarm_data.end_time - now.time_since_beginning_of_week()
min_duration = service_npc_type.min_duration_left_for_arrival_on_lot()
if duration < min_duration:
service_npc_type.fake_perform(household)
return
min_duration = service_npc_type.min_work_duration()
max_duration = service_npc_type.max_work_duration()
duration = clamp(min_duration, duration.in_minutes(), max_duration)
guest_list = SituationGuestList(True)
if preferred_sim_id is not None:
guest_list.add_guest_info(SituationGuestInfo.construct_from_purpose(preferred_sim_id, situation_type.default_job(), SituationInvitationPurpose.PREFERRED))
situation_creation_params_writer = PropertyStreamWriter()
situation_creation_params_writer.write_uint64('household_id', household.id)
situation_creation_params_writer.write_uint64('service_npc_type_id', service_npc_type.guid64)
if user_specified_data_id is not None:
situation_creation_params_writer.write_uint64('user_specified_data_id', user_specified_data_id)
situation_creation_params_writer.write_bool('is_recurring', situation_creation_params.is_recurring)
self._situation_id = services.get_zone_situation_manager().create_situation(situation_type, guest_list, user_facing=False, duration_override=duration, custom_init_writer=situation_creation_params_writer)
def _advance_situations_to_postfire(self):
situation_manager = services.get_zone_situation_manager()
if situation_manager is not None and self._situation_ids is not None:
for situation_id in self._situation_ids.values():
situation = situation_manager.get(situation_id)
while situation is not None:
situation.advance_to_post_fire()
def destroy_situation(situation_id, _connection=None):
sit_man = services.get_zone_situation_manager()
if situation_id is None:
sims4.commands.output('No situation id specified. Valid options are: ', _connection)
_list_situations(sit_man, _connection=_connection)
return
sit_man.destroy_situation_by_id(situation_id)
def make_greeted(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('Invalid sim: {} provided.'.format(opt_sim), _connection)
return
situation_manager = services.get_zone_situation_manager()
situation_manager.make_waiting_player_greeted(sim)
def start_situation(interaction, situation, user_facing):
situation_manager = services.get_zone_situation_manager()
guest_list = situation.get_predefined_guest_list()
if guest_list is None:
sim = interaction.sim
guest_list = SituationGuestList(invite_only=True, host_sim_id=sim.id)
if situation.targeted_situation is not None:
target_sim = interaction.get_participant(ParticipantType.PickedSim)
if target_sim is None:
target_sim = interaction.get_participant(ParticipantType.TargetSim)
target_sim_id = target_sim.id if target_sim is not None else None
job_assignments = situation.get_prepopulated_job_for_sims(sim, target_sim_id)
for (sim_id, job_type_id) in job_assignments:
job_type = services.situation_job_manager().get(job_type_id)
guest_info = SituationGuestInfo.construct_from_purpose(sim_id, job_type, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
else:
default_job = situation.default_job()
target_sims = interaction.get_participants(ParticipantType.PickedSim)
if target_sims:
for sim_or_sim_info in target_sims:
guest_info = SituationGuestInfo.construct_from_purpose(sim_or_sim_info.sim_id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
else:
target_sim = interaction.get_participant(ParticipantType.TargetSim)
if target_sim is not None:
guest_info = SituationGuestInfo.construct_from_purpose(target_sim.sim_id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
guest_info = SituationGuestInfo.construct_from_purpose(sim.sim_id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
zone_id = interaction.get_participant(ParticipantType.PickedZoneId) or 0
situation_manager.create_situation(situation, guest_list=guest_list, user_facing=user_facing, zone_id=zone_id)
def _push_open_street_sims_home(self):
sim_info_manager = services.sim_info_manager()
situation_manager = services.get_zone_situation_manager()
for instanced_sim in sim_info_manager.instanced_sims_gen():
while instanced_sim.id not in self._sims_told_to_leave and instanced_sim.is_npc and not instanced_sim.is_on_active_lot():
situation_manager.make_sim_leave_now_must_run(instanced_sim, super_speed_three_request=True)
self._sims_told_to_leave.add(instanced_sim.id)
def _try_start_special_event(self, scheduler, alarm_data, extra_data):
entry = alarm_data.entry
situation = entry.situation
situation_manager = services.get_zone_situation_manager()
if self._active_special_event_id is None:
client_manager = services.client_manager()
client = next(iter(client_manager.values()))
invited_sim = client.active_sim
active_sim_available = situation.is_situation_available(invited_sim)
def _start_special_event(dialog):
guest_list = None
if dialog.accepted:
start_user_facing = True
guest_list = SituationGuestList()
guest_info = SituationGuestInfo.construct_from_purpose(invited_sim.id, situation.venue_situation_player_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
else:
start_user_facing = False
situation_id = situation_manager.create_situation(situation, guest_list=guest_list, user_facing=start_user_facing)
self._active_special_event_id = situation_id
if not situation_manager.is_user_facing_situation_running() and active_sim_available:
dialog = situation.venue_invitation_message(invited_sim, SingleSimResolver(invited_sim))
dialog.show_dialog(on_response=_start_special_event, additional_tokens=(situation.display_name, situation.venue_situation_player_job.display_name))
else:
situation_id = situation_manager.create_situation(situation, user_facing=False)
self._active_special_event_id = situation_id
def trigger_walkby(_connection=None, command_type=sims4.commands.CommandType.DebugOnly):
situation_id = services.current_zone().ambient_service.debug_update()
if situation_id is not None:
situation = services.get_zone_situation_manager().get(situation_id)
sims4.commands.output('Created ambient situation: {}.{}'.format(situation, situation_id), _connection)
else:
sims4.commands.output('Did not create ambient situation. There are no types of walkbys that are available at this time.', _connection)
return True
def _get_blacklist(self):
if self._blacklist_sim_ids:
blacklist = set(self._blacklist_sim_ids)
else:
blacklist = set()
if self._request_priority == BouncerRequestPriority.AUTO_FILL or self._request_priority == BouncerRequestPriority.AUTO_FILL_PLUS:
blacklist = blacklist | services.get_zone_situation_manager().get_auto_fill_blacklist()
return blacklist
def force_neighbors_home(_connection=None):
client = services.client_manager().get_first_client()
active_household = client.household
if active_household is not None:
active_household_home_zone_id = active_household.home_zone_id
active_household_home_world_id = services.get_persistence_service().get_world_id_from_zone(active_household_home_zone_id)
send_home = active_household_home_zone_id == services.current_zone().id
blacklist_until = services.time_service().sim_now + date_and_time.create_time_span(days=7)
for sim_info in services.sim_info_manager().values():
if sim_info.is_selectable:
pass
sim_info_home_zone_id = sim_info.household.home_zone_id
sim_info_home_world_id = services.get_persistence_service().get_world_id_from_zone(sim_info_home_zone_id)
while sim_info_home_world_id == active_household_home_world_id:
services.get_zone_situation_manager().add_sim_to_auto_fill_blacklist(sim_info.id, blacklist_until=blacklist_until)
if send_home and sim_info.zone_id != active_household_home_zone_id and sim_info.zone_id != sim_info_home_zone_id:
sim_info.inject_into_inactive_zone(sim_info_home_zone_id)
def show_blacklist(_connection=None):
situation_manager = services.get_zone_situation_manager()
blacklist = situation_manager.get_auto_fill_blacklist()
for sim_id in blacklist:
sim = services.sim_info_manager().get(sim_id)
while sim is not None:
span = situation_manager.get_remaining_blacklist_time_span(sim.id)
sims4.commands.output('{} : {} remaining'.format(sim, span), _connection)
def __call__(self, sim_infos, host_sim_info=None):
venue_type = services.get_current_venue()
if venue_type is None or venue_type.active_background_event_id is None:
return
situation = services.get_zone_situation_manager().get(venue_type.active_background_event_id)
if situation is not None:
for sim_info in sim_infos:
situation.invite_sim_to_default_job(sim_info)
def on_enter(self):
super().on_enter()
situation_manager = services.get_zone_situation_manager()
situation_manager.create_situations_during_zone_spin_up()
services.current_zone(
).venue_service.initialize_venue_background_schedule()
situation_manager.on_all_situations_created_during_zone_spin_up()
return _ZoneSpinUpStateResult.DONE
def automation_list_active_situations(situation_id:int=None, _connection=None):
sit_man = services.get_zone_situation_manager()
sit = sit_man.get(situation_id)
if sit is None:
sims4.commands.automation_output('SituationInfo; Exists:No', _connection)
return
sims4.commands.output('SituationInfo; Exists:Yes, Id:{}, ClassName:{}, NumSims:{}, Level:{}, Score:{}, State:{} '.format(sit.id, sit.__class__.__name__, len(sit._situation_sims), int(sit.get_level()), sit.score, sit.get_phase_state_name_for_gsi()), _connection)
sims4.commands.automation_output('SituationInfo; Exists:Yes, Id:{}, ClassName:{}, NumSims:{}, Level:{}, Score:{}, State:{}'.format(sit.id, sit.__class__.__name__, len(sit._situation_sims), int(sit.get_level()), sit.score, sit.get_phase_state_name_for_gsi()), _connection)
def automation_advance_situation_phase(situation_id:int=None, _connection=None):
situation_manager = services.get_zone_situation_manager()
situation = situation_manager.get(situation_id)
if situation is None:
sims4.commands.automation_output('AdvancePhase; Success:False', _connection)
return
situation._transition_to_next_phase()
sims4.commands.automation_output('AdvancePhase; Success:True', _connection)
return True
def create_situation(situation_type, opt_sim:OptionalTargetParam=None, user_facing:bool=True, zone_id:int=0, _connection=None):
situation_manager = services.get_zone_situation_manager()
sim = get_optional_target(opt_sim, _connection)
guest_list = SituationGuestList(False, sim.id)
situation_id = situation_manager.create_situation(situation_type, guest_list=guest_list, user_facing=user_facing, zone_id=zone_id)
if situation_id is not None:
sims4.commands.output('Successfully created situation: {}.'.format(situation_id), _connection)
else:
sims4.commands.output('Insufficient funds to create situation', _connection)
def situation_save_load_seed_test(_connection=None):
seeds = []
situation_manager = services.get_zone_situation_manager()
for situation in situation_manager.running_situations():
seed = situation.save_situation()
while seed is not None:
seeds.append(seed)
situation_manager.reset(create_system_situations=False)
for seed in seeds:
situation_manager.create_situation_from_seed(seed)
def _start_work_callback(self, scheduler, alarm_data, extra_data):
logger.debug('My Work Time just triggered!!, Current Time:{}', services.time_service().sim_now)
is_npc = self._sim_info.is_npc
if self.should_skip_next_shift(check_if_can_go_now=True):
self._called_in_sick = False
self.resend_career_data()
return
if is_npc:
sim = self._get_sim()
services.get_zone_situation_manager().make_sim_leave_now_must_run(sim)
else:
now = services.time_service().sim_now
work_duration = alarm_data.start_time.time_to_week_time(alarm_data.end_time)
self.start_new_career_session(now, now + work_duration)
sim = self._get_sim()
if sim is not None:
self.push_go_to_work_affordance()
else:
self.attend_work()
def automation_get_num_sims_in_role_state(situation_id, role_state_type, _connection=None):
situation_manager = services.get_zone_situation_manager()
situation = situation_manager.get(situation_id)
if situation is None:
sims4.commands.automation_output('NumInRoleState; Number:0', _connection)
return
if role_state_type is None:
sims4.commands.automation_output('NumInRoleState; Number:0', _connection)
count = situation.get_num_sims_in_role_state(role_state_type)
sims4.commands.automation_output('NumInRoleState; Number:{}'.format(count), _connection)
def generate_situation_bouncer_data(zone_id:int=None):
all_requests = []
situation_manager = services.get_zone_situation_manager(zone_id=zone_id)
if situation_manager is None:
return all_requests
bouncer = situation_manager.bouncer
global_data = []
global_data.append({'npcs_here': bouncer._number_of_npcs_on_lot, 'npcs_leaving': bouncer._number_of_npcs_leaving, 'npc_soft_cap': situation_manager.npc_soft_cap})
for request in bouncer._all_requests_gen():
all_requests.append({'situation': str(request._situation), 'situation_id': str(request._situation.id), 'job': request._job_type.__name__, 'filter': request._sim_filter.__name__ if request._sim_filter is not None else 'None', 'status': request._status.name, 'klout': request._get_request_klout() if request._get_request_klout() is not None else 10000, 'priority': request._request_priority.name, 'sim_name': request.assigned_sim.full_name if request.assigned_sim is not None else 'None', 'spawning_option': request.spawning_option.name, 'unique': str(id(request)), 'Global': global_data})
return all_requests
def generate_situation_data(zone_id:int=None):
all_situations = []
sit_man = services.get_zone_situation_manager(zone_id=zone_id)
if sit_man is None:
return all_situations
global_data = []
for sim_info in tuple(services.sim_info_manager().values()):
sim = sim_info.get_sim_instance()
if sim is not None:
if not sim.sim_info.is_npc:
pass
on_lot_time = sit_man.get_time_span_sim_has_been_on_lot(sim)
if on_lot_time is not None:
on_lot_str = str(on_lot_time)
else:
on_lot_str = 'ERROR'
blacklist_time = sit_man.get_remaining_blacklist_time_span(sim.id)
if blacklist_time is not date_and_time.TimeSpan.ZERO:
blacklist_str = str(blacklist_time)
else:
blacklist_str = ''
else:
on_lot_str = ''
blacklist_time = sit_man.get_remaining_blacklist_time_span(sim_info.id)
while blacklist_time is not date_and_time.TimeSpan.ZERO:
blacklist_str = str(blacklist_time)
global_data.append({'npc': sim_info.full_name, 'npc_time_on_lot': on_lot_str, 'npc_blacklist_time': blacklist_str})
global_data.append({'npc': sim_info.full_name, 'npc_time_on_lot': on_lot_str, 'npc_blacklist_time': blacklist_str})
situations = list(sit_man._objects.values())
for sit in situations:
sim_data = []
for (sim, situation_sim) in tuple(sit._situation_sims.items()):
while sim:
sim_data.append({'sim_name': sim.full_name, 'sim_job': situation_sim.current_job_type.__name__ if situation_sim.current_job_type is not None else 'None', 'sim_role': situation_sim.current_role_state_type.__name__ if situation_sim.current_role_state_type is not None else 'None', 'sim_emotion': situation_sim.emotional_buff_name, 'sim_on_active_lot': sim.is_on_active_lot()})
goal_data = []
goals = sit.get_situation_goal_info()
if goals is not None:
for (goal, tuned_goal_set) in goals:
goal_data.append({'goal': goal.get_gsi_name(), 'goal_set': tuned_goal_set.__name__ if tuned_goal_set is not None else 'None', 'time_created': str(goal.created_time), 'time_completed': str(goal.completed_time), 'score': goal.score})
completed_goals = sit.get_situation_completed_goal_info()
if completed_goals is not None:
while True:
for (goal, tuned_goal_set) in completed_goals:
goal_data.append({'goal': goal.get_gsi_name(), 'goal_set': tuned_goal_set.__name__ if tuned_goal_set is not None else 'None', 'time_created': str(goal.created_time), 'time_completed': str(goal.completed_time), 'score': goal.score})
churn_data = []
for job_data in sit.gsi_all_jobs_data_gen():
while job_data.gsi_has_churn():
churn_data.append({'sim_job': job_data.gsi_get_job_name(), 'min': job_data.gsi_get_churn_min(), 'max': job_data.gsi_get_churn_max(), 'here': job_data.gsi_get_num_churn_sims_here(), 'coming': job_data.gsi_get_num_churn_sims_coming(), 'time_left': str(job_data.gsi_get_remaining_time_until_churn())})
shift_data = []
for job_data in sit.gsi_all_jobs_data_gen():
while job_data.gsi_has_shifts():
shift_data.append({'sim_job': job_data.gsi_get_job_name(), 'num': job_data.gsi_get_shifts_staffing(), 'here': job_data.gsi_get_num_churn_sims_here(), 'coming': job_data.gsi_get_num_churn_sims_coming(), 'change_time_left': str(job_data.gsi_get_remaining_time_until_shift_change()), 'churn_time_left': str(job_data.gsi_get_remaining_time_until_churn())})
all_situations.append({'situation_id': str(sit.id), 'situation': str(sit), 'time_left': str(sit._get_remaining_time()) if sit._get_remaining_time() is not None else 'Forever', 'state': sit.get_phase_state_name_for_gsi(), 'sim_count': len(sit._situation_sims), 'score': sit.score, 'level': str(sit.get_level()), 'Sims': sim_data, 'Goals': goal_data, 'Churn': churn_data, 'Shifts': shift_data, 'Global': global_data})
return all_situations
def start_career_situation(self):
if self._career_situation is not None:
guest_info = SituationGuestInfo.construct_from_purpose(self._sim_info.sim_id, self._career_situation.job, SituationInvitationPurpose.CAREER)
guest_list = SituationGuestList()
guest_list.add_guest_info(guest_info)
situation_manager = services.get_zone_situation_manager()
situation = self._career_situation.situation
if not situation.has_venue_location():
logger.error("Tried starting a career event, career:{} level:{}, and couldn't find a valid venue. There should ALWAYS be a Maxis Lot tuned for every venue type. - trevorlindsey", self, self.level)
return False
zone_id = situation.get_venue_location()
self._career_situation_id = situation_manager.create_situation(self._career_situation.situation, guest_list=guest_list, zone_id=zone_id)
def automation_complete_goal(situation_id, goal_name, _connection=None):
situation_manager = services.get_zone_situation_manager()
situation = situation_manager.get(situation_id)
if situation is None:
sims4.commands.automation_output('CompleteGoal; Success:False', _connection)
return False
result = situation.debug_force_complete_named_goal(goal_name, None)
if result:
sims4.commands.automation_output('CompleteGoal; Success:True', _connection)
else:
sims4.commands.automation_output('CompleteGoal; Success:False', _connection)
return result
