def _do_behavior(self):
if self.rabbit_hole is None:
return
sim_or_sim_info = self.interaction.get_participant(
self.rabbit_holed_participant)
picked_skill = self.interaction.get_participant(
ParticipantType.PickedStatistic)
services.get_rabbit_hole_service().put_sim_in_managed_rabbithole(
sim_or_sim_info.sim_info,
self.rabbit_hole,
picked_skill=picked_skill)
def _get_selector_visual_type(self, sim_info):
if sim_info.is_baby:
return (Sims_pb2.SimPB.BABY, None)
if sim_info.is_toddler and services.daycare_service(
).is_sim_info_at_daycare(sim_info):
return (Sims_pb2.SimPB.AT_DAYCARE, None)
if sim_info.household.missing_pet_tracker.is_pet_missing(sim_info):
return (Sims_pb2.SimPB.PET_MISSING, None)
sim = sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS)
for career in sim_info.careers.values():
if career.currently_at_work:
if career.is_at_active_event and sim is None:
return (Sims_pb2.SimPB.MISSING_ACTIVE_WORK,
career.career_category)
return (Sims_pb2.SimPB.AT_WORK, career.career_category)
if career.is_late:
if not career.taking_day_off:
return (Sims_pb2.SimPB.LATE_FOR_WORK,
career.career_category)
if services.get_rabbit_hole_service(
).should_override_selector_visual_type(sim_info.id):
return (Sims_pb2.SimPB.OTHER, None)
if sim is not None and sim.has_hidden_flags(
HiddenReasonFlag.RABBIT_HOLE):
return (Sims_pb2.SimPB.OTHER, None)
if services.hidden_sim_service().is_hidden(sim_info.id):
return (Sims_pb2.SimPB.OTHER, None)
tutorial_service = services.get_tutorial_service()
if tutorial_service is not None and tutorial_service.is_sim_unselectable(
sim_info):
return (Sims_pb2.SimPB.OTHER, None)
return (Sims_pb2.SimPB.NORMAL, None)
def _spawn_requested_sim(self, request):
for other_request in tuple(self._submitted_requests):
if request._is_request_for_same_sim(other_request):
self._submitted_requests.remove(other_request)
self._spawning_requests.append(other_request)
for other_request in tuple(self._listening_requests):
if request._is_request_for_same_sim(other_request):
self._listening_requests.remove(other_request)
self._spawning_requests.append(other_request)
place_strategy = request._place_strategy
success = sims.sim_spawner.SimSpawner.spawn_sim(request._sim_info, sim_position=place_strategy.position, sim_location=place_strategy.location, sim_spawner_tags=place_strategy.spawner_tags, spawn_point_option=place_strategy.spawn_point_option, saved_spawner_tags=place_strategy.saved_spawner_tags, spawn_action=place_strategy.spawn_action, from_load=request._from_load, spawn_point=place_strategy.spawn_point, spawn_at_lot=place_strategy.spawn_at_lot)
if success:
sim_info = request._sim_info
if services.get_rabbit_hole_service().will_override_spin_up_action(sim_info.id):
services.sim_info_manager().schedule_sim_spin_up_action(sim_info, SimZoneSpinUpAction.NONE)
else:
services.sim_info_manager().schedule_sim_spin_up_action(sim_info, request._spin_up_action)
self._next_spawn_time = services.time_service().sim_now + self._spawn_cooldown
message = 'Spawn Start'
else:
if request in self._spawning_requests:
self._spawning_requests.remove(request)
message = 'Spawn Failed'
if gsi_handlers.sim_spawner_service_log.sim_spawner_service_log_archiver.enabled:
request.log_to_gsi(message)
logger.debug('{}: {}', message, request)
def picker_rows_gen(cls, inst, target, context, **kwargs):
inst_or_cls = inst if inst is not None else cls
actor = inst_or_cls.get_participant(
sim=context.sim,
target=target,
participant_type=ParticipantType.Actor,
**kwargs)
familiar_tracker = actor.sim_info.familiar_tracker
if familiar_tracker is not None:
rabbit_hole_service = services.get_rabbit_hole_service()
current_region = services.current_region()
sim_info_manager = services.sim_info_manager()
for familiar_info in familiar_tracker:
is_enable = True
row_tooltip = None
if rabbit_hole_service.is_in_rabbit_hole(
familiar_info.pet_familiar_id):
is_enable = False
row_tooltip = inst_or_cls.rabbit_holed_disabled_tooltip
else:
pet_familiar = sim_info_manager.get(
familiar_info.pet_familiar_id)
sim_region = region.get_region_instance_from_zone_id(
pet_familiar.zone_id)
is_enable = False
row_tooltip = inst_or_cls.incompatible_region_disabled_tooltip
row = BasePickerRow(name=familiar_info.name,
icon_info=familiar_info.icon_info,
tag=familiar_info.uid,
is_enable=is_enable,
row_tooltip=row_tooltip)
yield row
def _run_interaction_gen(self, timeline):
sim_id = self._sim_info.id
rabbit_hole_service = services.get_rabbit_hole_service()
rabbit_hole_id = rabbit_hole_service.get_head_rabbit_hole_id(sim_id)
if rabbit_hole_id:
rabbit_hole_service.remove_sim_from_rabbit_hole(
sim_id, rabbit_hole_id=rabbit_hole_id, canceled=True)
return True
yield
def _run(self):
rabbit_hole_service = services.get_rabbit_hole_service()
self._rabbit_hole_id = rabbit_hole_service.put_sim_in_managed_rabbithole(
self._receiver_sim_info, self.audition_rabbit_hole)
if self._rabbit_hole_id is None:
self._on_sim_return(canceled=True)
rabbit_hole_service.set_rabbit_hole_expiration_callback(
self._receiver_sim_info.id, self._rabbit_hole_id,
self._on_sim_return)
return DramaNodeRunOutcome.SUCCESS_NODE_INCOMPLETE
def get_icon_info(cls, inst, **kwargs):
if inst is not None:
icon_info = services.get_rabbit_hole_service(
).get_head_rabbit_hole_home_interaction_icon(
inst.sim.id, **kwargs)
if icon_info is not None:
return icon_info
logger.error(
'Failed to get rabbit hole travel icon for rabbit hole: {}', cls)
return super().get_icon_info(cls, inst, **kwargs)
def _load_custom_data(self, reader):
self._calculated_audition_time = DateAndTime(
reader.read_uint64(AUDITION_TIME_TOKEN, None))
self._calculated_gig_time = DateAndTime(
reader.read_uint64(GIG_TIME_TOKEN, None))
self._rabbit_hole_id = reader.read_uint64(RABBIT_HOLE_ID_TOKEN, None)
rabbit_hole_service = services.get_rabbit_hole_service()
if not self._rabbit_hole_id:
rabbit_hole_service = services.get_rabbit_hole_service()
self._rabbit_hole_id = services.get_rabbit_hole_service(
).get_rabbit_hole_id_by_type(self._receiver_sim_info.id,
self.audition_rabbit_hole)
if self._rabbit_hole_id and rabbit_hole_service.is_in_rabbit_hole(
self._receiver_sim_info.id,
rabbit_hole_id=self._rabbit_hole_id):
rabbit_hole_service.set_rabbit_hole_expiration_callback(
self._receiver_sim_info.id, self._rabbit_hole_id,
self._on_sim_return)
self._send_career_ui_update()
return True
def cleanup(self, from_service_stop=False):
services.calendar_service().remove_on_calendar(self.uid)
self._send_career_ui_update(is_add=False)
rabbit_hole_service = services.get_rabbit_hole_service()
if self._rabbit_hole_id and rabbit_hole_service.is_in_rabbit_hole(
self._receiver_sim_info.id,
rabbit_hole_id=self._rabbit_hole_id):
rabbit_hole_service.remove_rabbit_hole_expiration_callback(
self._receiver_sim_info.id, self._rabbit_hole_id,
self._on_sim_return)
super().cleanup(from_service_stop=from_service_stop)
def _test(cls, *args, sim_info=None, **kwargs):
if sim_info is None:
return TestResult(False, 'No sim info')
sim_id = sim_info.id
rabbit_hole_service = services.get_rabbit_hole_service()
if not rabbit_hole_service.is_in_rabbit_hole(sim_id):
return TestResult(False, 'Not currently in a rabbit hole')
if not rabbit_hole_service.is_head_rabbit_hole_user_cancelable(sim_id):
return TestResult(
False, 'Rabbit hole interaction is not user cancelable')
return super()._test(*args, **kwargs)
def get_name(cls, inst, **interaction_parameters):
if inst is not None:
name = services.get_rabbit_hole_service(
).get_head_rabbit_hole_home_interaction_name(
inst.sim.id, **interaction_parameters)
if name is not None:
return name
logger.error(
'Failed to get rabbit hole travel display name for rabbit hole: {}',
cls)
return super()._get_name(cls, inst, **interaction_parameters)
def __call__(self, subject=None):
rabbit_hole_service = services.get_rabbit_hole_service()
for sim in subject:
if rabbit_hole_service.is_in_rabbit_hole(sim.sim_id):
if self.negate:
return TestResult(False,
'{} is in a rabbit hole.',
sim,
tooltip=self.tooltip)
if not self.negate:
return TestResult(False,
'{} is in a rabbit hole.',
sim,
tooltip=self.tooltip)
elif not self.negate:
return TestResult(False,
'{} is in a rabbit hole.',
sim,
tooltip=self.tooltip)
return TestResult.TRUE
def generate_rabbit_hole_data(zone_id: int = None, filter=None):
rabbit_hole_datas = []
rabbit_hole_service = services.get_rabbit_hole_service()
sim_info_manager = services.sim_info_manager()
if rabbit_hole_service is None:
return rabbit_hole_datas
for (sim_id, rabbit_holes) in rabbit_hole_service._rabbit_holes.items():
sim_info = sim_info_manager.get(sim_id)
for rabbit_hole in rabbit_holes:
alarm_handle_remaining_time = rabbit_hole.alarm_handle.get_remaining_time(
) if rabbit_hole.alarm_handle else 'no time limit'
zone_name = 'undefined'
persistence_service = services.get_persistence_service()
if persistence_service is not None:
zone_data = persistence_service.get_zone_proto_buff(
sim_info.zone_id)
if zone_data is not None:
zone_name = zone_data.name
rabbit_hole_datas.append({
'sim':
str(sim_info),
'sim_id':
str(sim_id),
'rabbit_hole_uid':
str(rabbit_hole.guid64),
'rabbit_hole_name':
str(rabbit_hole),
'rabbit_hole_zone':
str(zone_name),
'rabbit_hole_time':
str(alarm_handle_remaining_time),
'rabbit_hole_linked_sims':
str([
sim_info_manager.get(sim_id)
for (sim_id, _) in rabbit_hole.linked_rabbit_holes
]),
'rabbit_hole_phase':
str(rabbit_hole.current_phase)
})
return rabbit_hole_datas
def travel_player(self):
sim = self.sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS)
travel_info = InteractionOps_pb2.TravelSimsToZone()
travel_info.zone_id = self.to_zone_id
travel_info.sim_ids.append(sim.id)
self.interaction = None
if self.is_attend_career:
self._attend_career()
travel_group = self.sim_info.travel_group
if travel_group is not None and not any(sim_info is not self.sim_info and sim_info in self.sim_info.household for sim_info in travel_group):
dest_region = region.get_region_instance_from_zone_id(self.to_zone_id)
current_region = services.current_region()
if not current_region.is_region_compatible(dest_region):
services.travel_group_manager().destroy_travel_group_and_release_zone(travel_group, last_sim_info=self.sim_info)
rabbit_hole_service = services.get_rabbit_hole_service()
if rabbit_hole_service.is_in_rabbit_hole(sim.sim_id):
rabbit_hole_service.set_ignore_travel_cancel_for_sim_id_in_rabbit_hole(sim.sim_id)
sim.queue.cancel_all()
for sim in self.additional_sims:
sim.queue.cancel_all()
travel_info.sim_ids.append(sim.sim_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)
def resume(self):
if self._rabbit_hole_id and not services.get_rabbit_hole_service(
).is_in_rabbit_hole(self._receiver_sim_info.id,
rabbit_hole_id=self._rabbit_hole_id):
services.drama_scheduler_service().complete_node(self.uid)
def on_enter(self):
super().on_enter()
services.get_rabbit_hole_service().restore_rabbit_hole_state()
return _ZoneSpinUpStateResult.DONE
