def create_tuningless_superinteraction(affordance): create_tuningless_interaction(affordance) lock_instance_tunables( affordance, pre_add_autonomy_commodities=None, pre_run_autonomy_commodities=None, post_guaranteed_autonomy_commodities=None, post_run_autonomy_commodities=None, super_affordance_compatibility=None, basic_content=None, outfit_change=None, outfit_priority=None, joinable=None, object_reservation_tests=TunableTestSet.DEFAULT_LIST, ignore_group_socials=False)
def create_tuningless_interaction(affordance, **kwargs): locked_fields = dict(basic_reserve_object=None, basic_focus=None, _forwarding=None, allow_from_world=True, basic_extras=(), _constraints=frozendict(), tests=TunableTestSet.DEFAULT_LIST, test_globals=TunableGlobalTestSet.DEFAULT_LIST, test_autonomous=TunableTestSet.DEFAULT_LIST, _static_commodities=(), _false_advertisements=(), _hidden_false_advertisements=(), _cancelable_by_user=True, visible=False, simless=False, allow_autonomous=False, allow_user_directed=False, debug=False, outcome=InteractionOutcome()) if kwargs: locked_fields.update(kwargs) lock_instance_tunables(affordance, **locked_fields)
def start_situation(self): super().start_situation() self._change_state(GreetedPlayerVisitingNPCState()) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._line_of_sight = None if self._seed.custom_init_params_reader is None and self.initiating_sim_info is not None: sim = self.initiating_sim_info.get_sim_instance() self._line_of_sight = self._line_of_sight_factory() position = sim.position position += sim.forward*self._line_of_sight_generation_distance self._line_of_sight.generate(position, sim.routing_surface) def _issue_requests(self): request = BouncerPlayerVisitingNPCRequestFactory(self, callback_data=_RequestUserData(role_state_type=self.greeted_player_sims.role_state), job_type=self.greeted_player_sims.situation_job, exclusivity=self.exclusivity) self.manager.bouncer.submit_request(request) def _on_add_sim_to_situation(self, sim, job_type, role_state_type_override=None): super()._on_add_sim_to_situation(sim, job_type, role_state_type_override=role_state_type_override) if self._line_of_sight is not None: context = InteractionContext(sim, InteractionContext.SOURCE_SCRIPT, interactions.priority.Priority.High) constraint_to_satisfy = STAND_CONSTRAINT.intersect(self._line_of_sight.constraint) sim.push_super_affordance(ForceSatisfyConstraintSuperInteraction, None, context, constraint_to_satisfy=constraint_to_satisfy, name_override='MoveInsideHouseFromGreetedSituation') lock_instance_tunables(GreetedPlayerVisitingNPCSituation, exclusivity=situations.bouncer.bouncer_types.BouncerExclusivityCategory.VISIT, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, duration=0, _implies_greeted_status=True) class GreetedPlayerVisitingNPCState(situations.situation_complex.SituationState): __qualname__ = 'GreetedPlayerVisitingNPCState'
logger.debug('Loading asset: {0}', cls) class AspirationSimInfoPanel(AspirationBasic): __qualname__ = 'AspirationSimInfoPanel' INSTANCE_TUNABLES = {'display_name': sims4.localization.TunableLocalizedString(description='\n Display name for this aspiration', export_modes=sims4.tuning.tunable_base.ExportModes.All), 'descriptive_text': sims4.localization.TunableLocalizedString(description='\n Description for this aspiration', export_modes=sims4.tuning.tunable_base.ExportModes.All), 'category': sims4.tuning.tunable.TunableReference(description='\n The category this aspiration track goes into when displayed in the UI.', manager=services.get_instance_manager(sims4.resources.Types.ASPIRATION_CATEGORY), export_modes=sims4.tuning.tunable_base.ExportModes.All)} @classmethod def aspiration_type(cls): return AspriationType.SIM_INFO_PANEL @classmethod def _verify_tuning_callback(cls): for objective in cls.objectives: pass lock_instance_tunables(AspirationSimInfoPanel, complete_only_in_sequence=False) class AspirationNotification(AspirationBasic): __qualname__ = 'AspirationNotification' INSTANCE_TUNABLES = {'objectives': sims4.tuning.tunable.TunableList(description='\n A Set of objectives for completing an aspiration.', tunable=sims4.tuning.tunable.TunableReference(description='\n One objective for an aspiration', manager=services.get_instance_manager(sims4.resources.Types.OBJECTIVE))), 'disabled': sims4.tuning.tunable.Tunable(description='\n Checking this box will remove this Aspiration from the event system and the UI, but preserve the tuning.', tunable_type=bool, default=False), 'notification': UiDialogNotification.TunableFactory(description='\n This text will display in a notification pop up when completed.\n ')} @classmethod def aspiration_type(cls): return AspriationType.NOTIFICATION lock_instance_tunables(AspirationNotification, complete_only_in_sequence=False) class AspirationCareer(AspirationBasic): __qualname__ = 'AspirationCareer' def reward(self, *args, **kwargs):
neighbors = services.sim_filter_service().submit_matching_filter(sim_filter=neighbor_filter, allow_yielding=False, blacklist_sim_ids=blacklist_sim_ids, gsi_source_fn=cls.get_sim_filter_gsi_name) neighbor_sim_infos_at_home = [result.sim_info for result in neighbors if result.sim_info.is_at_home] if len(neighbor_sim_infos_at_home) > 1 or len(neighbor_sim_infos_at_home): if neighbor_filter.is_aggregate_filter(): continue neighbor_sim_id = neighbor_sim_infos_at_home[0].sim_id if neighbor_sim_infos_at_home else None if neighbor_sim_id is not None: break return neighbor_sim_id def _set_loud_neighbor_and_door(self, neighbor_sim_id): neighbor_sim_info = services.sim_info_manager().get(neighbor_sim_id) if neighbor_sim_info is None: self._self_destruct() return self._neighbor_sim_id = neighbor_sim_id door_service = services.get_door_service() plex_door_infos = door_service.get_plex_door_infos() object_manager = services.object_manager() for door_info in plex_door_infos: door = object_manager.get(door_info.door_id) if door is not None: if door.household_owner_id == neighbor_sim_info.household_id: self._neighbor_door_id = door_info.door_id break else: logger.error('Could not find door object that belongs to {}', neighbor_sim_info.household.name) self._self_destruct() lock_instance_tunables(LoudNeighborSituation, exclusivity=BouncerExclusivityCategory.NORMAL, _implies_greeted_status=False)
target_si = social_group.get_si_registered_for_sim(target_sim) if target_si is None: continue name = self.display_name_target(target_sim, self.sim) target_sim.ui_manager.add_running_mixer_interaction( target_si.id, self, icon_info, name) if gsi_handlers.interaction_archive_handlers.is_archive_enabled( self): gsi_handlers.interaction_archive_handlers.archive_interaction( target_sim, self, 'Start') if self._target_sim_refs_to_remove_interaction is None: self._target_sim_refs_to_remove_interaction = weakref.WeakSet( ) self._target_sim_refs_to_remove_interaction.add(target_sim) def _remove_interaction_from_targets(self): if self._target_sim_refs_to_remove_interaction: for target_sim in self._target_sim_refs_to_remove_interaction: target_sim.ui_manager.remove_from_si_state(self) if gsi_handlers.interaction_archive_handlers.is_archive_enabled( self): gsi_handlers.interaction_archive_handlers.archive_interaction( target_sim, self, 'Complete') lock_instance_tunables(MixerInteraction, basic_reserve_object=None, _false_advertisements=EMPTY_SET, _hidden_false_advertisements=EMPTY_SET, _require_current_posture=False, time_overhead=10)
for sim_info in participants: while sim_info.id == self.chef_id: return True return False def _was_cooking_interaction_canceled(self, event, resolver): if event == TestEvent.InteractionComplete and resolver(self.cook_group_meal_interaction): if resolver.interaction is not None and resolver.interaction.is_finishing and resolver.interaction.has_been_canceled: participants = resolver.get_participants(ParticipantType.Actor) while True: for sim_info in participants: while sim_info.id == self.chef_id: return True return False lock_instance_tunables(FamilyMealSituation, exclusivity=situations.bouncer.bouncer_types.BouncerExclusivityCategory.NORMAL, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE) class TryingToCookState(SituationState): __qualname__ = 'TryingToCookState' def __init__(self): super().__init__() self._try_to_cook_timeout_alarm_handle = None def on_activate(self, reader=None): super().on_activate(reader) trying_to_cook_timeout = self.owner.trying_to_cook_timeout if reader is not None: trying_to_cook_timeout = reader.read_float('trying_to_cook_timeout', trying_to_cook_timeout) self._try_to_cook_timeout_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(trying_to_cook_timeout), self._try_and_cook_timeout_callback) self._test_event_register(TestEvent.InteractionStart)
import role import sims4.tuning.tunable import situations.bouncer.bouncer_types import situations.situation_complex class GreetedNPCVisitingNPCSituation(VisitingNPCSituation): __qualname__ = 'GreetedNPCVisitingNPCSituation' INSTANCE_TUNABLES = {'greeted_npc_sims': sims4.tuning.tunable.TunableTuple(situation_job=situations.situation_job.SituationJob.TunableReference(description='\n The job given to NPC sims in the visiting situation.\n '), role_state=role.role_state.RoleState.TunableReference(description='\n The role state given to NPC sims in the visiting situation.\n '), tuning_group=GroupNames.ROLES)} @staticmethod def _states(): return [(1, GreetedNPCVisitingNPCState)] @classmethod def _get_tuned_job_and_default_role_state_tuples(cls): return [(cls.greeted_npc_sims.situation_job, cls.greeted_npc_sims.role_state)] @classmethod def default_job(cls): return cls.greeted_npc_sims.situation_job def start_situation(self): super().start_situation() self._change_state(GreetedNPCVisitingNPCState()) lock_instance_tunables(GreetedNPCVisitingNPCSituation, exclusivity=situations.bouncer.bouncer_types.BouncerExclusivityCategory.VISIT, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, _implies_greeted_status=True) class GreetedNPCVisitingNPCState(situations.situation_complex.SituationState): __qualname__ = 'GreetedNPCVisitingNPCState'
time_till_completion = (next_hour - self._total_time_ran)/len(self._sims_running_interaction) self._alarm_handle = alarms.add_alarm(self, time_till_completion, self._on_hour_reached) self._last_started_time = services.time_service().sim_now def _stop_alarm(self): if self._alarm_handle is not None: alarms.cancel_alarm(self._alarm_handle) self._alarm_handle = None self._last_started_time = None def _run_goal_completion_tests(self, sim_info, event, resolver): if not resolver(self._goal_test): return False self._stop_alarm() if event == event_testing.test_events.TestEvent.InteractionStart: self._sims_running_interaction.add(sim_info.id) else: self._sims_running_interaction.discard(sim_info.id) self._start_alarm() return False @property def completed_iterations(self): return int(self._total_time_ran.in_hours()) @property def max_iterations(self): return self._goal_test.duration lock_instance_tunables(SituationGoalInteractionTime, _iterations=1)
def _first_same_sex_relationship_callback(self, _): sims.global_gender_preference_tuning.GlobalGenderPreferenceTuning.enable_autogeneration_same_sex_preference = True self.remove_callback(self._first_same_sex_relationship_callback_data) services.get_instance_manager(sims4.resources.Types.STATISTIC).add_on_load_complete(RelationshipTrack.check_relationship_track_display_priorities) class ShortTermContextRelationshipTrack(RelationshipTrack): __qualname__ = 'ShortTermContextRelationshipTrack' INSTANCE_TUNABLES = {'socialization_decay_modifier': TunableRange(description='\n A multiplier to apply to the decay rate if the two Sims that this\n relationship track applies to are socializing.\n ', tunable_type=float, default=1, minimum=0)} @classproperty def is_short_term_context(cls): return True def on_add(self): super().on_add() sim = self.tracker.relationship.find_sim() target = self.tracker.relationship.find_target_sim() if sim is not None and target is not None and sim.is_in_group_with(target): self.apply_social_group_decay() def apply_social_group_decay(self): if self.socialization_decay_modifier != 1: self.add_decay_rate_modifier(self.socialization_decay_modifier) def remove_social_group_decay(self): if self.socialization_decay_modifier != 1: self.remove_decay_rate_modifier(self.socialization_decay_modifier) lock_instance_tunables(ShortTermContextRelationshipTrack, visible_test_set=DEFAULT)
@classmethod def default_job(cls): return cls.ungreeted_npc_sims.situation_job def start_situation(self): super().start_situation() self._change_state(UngreetedNPCVisitingNPCState()) def _on_make_waiting_player_greeted(self, door_bell_ringing_sim): self._greet() def _on_set_sim_job(self, sim, job_type): super()._on_set_sim_job(sim, job_type) if self.manager.is_player_greeted(): self._greet() def _greet(self): for sim in self.all_sims_in_situation_gen(): self.manager.create_greeted_npc_visiting_npc_situation(sim.sim_info) def _on_sim_removed_from_situation_prematurely(self, sim): if self.num_of_sims > 0: return self._self_destruct() lock_instance_tunables(UngreetedNPCVisitingNPCSituation, exclusivity=situations.bouncer.bouncer_types.BouncerExclusivityCategory.UNGREETED, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE) class UngreetedNPCVisitingNPCState(situations.situation_complex.SituationState): __qualname__ = 'UngreetedNPCVisitingNPCState'
return inst._constraint_to_satisfy if sim is DEFAULT: sim = inst.get_participant(participant_type) return sim.si_state.get_total_constraint(to_exclude=inst) def _run_interaction_gen(self, timeline): self.sim.on_slot = None result = yield super()._run_interaction_gen(timeline) if not result: return False if self._run_element is not None: result = yield element_utils.run_child(timeline, self._run_element) return result return True lock_instance_tunables(SitOrStandSuperInteraction, _constraints=(), _constraints_actor=ParticipantType.Object) class SatisfyConstraintSuperInteraction(SitOrStandSuperInteraction): __qualname__ = 'SatisfyConstraintSuperInteraction' INSTANCE_SUBCLASSES_ONLY = True create_tuningless_superinteraction(SatisfyConstraintSuperInteraction) class ForceSatisfyConstraintSuperInteraction(SatisfyConstraintSuperInteraction): __qualname__ = 'ForceSatisfyConstraintSuperInteraction' INSTANCE_SUBCLASSES_ONLY = True @classmethod def is_adjustment_interaction(cls): return False
self._total_simoleons_earned = simoleons_earned def create_seedling(self): seedling = super().create_seedling() writer = seedling.writer writer.write_uint64(self.SIMOLEONS_EARNED, self._total_simoleons_earned) return seedling def decommision(self): services.get_event_manager().unregister(self, self._test_events) super().decommision() def _run_goal_completion_tests(self, sim_info, event, resolver): if not resolver(self._goal_test): return False amount_to_add = resolver.get_resolved_arg('amount') if self._total_simoleons_earned >= self._goal_test.amount_to_earn: super()._on_goal_completed() else: self._on_iteration_completed() @property def completed_iterations(self): return self._total_simoleons_earned @property def max_iterations(self): return self._goal_test.amount_to_earn lock_instance_tunables(SituationGoalSimoleonsEarned, _iterations=1)
@classproperty def final_product_canvas_tuning(cls): return cls.final_product_type._components.canvas @classproperty def style_display_name(cls): return cls.painting_style.display_name @classmethod def pick_texture(cls, crafter) -> PaintingTexture: canvas_types = cls.final_product_canvas_tuning.canvas_types texture = cls.painting_style.pick_texture(crafter, canvas_types) return texture @classmethod def setup_crafted_object(cls, crafted_object, crafter, is_final_product): super().setup_crafted_object(crafted_object, crafter, is_final_product) if is_final_product: texture = cls.pick_texture(crafter) if texture is None: logger.error('Tuning Error: No texture found for {0}', crafted_object, owner='nbaker') return texture.apply_to_object(crafted_object) @classmethod def update_hovertip(cls, owner, crafter=None): crafting_component._set_simoleon_value(owner, owner.current_value) crafting_component._set_style_name(owner, cls.style_display_name) lock_instance_tunables(PaintingRecipe, multi_serving_name=None, push_consume=False)
major_goal_msg.audio_sting.group = self.main_goal_audio_sting.group major_goal_msg.audio_sting.instance = self.main_goal_audio_sting.instance def _set_minor_goals_data(self, pet, goals_msg): discovered_symptoms = pet.sim_info.sickness_tracker.discovered_symptoms while True: for i in range(0 if pet.sim_info.current_sickness is None else len( pet.sim_info.current_sickness.symptoms)): is_symptom_discovered = len( discovered_symptoms ) > i and pet.sim_info.was_symptom_discovered( discovered_symptoms[i]) symptom_goal_name = discovered_symptoms[i].display_name( ) if is_symptom_discovered else self.undiscovered_symptom_text( ) with ProtocolBufferRollback(goals_msg) as goal_msg: goal_msg.goal_id = SICKNESS_MINOR_GOAL_IDS[i] goal_msg.goal_name = symptom_goal_name goal_msg.max_iterations = 1 goal_msg.current_iterations = 1 if is_symptom_discovered else 0 if self.audio_sting_on_symptom_discovery is not None: goal_msg.audio_sting.type = self.audio_sting_on_symptom_discovery.type goal_msg.audio_sting.group = self.audio_sting_on_symptom_discovery.group goal_msg.audio_sting.instance = self.audio_sting_on_symptom_discovery.instance lock_instance_tunables( VetClinicDiagnosisSituation, exclusivity=BouncerExclusivityCategory.NORMAL, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, duration=0)
description= '\n The job and role state for a party pooper.\n ' ) } REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES @classmethod def _states(cls): return (SituationStateData(1, _PartyPooperState, factory=cls.party_pooper_state), ) @classmethod def _get_tuned_job_and_default_role_state_tuples(cls): return [(cls.party_pooper_job_and_role.job, cls.party_pooper_job_and_role.role_state)] @classmethod def default_job(cls): return cls.party_pooper_job_and_role.situation_job def start_situation(self): super().start_situation() self._change_state(self.party_pooper_state()) lock_instance_tunables( PartyPooperSituation, exclusivity=BouncerExclusivityCategory.NORMAL, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, _implies_greeted_status=False)
def __init__(self, *args, sim_info=None, **kwargs): super().__init__(*args, **kwargs) self._sim_info = sim_info @flexmethod def get_participants(cls, inst, participant_type, sim=DEFAULT, target=DEFAULT, sim_info=None, **interaction_parameters) -> set: result = super(ImmediateSuperInteraction, inst if inst is not None else cls).get_participants(participant_type, sim=sim, target=target, **interaction_parameters) result = set(result) if inst is not None: sim_info = inst._sim_info if participant_type & ParticipantType.Actor and sim_info is not None: result.add(sim_info) return tuple(result) lock_instance_tunables(SimInfoInteraction, simless=True) class BringHereInteraction(SimInfoInteraction): __qualname__ = 'BringHereInteraction' @classmethod def _test(cls, *args, sim_info=None, **kwargs): if sim_info.zone_id == services.current_zone_id(): return TestResult(False, 'Cannot bring a sim to a zone that is already the current zone.') return super()._test(*args, **kwargs) def _run_interaction_gen(self, timeline): SimSpawner.spawn_sim(self._sim_info) class SwitchToZoneInteraction(SimInfoInteraction): __qualname__ = 'SwitchToZoneInteraction'
crafted_object, owner='nbaker') return reveal_level = crafted_object.canvas_component.painting_reveal_level texture.apply_to_object(crafted_object) if reveal_level is not None: crafted_object.canvas_component.painting_reveal_level = reveal_level @classmethod def update_hovertip(cls, owner, crafter=None): owner.update_tooltip_field(TooltipFieldsComplete.simoleon_value, owner.current_value) owner.update_tooltip_field(TooltipFieldsComplete.style_name, cls.style_display_name) owner.update_object_tooltip() lock_instance_tunables(PaintingRecipe, multi_serving_name=None, push_consume=False) class PaintByReferenceRecipe(PaintingRecipe): @classmethod def _verify_tuning_callback(cls): cls._verify_recipe_tuning_callback() @classmethod def setup_crafted_object(cls, crafted_object, crafter, is_final_product): cls._setup_crafted_object(crafted_object, crafter, is_final_product)
def create_tuningless_superinteraction(affordance): create_tuningless_interaction(affordance) lock_instance_tunables(affordance, pre_add_autonomy_commodities=None, pre_run_autonomy_commodities=None, post_guaranteed_autonomy_commodities=None, post_run_autonomy_commodities=None, super_affordance_compatibility=None, basic_content=None, outfit_change=None, outfit_priority=None, joinable=None, object_reservation_tests=TunableTestSet.DEFAULT_LIST, ignore_group_socials=False)
@classmethod def default_job(cls): pass @classmethod def _states(cls): return (SituationStateData(1, ArriveState, factory=cls.arrive_state), SituationStateData(2, TendState, factory=cls.tend_state)) @classmethod def _get_tuned_job_and_default_role_state_tuples(cls): return [(cls.tendor_job_and_role_state.job, cls.tendor_job_and_role_state.role_state)] def start_situation(self): super().start_situation() self._change_state(self.arrive_state()) def _save_custom_situation(self, writer): super()._save_custom_situation(writer) staffed_object = self.get_staffed_object() if staffed_object is not None: writer.write_uint64(OBJECT_TOKEN, staffed_object.id) lock_instance_tunables( TendObjectSituation, exclusivity=BouncerExclusivityCategory.VENUE_EMPLOYEE, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, _implies_greeted_status=False)
def create_tuningless_interaction(affordance, **kwargs): locked_fields = dict(basic_reserve_object=None, basic_focus=None, allow_forward=False, allow_from_world=True, basic_extras=[], _constraints=[], tests=TunableTestSet.DEFAULT_LIST, test_globals=TunableGlobalTestSet.DEFAULT_LIST, test_autonomous=TunableTestSet.DEFAULT_LIST, _static_commodities=[], _false_advertisements=[], _hidden_false_advertisements=[], _cancelable_by_user=True, visible=False, simless=False, allow_autonomous=False, allow_user_directed=False, debug=False, outcome=InteractionOutcome()) if kwargs: locked_fields.update(kwargs) lock_instance_tunables(affordance, **locked_fields)
CooldownFestivalSituationState, factory=cls.cooldown_state)) @classmethod def _get_tuned_job_and_default_role_state_tuples(cls): return list( cls.initial_state._tuned_values.job_and_role_changes.items()) def start_situation(self): super().start_situation() self._change_state(self.initial_state()) lock_instance_tunables( GenericOneStateFestivalAttendeeSituation, exclusivity=BouncerExclusivityCategory.FESTIVAL_GOER, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, _implies_greeted_status=False) class StartingTransitioningFestivalSituationState(CommonSituationState): def timer_expired(self): self._change_state(self.owner.secondary_state()) class SecondaryFestivalSituationState(CommonSituationState): pass class GenericTwoStateFestivalAttendeeSituation(BaseGenericFestivalSituation): INSTANCE_TUNABLES = {
from sims4 import commands from sims4.tuning.instances import lock_instance_tunables from sims4.tuning.tunable import TunableList, TunableVariant, Tunable from sims4.utils import classproperty from situations.tunable import CreateSituationElement from tag import Tag class ImmediateSuperInteraction(SuperInteraction): __qualname__ = 'ImmediateSuperInteraction' INSTANCE_TUNABLES = {'basic_content': TunableBasicContentSet(no_content=True, default='no_content'), 'basic_extras': TunableList(description='Additional elements to run around the basic content of the interaction.', tunable=TunableVariant(state_change=TunableStateChange(), create_situation=CreateSituationElement.TunableFactory(), create_object=ObjectCreationElement.TunableFactory(), notification=NotificationElement.TunableFactory(), payment=PaymentElement.TunableFactory(), destroy_object=ObjectDestructionElement.TunableFactory(), vfx=PlayVisualEffectElement.TunableFactory()))} @classproperty def immediate(cls): return True lock_instance_tunables(ImmediateSuperInteraction, allow_autonomous=False, _cancelable_by_user=False, _must_run=True, visible=False, _constraints=[], basic_reserve_object=None, basic_focus=None, intensity=InteractionIntensity.Default, interaction_category_tags=frozenset([Tag.INVALID]), super_affordance_compatibility=None, animation_stat=None, _provided_posture_type=None, supported_posture_type_filter=[], force_autonomy_on_inertia=False, force_exit_on_inertia=False, pre_add_autonomy_commodities=[], pre_run_autonomy_commodities=[], post_guaranteed_autonomy_commodities=[], post_run_autonomy_commodities=SimpleNamespace(requests=[], fallback_notification=None), opportunity_cost_multiplier=1, autonomy_can_overwrite_similar_affordance=False, subaction_selection_weight=1, relationship_scoring=False, _party_size_weight_tuning=[], joinable=[], rallyable=None, autonomy_preference=None, outfit_priority=None, outfit_change=None, object_reservation_tests=[], cancel_replacement_affordances=None, privacy=None, provided_affordances=[], canonical_animation=None, ignore_group_socials=False) class CommandSuperInteraction(ImmediateSuperInteraction): __qualname__ = 'CommandSuperInteraction' INSTANCE_TUNABLES = {'command': Tunable(str, None, description='The command to run.')} def _run_gen(self, timeline): if self.context.client is not None: if self.context.target_sim_id is not None: commands.execute('{} {}'.format(self.command, self.context.target_sim_id), self.context.client.id) else: commands.execute('{} {}'.format(self.command, self.target.id), self.context.client.id) else: commands.execute('{} {}'.format(self.command, self.target.id), None) return True yield None
def _constraint_gen(cls, *args, **kwargs): for constraint in super()._constraint_gen(*args, **kwargs): yield constraint yield cls.CONSTRAINT class TerrainSuperInteraction(TerrainInteractionMixin, SuperInteraction): __qualname__ = 'TerrainSuperInteraction' INSTANCE_TUNABLES = {'basic_content': TunableBasicContentSet(no_content=True, default='no_content')} @classmethod def _constraint_gen(cls, *args, **kwargs): for constraint in super()._constraint_gen(*args, **kwargs): yield constraint yield services.current_zone().get_spawn_point_ignore_constraint() lock_instance_tunables(TerrainSuperInteraction, basic_reserve_object=None, basic_focus=None) class TerrainImmediateSuperInteraction(TerrainInteractionMixin, ImmediateSuperInteraction): __qualname__ = 'TerrainImmediateSuperInteraction' INSTANCE_SUBCLASSES_ONLY = True class TravelSuperInteraction(TravelMixin, TerrainSuperInteraction): __qualname__ = 'TravelSuperInteraction' @classmethod def _test(cls, target, context, **kwargs): (position, _, result) = cls._get_target_position_surface_and_test_off_lot(target, context) if not result: return result if position is not None and not terrain.is_position_in_street(position): return TestResult(False, 'Cannot Travel from terrain outside of the street!')
logger.debug('Saving sim during TravelInteraction for {}', sim_info) sim_info.inject_into_inactive_zone(self.to_zone_id) save_success = sim_info.save_sim() while not save_success: logger.error('Failure saving during TravelInteraction for {}', sim_info) finally: logger.debug('Destroying sim {}', sim_info) self.force_save_and_destroy_sim = False if on_reset: if self.sim is not None: services.object_manager().remove(self.sim) notify_travel_service() elif self.sim is not None: self.sim.schedule_destroy_asap(source=self, cause='Destroying sim on travel.') lock_instance_tunables(TravelInteraction, basic_reserve_object=None, basic_focus=None, allow_from_object_inventory=False, allow_from_sim_inventory=False, intensity=InteractionIntensity.Default, basic_liabilities=[], animation_stat=None, _provided_posture_type=None, supported_posture_type_filter=[], force_autonomy_on_inertia=False, force_exit_on_inertia=False, pre_add_autonomy_commodities=[], pre_run_autonomy_commodities=[], post_guaranteed_autonomy_commodities=[], post_run_autonomy_commodities=SimpleNamespace(requests=[], fallback_notification=None), opportunity_cost_multiplier=1, autonomy_can_overwrite_similar_affordance=False, subaction_selection_weight=1, relationship_scoring=False, _party_size_weight_tuning=[], joinable=[], rallyable=None, autonomy_preference=None, outfit_change=None, outfit_priority=None, object_reservation_tests=[], cancel_replacement_affordances=None, privacy=None, provided_affordances=[], canonical_animation=None, ignore_group_socials=False, utility_info=None, skill_loot_data=skill.EMPTY_SKILL_LOOT_DATA) class GoToSpecificLotTravelInteraction(TravelInteraction): __qualname__ = 'GoToSpecificLotTravelInteraction' INSTANCE_TUNABLES = {'destination_lot': OptionalTunable(description="\n If enabled, tune a specific lot description to be the destination\n of the interaction. Otherwise, the interaction will assume the\n destination lot is the Sim's home lot.\n ", tunable=TunableLotDescription(description='\n The lot description of the destination lot.\n '))} def __init__(self, aop, context, **kwargs): if self.destination_lot is None: zone_id = context.sim.household.home_zone_id else: lot_id = get_lot_id_from_instance_id(self.destination_lot) zone_id = services.get_persistence_service().resolve_lot_id_into_zone_id(lot_id, ignore_neighborhood_id=True) super().__init__(aop, context, from_zone_id=context.sim.zone_id, to_zone_id=zone_id, on_complete_callback=None, on_complete_context=None, **kwargs) def _run_interaction_gen(self, timeline): travel_info = InteractionOps_pb2.TravelSimsToZone()
def _pick_affordance(self, order_sim, object_info, context): deliver_part = None carry_track = object_info.carry_track deliver_to_bar = self.delivery_to_bar_affordance deliver_to_sit_drink_slot = self.delivery_to_sit_drink_slot_affordance if self.sim == order_sim or order_sim is None: return (deliver_to_bar, self.target, deliver_part, carry_track) order_surface_target = order_sim.posture_state.surface_target if order_surface_target is not None and order_surface_target.is_part: bar = None if self.target.is_part: bar = self.target.part_owner if order_surface_target.part_owner is bar: if order_surface_target.is_valid_for_placement(definition=object_info.definition): deliver_part = order_surface_target return (deliver_to_sit_drink_slot, self.target, deliver_part, carry_track) return (deliver_to_bar, self.target, deliver_part, carry_track) def _run_interaction_gen(self, timeline): (order_sim, recipe) = self.process.pop_order() object_info = recipe.final_product context = self.context.clone_for_continuation(self) (deliver_affordance, target, deliver_part, carry_track) = self._pick_affordance(order_sim, object_info, context) obj_info_copy = FrozenAttributeDict(object_info, carry_track=carry_track) new_process = self.process.copy_for_serve_drink(recipe) aop = AffordanceObjectPair(deliver_affordance, target, deliver_affordance, None, order_sim=order_sim, object_info=obj_info_copy, deliver_part=deliver_part, phase=self.process.phase, crafting_process=new_process) self._went_to_next_phase_or_finished_crafting = True return aop.test_and_execute(context) lock_instance_tunables(ChooseDeliverySuperInteraction, basic_content=None)
def _create_social_geometry(self, sim, call_on_changed=True): pass def _clear_social_geometry(self, sim, call_on_changed=True): pass def _group_geometry_changed(self): pass def _create_adjustment_alarm(self): pass def try_relocate_around_focus(self, *args, **kwargs): return True lock_instance_tunables(SideGroup, adjust_sim_positions_dynamically=True, is_side_group=True) class GameGroup(SideGroup): __qualname__ = 'GameGroup' INSTANCE_TUNABLES = {'social_anchor_object': TunableEnumEntry(description='\n The participant type used to find an object with the game component.\n This object will also be used as the social anchor for your social\n group to ensure the players of the game are around the object.\n ', tunable_type=ParticipantTypeObject, default=ParticipantTypeObject.ActorSurface)} def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.geometry = None @classmethod def make_constraint_default(cls, *args, **kwargs): return Anywhere() @property def _los_constraint(self):
TunableBasicContentSet(one_shot=True, no_content=True, default='no_content') } @flexmethod def _constraint_gen(cls, inst, *args, **kwargs): for constraint in super()._constraint_gen(*args, **kwargs): yield constraint zone = services.current_zone() if zone is not None: yield zone.get_spawn_point_ignore_constraint() lock_instance_tunables(TerrainSuperInteraction, basic_reserve_object=None, basic_focus=None) class TerrainImmediateSuperInteraction(TerrainInteractionMixin, ImmediateSuperInteraction): INSTANCE_SUBCLASSES_ONLY = True class TravelMixin: def __init__(self, *args, to_zone_id=0, **kwargs): super().__init__(*args, to_zone_id=to_zone_id, **kwargs) self.to_zone_id = to_zone_id @classmethod def travel_test(cls, context):
lock_instance_tunables(ImmediateSuperInteraction, allow_autonomous=False, _cancelable_by_user=False, _must_run=True, visible=False, _constraints=frozendict(), basic_reserve_object=None, basic_focus=None, intensity=InteractionIntensity.Default, super_affordance_compatibility=None, animation_stat=None, _provided_posture_type=None, supported_posture_type_filter=(), force_autonomy_on_inertia=False, force_exit_on_inertia=False, disallow_as_mixer_target=False, attention_cost=0.5, _false_advertisements=(), _hidden_false_advertisements=(), _static_commodities=(), _affordance_key_override_for_autonomy=None, apply_autonomous_posture_change_cost=True, disable_autonomous_multitasking_if_user_directed=False, test_autonomous=TunableTestSet.DEFAULT_LIST, pre_add_autonomy_commodities=(), pre_run_autonomy_commodities=(), post_guaranteed_autonomy_commodities=(), post_run_autonomy_commodities=SimpleNamespace( requests=(), fallback_notification=None), scoring_priority=AutonomyInteractionPriority.INVALID, duplicate_affordance_group=Tag.INVALID, time_overhead=1, use_best_scoring_aop=True, opportunity_cost_multiplier=1, autonomy_can_overwrite_similar_affordance=False, subaction_selection_weight=1, relationship_scoring=False, _party_size_weight_tuning=(), joinable=(), rallyable=None, autonomy_preference=None, outfit_priority=None, outfit_change=None, object_reservation_tests=(), cancel_replacement_affordances=None, privacy=None, provided_affordances=(), canonical_animation=None, ignore_group_socials=False)
def _pre_perform(self, *args, **kwargs): if self.sim.household.free_slot_count == 0: self.cancel(FinishingType.FAILED_TESTS, cancel_reason_msg="There aren't any free household slots.") return self.add_liability(ADOPTION_LIABILTIY, AdoptionLiability()) return super()._pre_perform(*args, **kwargs) def on_choice_selected(self, choice_tag, **kwargs): sim_id = choice_tag if sim_id is not None: self._picked_sim_id = sim_id self.add_liability(SIM_FILTER_GLOBAL_BLACKLIST_LIABILITY, SimFilterGlobalBlacklistLiability((sim_id,), SimFilterGlobalBlacklistReason.ADOPTION)) self.trigger_soft_stop() lock_instance_tunables(AdoptionPickerInteraction, pie_menu_option=None) class AdoptionInteraction(SuperInteraction, NameOffspringSuperInteractionMixin): __qualname__ = 'AdoptionInteraction' INSTANCE_TUNABLES = {'dialog': SimPersonalityAssignmentDialog.TunableFactory(description="\n The dialog that is displayed (and asks for the user to enter a first\n name and last name) before assigning the sim to your household.\n \n An additional token is passed in: the adopted Sim's data.\n ", text_inputs=(TEXT_INPUT_FIRST_NAME, TEXT_INPUT_LAST_NAME), locked_args={'phone_ring_type': PhoneRingType.NO_RING}), 'adoption_trait': TunableReference(description='\n Trait that represents the sim being considered adoptable. The\n trait will be removed from the sim being adopted upon adoption\n being completed.\n ', manager=services.get_instance_manager(sims4.resources.Types.TRAIT))} def _pre_perform(self, *args, **kwargs): self.add_liability(interactions.rabbit_hole.RABBIT_HOLE_LIABILTIY, interactions.rabbit_hole.RabbitHoleLiability()) return super()._pre_perform(*args, **kwargs) def _build_outcome_sequence(self, *args, **kwargs): sequence = super()._build_outcome_sequence(*args, **kwargs) return element_utils.build_critical_section(self._name_and_create_adoptee_gen, sequence) def _get_name_dialog(self): adopted_sim_info = self.get_participant(ParticipantType.PickedSim)
factory=cls.tend_state), SituationStateData(3, SalesTableTeardownState, factory=cls.teardown_state)) @classmethod def _get_tuned_job_and_default_role_state_tuples(cls): return [(cls.vendor_job_and_role_state.job, cls.vendor_job_and_role_state.role_state)] def start_situation(self): super().start_situation() self._change_state(self.setup_state()) class SalesTableVendorSituation(SalesTableVendorSituationMixin, SituationComplexCommon): REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES lock_instance_tunables( SalesTableVendorSituation, exclusivity=BouncerExclusivityCategory.WALKBY, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, _implies_greeted_status=False) class StaffedSalesTableVendorSituation(StaffedObjectSituationMixin, SalesTableVendorSituation): pass
lock_instance_tunables(TravelInteraction, basic_reserve_object=None, basic_focus=None, allow_from_object_inventory=False, allow_from_sim_inventory=False, intensity=InteractionIntensity.Default, basic_liabilities=[], animation_stat=None, _provided_posture_type=None, supported_posture_type_filter=[], force_autonomy_on_inertia=False, force_exit_on_inertia=False, pre_add_autonomy_commodities=[], pre_run_autonomy_commodities=[], post_guaranteed_autonomy_commodities=[], post_run_autonomy_commodities=SimpleNamespace( requests=[], fallback_notification=None), opportunity_cost_multiplier=1, autonomy_can_overwrite_similar_affordance=False, subaction_selection_weight=1, relationship_scoring=False, _party_size_weight_tuning=[], joinable=[], rallyable=None, autonomy_preference=None, outfit_change=None, outfit_priority=None, object_reservation_tests=[], cancel_replacement_affordances=None, privacy=None, provided_affordances=[], canonical_animation=None, ignore_group_socials=False, utility_info=None, skill_loot_data=skill.EMPTY_SKILL_LOOT_DATA)
self.sim.routing_component.on_slot = None result = yield from super()._run_interaction_gen(timeline) if not result: return False yield elif self._run_element is not None: result = yield from element_utils.run_child( timeline, self._run_element) return result yield return True yield lock_instance_tunables(SitOrStandSuperInteraction, _constraints=frozendict(), _constraints_actor=ParticipantType.Object) class SatisfyConstraintSuperInteraction(SitOrStandSuperInteraction): INSTANCE_SUBCLASSES_ONLY = True create_tuningless_superinteraction(SatisfyConstraintSuperInteraction) class ForceSatisfyConstraintSuperInteraction(SatisfyConstraintSuperInteraction ): INSTANCE_SUBCLASSES_ONLY = True @classmethod
**interaction_parameters) -> set: result = super(ImmediateSuperInteraction, inst if inst is not None else cls).get_participants( participant_type, sim=sim, target=target, **interaction_parameters) result = set(result) if inst is not None: sim_info = inst._sim_info if participant_type & ParticipantType.Actor and sim_info is not None: result.add(sim_info) return tuple(result) lock_instance_tunables(SimInfoInteraction, simless=True) class BringHereInteraction(SimInfoInteraction): __qualname__ = 'BringHereInteraction' @classmethod def _test(cls, *args, sim_info=None, **kwargs): if sim_info.zone_id == services.current_zone_id(): return TestResult( False, 'Cannot bring a sim to a zone that is already the current zone.' ) return super()._test(*args, **kwargs) def _run_interaction_gen(self, timeline):
lock_instance_tunables(ImmediateSuperInteraction, allow_autonomous=False, _cancelable_by_user=False, _must_run=True, visible=False, _constraints=[], basic_reserve_object=None, basic_focus=None, intensity=InteractionIntensity.Default, interaction_category_tags=frozenset([Tag.INVALID]), super_affordance_compatibility=None, animation_stat=None, _provided_posture_type=None, supported_posture_type_filter=[], force_autonomy_on_inertia=False, force_exit_on_inertia=False, pre_add_autonomy_commodities=[], pre_run_autonomy_commodities=[], post_guaranteed_autonomy_commodities=[], post_run_autonomy_commodities=SimpleNamespace( requests=[], fallback_notification=None), opportunity_cost_multiplier=1, autonomy_can_overwrite_similar_affordance=False, subaction_selection_weight=1, relationship_scoring=False, _party_size_weight_tuning=[], joinable=[], rallyable=None, autonomy_preference=None, outfit_priority=None, outfit_change=None, object_reservation_tests=[], cancel_replacement_affordances=None, privacy=None, provided_affordances=[], canonical_animation=None, ignore_group_socials=False)
cls.gig_pay.lower_bound, pay_rate, scheduled_time, finishing_time, tip.tip_title(), tip.tip_text(), gig_customer) if not enabled and cls.disabled_tooltip is not None: row_tooltip = lambda *_: cls.disabled_tooltip(owner) elif cls.display_description is None: row_tooltip = None else: row_tooltip = lambda *_: cls.display_description(owner) customer_description = cls.odd_job_tuning.customer_description( gig_customer) row = OddJobPickerRow(customer_id=gig_customer.id, customer_description=customer_description, tip_title=tip.tip_title(), tip_text=tip.tip_text(), tip_icon=tip.tip_icon, name=cls.display_name(owner), icon=cls.display_icon, row_description=description, row_tooltip=row_tooltip, is_enable=enabled) return row lock_instance_tunables(RabbitholeGig, gig_prep_tasks=None, audio_on_prep_task_completion=None, career_events=None, gig_cast_rel_bit_collection_id=None, gig_cast=None, end_of_gig_dialog=None, payout_stat_data=None)
manager=services.get_instance_manager( sims4.resources.Types.ASPIRATION_CATEGORY), export_modes=sims4.tuning.tunable_base.ExportModes.All) } @classmethod def aspiration_type(cls): return AspriationType.SIM_INFO_PANEL @classmethod def _verify_tuning_callback(cls): for objective in cls.objectives: pass lock_instance_tunables(AspirationSimInfoPanel, complete_only_in_sequence=False) class AspirationNotification(AspirationBasic): __qualname__ = 'AspirationNotification' INSTANCE_TUNABLES = { 'objectives': sims4.tuning.tunable.TunableList( description= '\n A Set of objectives for completing an aspiration.', tunable=sims4.tuning.tunable.TunableReference( description='\n One objective for an aspiration', manager=services.get_instance_manager( sims4.resources.Types.OBJECTIVE))), 'disabled': sims4.tuning.tunable.Tunable(
return random.weighted_random_item(weighted) def _enable_state(self, state_type): if state_type in self._locked_states: self._locked_states.remove(state_type) def _disable_state(self, state_type): self._locked_states.add(state_type) if self._cur_state.state_type == state_type: self.try_set_next_state() def get_phase_state_name_for_gsi(self): if self._cur_state is None: return 'None' else: return self._cur_state.state_type.name def _gsi_additional_data_gen(self): yield ('Locked States', str(self._locked_states)) def log_flow_entry(self, message): log_vet_flow_entry(repr(self.get_employee()), type(self).__name__, message) lock_instance_tunables( VetEmployeeSituation, duration=0, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, exclusivity=situations.bouncer.bouncer_types.BouncerExclusivityCategory. VENUE_EMPLOYEE)
def _run_interaction_gen(self, timeline): self.away_action_sim_info.away_action_tracker.create_and_apply_away_action( self.away_action, self.away_action_target) @flexmethod def get_display_tooltip(cls, inst, away_action=None, **kwargs): if inst is not None: away_action = inst.away_action inst_or_cls = inst if inst is not None else cls if away_action is not None: return inst_or_cls.create_localized_string( away_action.pie_menu_tooltip, **kwargs) return inst_or_cls.get_display_tooltip(**kwargs) lock_instance_tunables(ApplyAwayActionInteraction, simless=True) class AwayActionSimPickerInteraction(SimPickerInteraction): __qualname__ = 'AwayActionSimPickerInteraction' def __init__(self, *args, away_action=None, away_action_sim_info=None, **kwargs): super().__init__(*args, **kwargs) self.away_action = away_action self.away_action_sim_info = away_action_sim_info @classmethod
if success and self.ui_display_type != DramaNodeUiDisplayType.NO_UI: services.calendar_service().mark_on_calendar(self) return success def create_calendar_entry(self): calendar_entry = super().create_calendar_entry() calendar_entry.zone_id = self._zone_id build_icon_info_msg( IconInfoData( icon_resource=self._display_data.instance_display_icon), self._display_data.instance_display_name, calendar_entry.icon_info) calendar_entry.scoring_enabled = False return calendar_entry lock_instance_tunables(VenueEventDramaNode, ui_display_data=None) class OrganizationEventDramaNode(VenueEventDramaNode): INSTANCE_TUNABLES = { 'fake_duration': TunableSimMinute( description= "\n The amount of time in Sim minutes that is used by UI to display the\n drama node's activity's duration. When the event actually runs the\n open street director determines actual end-time.\n ", default=60, minimum=1), 'organization': TunableReference( description= '\n The organization for which this drama node is scheduling venue events.\n ', manager=services.get_instance_manager(
self.away_action_sim_info.away_action_tracker.create_and_apply_away_action( self.away_action, self.away_action_target) @flexmethod def get_display_tooltip(cls, inst, away_action=None, **kwargs): if inst is not None: away_action = inst.away_action inst_or_cls = inst if inst is not None else cls if away_action is not None: return inst_or_cls.create_localized_string( away_action.pie_menu_tooltip, **kwargs) return inst_or_cls.get_display_tooltip(**kwargs) lock_instance_tunables(ApplyAwayActionInteraction, simless=True, tests=TunableTestSet.DEFAULT_LIST) class AwayActionSimPickerInteraction(SimPickerInteraction): def __init__(self, *args, away_action=None, away_action_sim_info=None, **kwargs): super().__init__(*args, **kwargs) self.away_action = away_action self.away_action_sim_info = away_action_sim_info @classmethod def _test(cls,
if minutes_remaining < self.CONTINUE_SHOPPING_THRESHOLD: return if self.role_state_browse is not None: return _BrowseState() return _LoiterState() def _set_shop_duration(self): shop_time = random.randint(self.total_shop_time_min, self.total_shop_time_max) shop_time *= self._total_shop_time_multiplier self.change_duration(shop_time) lock_instance_tunables(RetailCustomerSituation, exclusivity=situations.bouncer.bouncer_types. BouncerExclusivityCategory.NORMAL, creation_ui_option=situations.situation_types. SituationCreationUIOption.NOT_AVAILABLE, duration=0) class _GoToStoreState(SituationState): def on_activate(self, reader=None): super().on_activate(reader) for custom_key in self.owner.go_to_store_interaction.custom_keys_gen(): self._test_event_register(TestEvent.InteractionComplete, custom_key) self.owner._set_job_role_state(self.owner.customer_job, self.owner.role_state_go_to_store) def handle_event(self, sim_info, event, resolver): if not self.owner.validate_customer(sim_info):
neighbor = random.choice(neighbor_results) guest_list = SituationGuestList( invite_only=True, host_sim_id=neighbor.sim_info.sim_id, filter_requesting_sim_id=active_sim_info.sim_id) guest_list.add_guest_info( SituationGuestInfo(neighbor.sim_info.sim_id, cls.neighbor_job_and_default_role_state.job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP, expectation_preference=True)) return guest_list def start_situation(self): super().start_situation() self._change_state(self._ring_doorbell_state()) def _issue_requests(self): super()._issue_requests() request = SelectableSimRequestFactory( self, callback_data=_RequestUserData(), job_type=self.player_sim_job_and_default_role_state.job, exclusivity=self.exclusivity) self.manager.bouncer.submit_request(request) lock_instance_tunables( NeighborHangoutSituation, exclusivity=BouncerExclusivityCategory.NORMAL, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE)
def sim_of_interest(self, sim_info): if self._contestant_sim is not None and self._contestant_sim.sim_info is sim_info: return True return False def start_turn(self): self._change_state(self.take_turn_state()) def on_turn_finished(self): self._change_state(self.wait_for_turn_state()) services.venue_service().get_zone_director().select_next_contestant() lock_instance_tunables( OpenMicContestant, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, duration=0, _implies_greeted_status=False) class PlayerSituationState(CommonInteractionCompletedSituationState): def _on_interaction_of_interest_complete(self, sim_info=None, **kwargs): if sim_info is None: return services.venue_service().get_zone_director().request_player_turn( sim_info) class OpenMicPlayerControllerSituation(SituationComplexCommon): INSTANCE_TUNABLES = { 'situation_state':
class SimBackgroundSituation(situations.situation_complex.SituationComplexCommon): INSTANCE_TUNABLES = {'job_and_role_state': TunableSituationJobAndRoleState(description='\n The job and role state for the sims\n ')} REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES @classproperty def situation_serialization_option(cls): return SituationSerializationOption.DONT @classmethod def _states(cls): return (SituationStateData(1, _SimBackgroundSituationMainState),) @classmethod def _get_tuned_job_and_default_role_state_tuples(cls): return [(cls.job_and_role_state.job, cls.job_and_role_state.role_state)] @classmethod def default_job(cls): pass def start_situation(self): super().start_situation() self._change_state(_SimBackgroundSituationMainState()) def _issue_requests(self): request = BouncerRequestFactory(self, callback_data=_RequestUserData(role_state_type=self.job_and_role_state.role_state), job_type=self.job_and_role_state.job, request_priority=BouncerRequestPriority.BACKGROUND_LOW, user_facing=False, exclusivity=self.exclusivity) self.manager.bouncer.submit_request(request) lock_instance_tunables(SimBackgroundSituation, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, _implies_greeted_status=False)
if result: self._restore_crate() self._pet_crate_x = None self._pet_crate_y = None self._pet_crate_z = None return result def _restore_crate(self): if self._pet_crate_x is None: return obj = create_object(self.pet_crate_object_definition) if obj is None: return position = sims4.math.Vector3(float(self._pet_crate_x), float(self._pet_crate_y), float(self._pet_crate_z)) starting_location = placement.create_starting_location( position=position) fgl_context = placement.create_fgl_context_for_object( starting_location, obj, ignored_object_ids=(obj.id, )) (position, orientation) = placement.find_good_location(fgl_context) if position is not None and orientation is not None: obj.move_to(translation=position, orientation=orientation) else: obj.destroy() lock_instance_tunables( SituationComplexAdoptionPet, exclusivity=BouncerExclusivityCategory.NORMAL, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE)
super().__init__(choice_enumeration_strategy=StatePickerEnumerationStrategy(), *args, **kwargs) def _run_interaction_gen(self, timeline): self._choice_enumeration_strategy.build_choice_list(self, self.state) chosen_state = self._choice_enumeration_strategy.find_best_choice(self) if chosen_state is None: logger.error('{} fail to find a valid chosen state value for state {}'.format(self.__class__.__name__, self.state)) return False chosen_state.activate_channel(interaction=self, push_affordances=self.push_additional_affordances) return True @classmethod def _test(cls, target, context, **kwargs): test_result = super()._test(target, context, **kwargs) if not test_result: return test_result if not StatePickerEnumerationStrategy.has_valid_choice(target, context, state=cls.state): return TestResult(False, 'No valid choice in State Picker Enumeration Strategy.') return TestResult.TRUE class WatchCurrentChannelAutonomouslySuperInteraction(SuperInteraction): __qualname__ = 'WatchCurrentChannelAutonomouslySuperInteraction' INSTANCE_TUNABLES = {'state': objects.components.state.TunableStateTypeReference(description='The state used to populate the picker.')} def _run_interaction_gen(self, timeline): current_state = self.target.get_state(self.state) current_state.activate_channel(interaction=self, push_affordances=True) return True lock_instance_tunables(AutonomousPickerSuperInteraction, allow_user_directed=False, basic_reserve_object=None, disable_transitions=True)
return cls.cafe_generic_job.job def _on_set_sim_job(self, sim, job_type): super()._on_set_sim_job(sim, job_type) self._cafe_sim = sim def start_situation(self): super().start_situation() self._change_state(self.pre_order_coffee_state()) def sim_of_interest(self, sim_info): if self._cafe_sim is not None and self._cafe_sim.sim_info is sim_info: return True return False lock_instance_tunables(CafeGenericCustomerSituation, exclusivity=BouncerExclusivityCategory.NORMAL, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, duration=0, _implies_greeted_status=False) class _CafeGenericState(SituationState): pass class CafeGenericBackgroundSituation(SituationComplexCommon): INSTANCE_TUNABLES = {'generic_sim_job': TunableSituationJobAndRoleState(description="\n A job and role state that essentially does nothing but filter out\n Sims that shouldn't be placed in the generic cafe sim situation.\n "), 'cafe_generic_customer_situation': Situation.TunableReference(description='\n The individual, generic cafe customer situation we want to use for\n Sims that show up at the Cafe so they can go get coffee.\n ', class_restrictions=('CafeGenericCustomerSituation',))} REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES @classmethod def _states(cls): return (SituationStateData(1, _CafeGenericState),) @classmethod def _get_tuned_job_and_default_role_state_tuples(cls): return [(cls.generic_sim_job.job, cls.generic_sim_job.role_state)]
def role_affordance_target(self): target = services.object_manager().get(self._crafted_object_id) if target is None: target = services.current_zone().inventory_manager.get(self._crafted_object_id) return target def _get_start_work_test(self): if self.start_work_test_and_state is not None: start_work_test = self.start_work_test_and_state.enter_state_test if start_work_test.affordances or start_work_test.tags: return start_work_test def _get_role_state_overrides(self, sim, job_type, role_state_type, role_affordance_target): return (role_state_type, self.role_affordance_target) lock_instance_tunables(ServiceNpcSituation, creation_ui_option=SituationCreationUIOption.NOT_AVAILABLE, NPC_hosted_situation_player_job=None, venue_situation_player_job=None) class ServiceNpcBaseSituationState(SituationState): __qualname__ = 'ServiceNpcBaseSituationState' def on_activate(self, reader): super().on_activate(reader) self._test_event_register(event_testing.test_events.TestEvent.InteractionComplete) self._test_event_register(event_testing.test_events.TestEvent.InteractionStart) def handle_event(self, sim_info, event, resolver): pass class ArrivingOnLotSituationState(SituationState): __qualname__ = 'ArrivingOnLotSituationState'