def _build_outer_elements(self, sequence): sim_info = self._get_sim_info() if sim_info is None: return self._action = self.action(sim_info) if not self._action.can_execute(): return is_baby_age_up = self.interaction.interaction_parameters.get( 'is_baby_age_up', False) if is_baby_age_up or self._action.is_baby_age_up(): sequence = self._build_baby_age_up_sequence( sim_info, sequence, is_external=is_baby_age_up) lock_handle = None def _lock_save_for_aging(_): nonlocal lock_handle if is_baby_age_up or not sim_info.is_npc: class _AgeUpSaveLockHandle: def get_lock_save_reason(self): return AgingTuning.AGING_SAVE_LOCK_TOOLTIP(sim_info) lock_handle = _AgeUpSaveLockHandle() services.get_persistence_service().lock_save(lock_handle) def _unlock_save_for_aging(_): if lock_handle is not None: services.get_persistence_service().unlock_save(lock_handle) sequence = build_critical_section_with_finally(_lock_save_for_aging, sequence, _unlock_save_for_aging) return sequence
def _run(self, timeline): if self._target.is_terrain: start = self.start_one_shot stop = lambda *args, **kwargs: None else: start = self.start stop = self.stop if self.offset_time is None: sequence = build_critical_section_with_finally( start, self._sequence, stop) else: sequence = build_delayed_element( self._sequence, clock.interval_in_sim_minutes(self.offset_time), start) sequence = build_critical_section_with_finally(sequence, stop) return timeline.run_child(sequence)
def build_basic_elements(self, sequence=()): sequence = super().build_basic_elements(sequence=sequence) for sim in self.required_sims(): for social_group in sim.get_groups_for_sim_gen(): sequence = social_group.with_social_focus( self.sim, social_group._group_leader, (sim, ), sequence) suspended_modifiers_dict = self._generate_suspended_modifiers_dict() if gsi_handlers.interaction_archive_handlers.is_archive_enabled(self): start_time = services.time_service().sim_now else: start_time = None def interaction_start(_): self._suspend_modifiers(suspended_modifiers_dict) self.apply_interaction_cost() performance.counters.add_counter('PerfNumSubInteractions', 1) self._add_interaction_to_targets() if gsi_handlers.interaction_archive_handlers.is_archive_enabled( self): gsi_handlers.interaction_archive_handlers.archive_interaction( self.sim, self, 'Start') def interaction_end(_): if start_time is not None: self.duration = (services.time_service().sim_now - start_time).in_minutes() self._remove_interaction_from_targets() self.sim.update_last_used_interaction(self) self._resume_modifiers(suspended_modifiers_dict) return build_critical_section_with_finally(interaction_start, sequence, interaction_end)
def _build_outcome_sequence(self, *args, **kwargs): sequence = super()._build_outcome_sequence(*args, **kwargs) pregnancy_tracker = self.sim.sim_info.pregnancy_tracker return element_utils.must_run( element_utils.build_critical_section_with_finally( self._name_and_create_babies_gen, sequence, lambda _: pregnancy_tracker.clear_pregnancy()))
def maybe_do_transition(timeline): if not use_posture_animations and not exited_carry: event_handler_exit_carry(None) if callback is not None: callback() if use_posture_animations or exited_carry: interaction_target_was_target = False si_target_was_target = False if interaction.target == target: interaction_target_was_target = True interaction.set_target(None) if old_carry_posture.target_is_transient and si.target == target: si_target_was_target = True si.set_target(None) if carry_system_target is not None: old_carry_posture.carry_system_target = carry_system_target def do_transition(timeline): result = yield element_utils.run_child(timeline, transition) if result: interaction_target_was_target = False si_target_was_target = False new_posture.source_interaction = None return True return False def post_transition(_): if interaction_target_was_target: interaction.set_target(target) if si_target_was_target: si.set_target(target) if carry_system_target is not None: old_carry_posture.carry_system_target = None yield element_utils.run_child(timeline, must_run(build_critical_section_with_finally(do_transition, post_transition)))
def build_basic_content(self, sequence, **kwargs): sequence = super(SuperInteraction, self).build_basic_content(sequence, **kwargs) def change_cancelable_for_target_si(cancelable): if self._target_si is not None: target_si = self._target_si[0] target_si._cancelable_by_user = cancelable target_si.sim.ui_manager.update_interaction_cancel_status( target_si) def unparent_carried_sim(*_, **__): sim = self.carry_target or self.target routing_surface = sim.routing_surface new_location = sim.location.clone(parent=None, routing_surface=routing_surface) sim.set_location_without_distribution(new_location) sim.update_intended_position_on_active_lot(update_ui=True) carry_system_target = self._get_carry_system_target( unparent_carried_sim) target_si_cancelable = self._target_si[0]._cancelable_by_user sequence = exit_carry_while_holding( self, use_posture_animations=True, carry_system_target=carry_system_target, sequence=sequence) sequence = build_critical_section_with_finally( lambda _: change_cancelable_for_target_si(False), sequence, lambda _: change_cancelable_for_target_si(target_si_cancelable)) return sequence
def factory(interaction, game, ensure_setup, sequence=()): def join_game(interaction, game, ensure_setup): sim = interaction.sim if sim is not None: (target_game, _) = get_game_references(interaction) if target_game is not None: if target_game.current_game is None: target_game.set_current_game(game) if target_game.current_game is game: target_game.add_player(sim) target_game.take_turn() if ensure_setup: target_game.setup_game() def leave_game(interaction): sim = interaction.sim if sim is not None: (target_game, _) = get_game_references(interaction) if target_game is not None: target_game.remove_player(sim) if game is None: return sequence sequence = build_critical_section_with_finally( lambda _: join_game(interaction, game, ensure_setup), sequence, lambda _: leave_game(interaction)) return sequence
def create(self, *args): reservation_handler = None def _create(_): nonlocal reservation_handler self._object = self.create_object() if self._object is None: return False if self.sim is not None and self._reserver is not None: reservation_handler = self.object.get_reservation_handler(self.sim, reservation_interaction=self._reserver) reservation_handler.begin_reservation() self._reserver.map_create_target(self.object) return True def _cleanup(_): if self._object is not None: if reservation_handler is not None: reservation_handler.end_reservation() if not self._claimed: current_zone = services.current_zone() if current_zone is not None and not current_zone.is_zone_shutting_down: self._object.destroy(source=self.sim, cause="Created object wasn't claimed.") self._object = None self._object_cleaned_up = True return build_critical_section_with_finally(_create, args, _cleanup)
def _build_outcome_sequence(self): def end(_): if self.outcome_result == interactions.utils.outcome_enums.OutcomeResult.SUCCESS: self._show_success_notification() sequence = super()._build_outcome_sequence() return element_utils.build_critical_section_with_finally(sequence, end)
def factory(interaction, game, ensure_setup, sequence=()): def join_game(interaction, game, ensure_setup): sim = interaction.sim if sim is not None: (target_game, _) = get_game_references(interaction) if target_game is not None: if target_game.current_game is None: target_game.set_current_game(game) if target_game.current_game is game: target_game.add_player(sim) target_game.take_turn() if ensure_setup: target_game.setup_game() def leave_game(interaction): sim = interaction.sim if sim is not None: (target_game, _) = get_game_references(interaction) if target_game is not None: target_game.remove_player(sim) if game is None: return sequence sequence = build_critical_section_with_finally(lambda _: join_game(interaction, game, ensure_setup), sequence, lambda _: leave_game(interaction)) return sequence
def build_basic_elements(self, sequence=()): sequence = super().build_basic_elements(sequence=sequence) for sim in self.required_sims(): for social_group in sim.get_groups_for_sim_gen(): sequence = social_group.with_social_focus(self.sim, social_group._group_leader, (sim,), sequence) suspended_modifiers_dict = self._generate_suspended_modifiers_dict() if gsi_handlers.interaction_archive_handlers.is_archive_enabled(self): start_time = services.time_service().sim_now else: start_time = None def interaction_start(_): self._suspend_modifiers(suspended_modifiers_dict) self.apply_interaction_cost() performance.counters.add_counter('PerfNumSubInteractions', 1) self._add_interaction_to_targets() if gsi_handlers.interaction_archive_handlers.is_archive_enabled(self): gsi_handlers.interaction_archive_handlers.archive_interaction(self.sim, self, 'Start') def interaction_end(_): if start_time is not None: game_clock_service = services.game_clock_service() if game_clock_service is not None: self.duration = (game_clock_service.now() - start_time).in_minutes() self._remove_interaction_from_targets() self.sim.update_last_used_mixer(self) if self._plumbbob_sheen_event_handle is not None: self._plumbbob_sheen_event_handle.release() self._plumbbob_sheen_event_handle = None self._resume_modifiers(suspended_modifiers_dict) self._plumbbob_sheen_event_handle = self.animation_context.register_event_handler(self._outcome_xevt_callback, handler_id=SCRIPT_EVENT_ID_PLUMBBOB_SHEEN) return build_critical_section_with_finally(interaction_start, sequence, interaction_end)
def with_reslot_plumbbob(interaction, bone_name, offset, target, balloon_offset, sequence=None): sim = interaction.sim subject = interaction.get_participant(target) logger.assert_raise( subject is not None, 'Interaction {} has no target {}, but is trying to reslot the plumbbob to {}' .format(interaction, target, bone_name), owner='nbaker') subject_suffix = subject.part_suffix if subject_suffix is not None: bone_name += subject_suffix distributor = Distributor.instance() def reslot(_): reslot_op = ReslotPlumbbob(sim.id, subject.id, bone_name, offset, balloon_offset=balloon_offset) distributor.add_op(sim, reslot_op) def unslot(_): unslot_plumbbob(sim) return build_critical_section_with_finally(reslot, sequence, unslot)
def get_auto_exit(actors, asm=None, interaction=None, required_actors=()): arb_exit = None contexts_to_release_all = [] for actor in actors: if actor.is_sim: if actor.asm_auto_exit.asm is not None: asm_to_exit = actor.asm_auto_exit.asm[0] if asm_to_exit is asm: continue if required_actors: asm_actors = set(asm_to_exit.actors_gen()) if not all(a in asm_actors for a in required_actors): continue else: if arb_exit is None: arb_exit = animation.arb.Arb() if interaction is not None: if gsi_handlers.interaction_archive_handlers.is_archive_enabled(interaction): prev_state = asm_to_exit.current_state try: asm_to_exit.request('exit', arb_exit, debug_context=(interaction, asm)) finally: if gsi_handlers.interaction_archive_handlers.is_archive_enabled(interaction): gsi_handlers.interaction_archive_handlers.add_animation_data(interaction, asm_to_exit, prev_state, 'exit', 'arb_exit is empty' if arb_exit.empty else arb_exit.get_contents_as_string()) contexts_to_release = release_auto_exit(actor) contexts_to_release_all.extend(contexts_to_release) release_contexts_fn = get_release_contexts_fn(contexts_to_release_all, AUTO_EXIT_REF_TAG) if arb_exit is not None and not arb_exit.empty: element = build_critical_section_with_finally(build_critical_section(create_run_animation(arb_exit), flush_all_animations), release_contexts_fn) return must_run(element) elif contexts_to_release_all: return must_run(build_element(release_contexts_fn))
def build_basic_content(self, sequence=(), **kwargs): self.store_event_handler(self._play_music_track, self.audio_start_event) self.store_event_handler(self._stop_music_track, self.audio_stop_event) sequence = super().build_basic_content(sequence, **kwargs) return build_critical_section_with_finally(sequence, self._stop_music_track)
def retarget_interaction(interaction, target, *args): if interaction is not None: interaction_retarget_handler = InteractionRetargetHandler( interaction, target) return build_critical_section_with_finally( interaction_retarget_handler.begin, args, interaction_retarget_handler.end) return args
def build_basic_content(self, sequence=(), **kwargs): self.store_event_handler(self._create_sound_alarm, self.audio_start_event) self.store_event_handler(self._cancel_sound_alarm, self.audio_stop_event) sequence = super().build_basic_content(sequence, **kwargs) return build_critical_section_with_finally( sequence, self._cancel_sound_alarm_no_data)
def maybe_do_transition(timeline): def push_si(_): context = InteractionContext(sim, InteractionContext.SOURCE_POSTURE_GRAPH, si.priority, run_priority=si.run_priority, insert_strategy=QueueInsertStrategy.NEXT, must_run_next=True, group_id=si.group_id) result = final_source_aop.interaction_factory(context) if not result: return result final_source_interaction = result.interaction si.acquire_posture_ownership(final_posture) yield final_source_interaction.run_direct_gen(timeline) final_posture.source_interaction = final_source_interaction return result if not got_callback: event_handler_swap_carry(None) if callback is not None: callback() if original_carry_posture.target_is_transient: if interaction.target == original_carry_target: interaction_target_was_target = True interaction.set_target(None) else: interaction_target_was_target = False if si.target == original_carry_target: si_target_was_target = True si.set_target(None) else: si_target_was_target = False else: interaction_target_was_target = False si_target_was_target = False if carry_system_target is not None: original_carry_posture.carry_system_target = carry_system_target def do_transition(timeline): nonlocal interaction_target_was_target, si_target_was_target result = yield element_utils.run_child(timeline, transition_to_carry_nothing) if not result: return False interaction_target_was_target = False si_target_was_target = False carry_nothing_posture.source_interaction = None return True def post_transition(_): if interaction_target_was_target: interaction.set_target(original_carry_target) if si_target_was_target: si.set_target(original_carry_target) if carry_system_target is not None: original_carry_posture.carry_system_target = None exit_carry_result = yield element_utils.run_child(timeline, must_run(build_critical_section_with_finally(do_transition, post_transition))) if not (got_callback and exit_carry_result): raise RuntimeError('[maxr] Failed to exit carry: {}'.format(original_carry_posture)) if got_callback: context = si.context.clone_for_sim(sim) yield element_utils.run_child(timeline, (PostureTransition(final_posture, final_posture_state, context, final_var_map), push_si))
def with_walkstyle(sim, walkstyle, uid, sequence=None, priority=DEFAULT_WALKSTYLE_OVERRIDE_PRIORITY): def request_walkstyle(element): sim.request_walkstyle(WalkStyleRequest(priority, walkstyle), uid) def unrequest_walkstyle(element): sim.remove_walkstyle(uid) return build_critical_section_with_finally(request_walkstyle, sequence, unrequest_walkstyle)
def interact_with_carried_object(sim, target, posture_state=DEFAULT, interaction=None, create_target_track=None, animation_context=None, must_run=False, sequence=()): if interaction is not None: if interaction.staging and sim.posture_state.is_source_or_owning_interaction( interaction): return sequence if interaction.disable_carry_interaction_mask: return sequence is_carrying_other_object = False animation_contexts = set() target_ref = target.ref() if must_run or target is not None else None def maybe_do_begin(_): nonlocal posture_state, is_carrying_other_object if posture_state is DEFAULT: posture_state = sim.posture_state try: resolved_target = target_ref() if target_ref is not None else None if create_target_track is None: target_track = posture_state.get_carry_track(resolved_target) if target_track is None: return other_carry = posture_state.get_other_carry_posture( resolved_target) if other_carry is None or other_carry.holstered: return else: other_carry = posture_state.right if create_target_track == PostureTrack.LEFT else posture_state.left if other_carry.target is None: return finally: del posture_state is_carrying_other_object = True if animation_context is not None: animation_contexts.add(animation_context) if interaction is not None: animation_contexts.add(interaction.animation_context) sim.asm_auto_exit.apply_carry_interaction_mask += 1 for context in animation_contexts: context.apply_carry_interaction_mask.append('x') def maybe_do_end(_): if not is_carrying_other_object: return sim.asm_auto_exit.apply_carry_interaction_mask -= 1 for context in animation_contexts: context.apply_carry_interaction_mask.remove('x') return build_critical_section_with_finally(maybe_do_begin, sequence, maybe_do_end)
def set_sim_sleeping(interaction, sequence=None): sim = interaction.sim def set_sleeping(_): sim.sleeping = True def set_awake(_): sim.sleeping = False return build_critical_section_with_finally(set_sleeping, sequence, set_awake)
def _run(self, timeline): sequence = self.sequence if self.start_outfit_change_and_index is not None: start_change = build_critical_section(self.subject_sim_outfits.get_change_outfit_element(self.start_outfit_change_and_index, do_spin=True), flush_all_animations) sequence = build_critical_section(start_change, sequence) if self.end_outfit_change_and_index is not None: end_change = build_critical_section(self.subject_sim_outfits.get_change_outfit_element(self.end_outfit_change_and_index, do_spin=True), flush_all_animations) end_change_varification = lambda _: self.subject_sim_outfits.exit_change_verification(self.end_outfit_change_and_index) sequence = build_critical_section(sequence, end_change) sequence = build_critical_section_with_finally(sequence, end_change_varification) return timeline.run_child(sequence)
def with_skill_bar_suppression(self, sequence=()): def _start_suppression(_): self._ui_skill_bar_suppression_count += 1 def _end_suppression(_): self._ui_skill_bar_suppression_count -= 1 sequence = build_critical_section_with_finally(_start_suppression, sequence, _end_suppression) return sequence
def _factory(interaction, relationship_bits_begin, relationship_bits_end, sequence=()): def begin(_): relationship_bits_begin.apply_to_resolver( interaction.get_resolver()) def end(_): relationship_bits_end.apply_to_resolver(interaction.get_resolver()) return build_critical_section_with_finally(begin, sequence, end)
def factory(interaction, subject, tag_name, effect_name, sequence=(), **kwargs): target = interaction.get_participant(subject) audio_effect_data = AudioEffectData(effect_name) if target is not None: def start(*_, **__): target.append_audio_effect(tag_name, audio_effect_data) def stop(*_, **__): target.remove_audio_effect(tag_name) return build_critical_section_with_finally(start, sequence, stop)
def _build_outcome_sequence(self): succeeded = self._is_successful_catch() object_to_create = None outcome_type = self.OUTCOME_TYPE_OTHER outcome_actions = self.CATCH_NOTHING_OUTCOME_ACTIONS prop_override = None if succeeded: fishing_data = self.super_interaction._get_fishing_data_from_target( ) weighted_outcomes = [ (fishing_data.weight_fish, self.CATCH_FISH_OUTCOME_ACTIONS), (fishing_data.weight_junk, self.CATCH_JUNK_OUTCOME_ACTIONS), (fishing_data.weight_treasure, self.CATCH_TREASURE_OUTCOME_ACTIONS) ] outcome_actions = sims4.random.weighted_random_item( weighted_outcomes) if outcome_actions is self.CATCH_JUNK_OUTCOME_ACTIONS: prop_override = self._get_random_junk() else: if outcome_actions is self.CATCH_TREASURE_OUTCOME_ACTIONS: object_to_create = fishing_data.choose_treasure() prop_override = self.TREASURE_PROP_OBJECT outcome_type = self.OUTCOME_TYPE_TREASURE else: object_to_create = fishing_data.choose_fish( self.get_resolver()) prop_override = object_to_create if object_to_create is not None: outcome_type = self.OUTCOME_TYPE_FISH if not object_to_create: outcome_actions = self.CATCH_NOTHING_OUTCOME_ACTIONS outcome = FishingLocationCatchOutcome(outcome_actions, prop_override) def end(_): sim = self.sim if object_to_create is not None and sim.is_selectable: obj = objects.system.create_object(object_to_create) if outcome_type == self.OUTCOME_TYPE_FISH: obj.initialize_fish(sim) self._apply_caught_fish_buff(obj) self._show_catch_fish_notification(sim, obj) self.super_interaction.kill_and_try_reapply_bait() elif outcome_type == self.OUTCOME_TYPE_TREASURE: self._show_catch_treasure_notification(sim, obj) obj.update_ownership(sim) if sim.inventory_component.can_add(obj): sim.inventory_component.player_try_add_object(obj) else: build_buy.move_object_to_household_inventory(obj) return element_utils.build_critical_section_with_finally( outcome.build_elements(self), end)
def get_visual_effect_sequence(self, vfx_element, sequence): got_callback = False def callback(*_, **__): nonlocal got_callback if got_callback: return got_callback = True vfx_element._stop_vfx() vfx_element.interaction.store_event_handler(callback, handler_id=self.event) return build_critical_section_with_finally(sequence, callback)
def _factory(interaction, stat, subject, amount, sequence=None): target = interaction.get_participant(subject) if target is not None: tracker = target.get_tracker(stat) def begin(_): tracker.add_value(stat, amount) def end(_): tracker.add_value(stat, -amount) return build_critical_section_with_finally(begin, sequence, end) return sequence
def build_basic_elements(self, sequence=()): career = self.get_career() career_level = career.current_level_tuning() if career_level.fame_moment is not None and self._should_run_fame_moment( career, career_level): self._start_fame_moment(career, career_level.fame_moment) if career.scholarship_info_loot is not None and not career.seen_scholarship_info: self._start_scholarship_info_loot(career, career.scholarship_info_loot) sequence = super().build_basic_elements(sequence=sequence) sequence = build_critical_section_with_finally(sequence, self.interaction_end) return sequence
def _run_gen(self, timeline): def begin(_): zone = services.current_zone() lot_id = 0 if not self.attach_to_active_lot else zone.lot.lot_id self.spawn_point = DynamicInteractionSpawnPoint(self.interaction, self.participant, self.distance_to_participant, self.tags, lot_id=lot_id, zone_id=zone.id) services.current_zone().add_dynamic_spawn_point(self.spawn_point) def end(_): services.current_zone().remove_dynamic_spawn_point(self.spawn_point) self.spawn_point = None result = yield element_utils.run_child(timeline, build_critical_section_with_finally(begin, self.sequence, end)) return result
def _with_censor_grid_gen(timeline): if self._posture.censor_level is not None: def _add_censor(timeline): self._posture_censor_handle = sim.censorgrid_component.add_censor(self._posture.censor_level) def _remove_censor(timeline): sim.censorgrid_component.remove_censor(self._posture_censor_handle) child_sequence = element_utils.build_critical_section_with_finally(_add_censor, sequence, _remove_censor) else: child_sequence = sequence result = yield element_utils.run_child(timeline, child_sequence) return result
def _build_outcome_sequence(self, *args, **kwargs): sequence = super()._build_outcome_sequence(*args, **kwargs) social_group = self.social_group if social_group is not None: def _surpress_social_group_update(_): social_group.suppress_social_group_update_message = True def _send_social_group_update(_): social_group.suppress_social_group_update_message = False social_group.on_social_context_changed() sequence = build_critical_section_with_finally( _surpress_social_group_update, sequence, _send_social_group_update) return sequence
def _build_stat_sequence(self, participant, modifier, sequence): handle = None participant_ref = weakref.ref(participant) def _begin(_): nonlocal handle handle = participant.add_statistic_modifier(modifier, True) def _end(_): if handle: participant_deref = participant_ref() if participant_deref is not None: return participant_deref.remove_statistic_modifier(handle) return build_critical_section_with_finally(_begin, sequence, _end)
def _run(self, timeline): def begin(_): for obj in self.parent_object.children_recursive_gen(): if self.fade_objects_on_ground or obj.position.y == self.parent_object.position.y: pass opacity = obj.opacity self.hidden_objects[obj] = opacity obj.fade_opacity(self.opacity, self.fade_duration) def end(_): for (obj, opacity) in self.hidden_objects.items(): obj.fade_opacity(opacity, self.fade_duration) return timeline.run_child(build_critical_section_with_finally(begin, self.sequence, end))
def _run(self, timeline): def begin(_): for obj in self.parent_object.children_recursive_gen(): if not self.fade_objects_on_ground and obj.position.y == self.parent_object.position.y: continue opacity = obj.opacity self.hidden_objects[obj] = opacity obj.fade_opacity(self.opacity, self.fade_duration) def end(_): for (obj, opacity) in self.hidden_objects.items(): obj.fade_opacity(opacity, self.fade_duration) return timeline.run_child( build_critical_section_with_finally(begin, self.sequence, end))
def factory(interaction, sequence=()): interaction = interaction old_target = interaction.target def set_new_target(): (game, _) = get_game_references(interaction) if game is None: return new_target = game.get_game_target(actor_sim=interaction.sim) if new_target is not None: interaction.set_target(new_target) def revert_target(): interaction.set_target(old_target) sequence = build_critical_section_with_finally(lambda _: set_new_target(), sequence, lambda _: revert_target()) return sequence
def with_reslot_plumbbob(interaction, bone_name, offset, sequence=None): sim = interaction.sim target = interaction.target target_suffix = target.part_suffix if target_suffix is not None: bone_name += target_suffix distributor = Distributor.instance() def reslot(_): reslot_op = ReslotPlumbbob(sim.id, target.id, bone_name, offset) distributor.add_op(sim, reslot_op) def unslot(_): reslot_op = ReslotPlumbbob(sim.id, 0, None, sims4.math.Vector3.ZERO()) distributor.add_op(sim, reslot_op) return build_critical_section_with_finally(reslot, sequence, unslot)
def _with_censor_grid_gen(timeline): if self._posture.censor_level is not None: def _add_censor(timeline): self._posture_censor_handle = sim.censorgrid_component.add_censor( self._posture.censor_level) def _remove_censor(timeline): sim.censorgrid_component.remove_censor( self._posture_censor_handle) child_sequence = element_utils.build_critical_section_with_finally( _add_censor, sequence, _remove_censor) else: child_sequence = sequence result = yield element_utils.run_child(timeline, child_sequence) return result
def create(self, *args): def _create(_): self._object = create_object(self.def_id, **self.create_kwargs) if self._object is None: return False if self.sim is not None and self._reserver is not None: self.object.reserve(self.sim, self._reserver) return True def _cleanup(_): if self.sim is not None and self._reserver is not None: self._object.release(self.sim, self._reserver) if not (self._object is not None and self._claimed): self._object.destroy(source=self.sim, cause="Created object wasn't claimed.") self._object = None return build_critical_section_with_finally(_create, args, _cleanup)
def _build_outcome_sequence(self): succeeded = self._is_successful_catch() object_to_create = None outcome_type = self.OUTCOME_TYPE_OTHER outcome_actions = self.CATCH_NOTHING_OUTCOME_ACTIONS prop_override = None if succeeded: fishing_data = self.super_interaction._get_fishing_data_from_target() weighted_outcomes = [(fishing_data.weight_fish, self.CATCH_FISH_OUTCOME_ACTIONS), (fishing_data.weight_junk, self.CATCH_JUNK_OUTCOME_ACTIONS), (fishing_data.weight_treasure, self.CATCH_TREASURE_OUTCOME_ACTIONS)] outcome_actions = sims4.random.weighted_random_item(weighted_outcomes) if outcome_actions is self.CATCH_JUNK_OUTCOME_ACTIONS: prop_override = self._get_random_junk() else: if outcome_actions is self.CATCH_TREASURE_OUTCOME_ACTIONS: object_to_create = fishing_data.choose_treasure() prop_override = self.TREASURE_PROP_OBJECT outcome_type = self.OUTCOME_TYPE_TREASURE else: object_to_create = fishing_data.choose_fish(self.get_resolver()) prop_override = object_to_create if object_to_create is not None: outcome_type = self.OUTCOME_TYPE_FISH if not object_to_create: outcome_actions = self.CATCH_NOTHING_OUTCOME_ACTIONS outcome = FishingLocationCatchOutcome(outcome_actions, prop_override) def end(_): sim = self.sim if object_to_create is not None and sim.is_selectable: obj = objects.system.create_object(object_to_create) if outcome_type == self.OUTCOME_TYPE_FISH: obj.initialize_fish(sim) self._apply_caught_fish_buff(obj) self._show_catch_fish_notification(sim, obj) self.super_interaction.kill_and_try_reapply_bait() elif outcome_type == self.OUTCOME_TYPE_TREASURE: self._show_catch_treasure_notification(sim, obj) obj.update_ownership(sim) if sim.inventory_component.can_add(obj): sim.inventory_component.player_try_add_object(obj) else: build_buy.move_object_to_household_inventory(obj) return element_utils.build_critical_section_with_finally(outcome.build_elements(self), end)
def factory(interaction, toggles, sequence=(), **kwargs): target = interaction.target if target is None: logger.error('Attempt to toggle a footprint with no target') return sequence footprint_comp = target.get_component(FOOTPRINT_COMPONENT) if footprint_comp is None: logger.error('Attempt to toggle a footprint on a target ({}) with no footprint component.', target, owner='mduke') return sequence def start(*_, **__): for toggle in toggles: footprint_comp.start_toggle_footprint(toggle) def stop(*_, **__): for toggle in toggles: footprint_comp.stop_toggle_footprint(toggle) return build_critical_section_with_finally(start, sequence, stop)
def interact_with_carried_object(sim, target, posture_state=DEFAULT, interaction=None, create_target_track=None, animation_context=None, must_run=False, sequence=()): if interaction.staging and sim.posture_state.is_source_or_owning_interaction(interaction): return sequence if not must_run and interaction is not None and interaction.disable_carry_interaction_mask: return sequence is_carrying_other_object = False animation_contexts = set() target_ref = target.ref() if target is not None else None def maybe_do_begin(_): nonlocal posture_state, is_carrying_other_object if posture_state is DEFAULT: posture_state = sim.posture_state try: resolved_target = target_ref() if target_ref is not None else None if create_target_track is None: target_track = posture_state.get_carry_track(resolved_target) if target_track is None: return other_carry = posture_state.get_other_carry_posture(resolved_target) if other_carry is None or other_carry.holstered: return else: other_carry = posture_state.right if create_target_track == PostureTrack.LEFT else posture_state.left if other_carry.target is None: return finally: del posture_state is_carrying_other_object = True if animation_context is not None: animation_contexts.add(animation_context) if interaction is not None: animation_contexts.add(interaction.animation_context) for context in animation_contexts: context.apply_carry_interaction_mask.append('x') def maybe_do_end(_): if not is_carrying_other_object: return for context in animation_contexts: context.apply_carry_interaction_mask.remove('x') return build_critical_section_with_finally(maybe_do_begin, sequence, maybe_do_end)
def factory(interaction, timeout=10, memory_uid=0, sequence=()): def trigger_memory_on(interaction): sim = interaction.sim send_memory_trigger_update(sim=sim, trigger_memory=True, timeout_time=timeout, memory_uid=memory_uid) def trigger_memory_off(interaction): sim = interaction.sim send_memory_trigger_update(sim=sim, trigger_memory=False, timeout_time=0, memory_uid=memory_uid) sequence = build_critical_section_with_finally( lambda _: trigger_memory_on(interaction), sequence, lambda _: trigger_memory_off(interaction)) return sequence
def _get_behavior(self): posture = self._posture sim = posture.sim multi_sim_posture_transition = posture.multi_sim and not posture.is_puppet prev_posture_state = sim.posture_state self._prev_posture = prev_posture_state.get_aspect(posture.track) animate_in = None if multi_sim_posture_transition or self._animate_in is not None and not self._animate_in.empty: animate_in = create_run_animation(self._animate_in) my_stage = self._stage() def posture_change(timeline): posture.log_info('Change', msg='{}'.format(posture.track.name if posture.track is not None else 'NO TRACK!')) prev_posture_state = sim.posture_state prev_posture = prev_posture_state.get_aspect(posture.track) sim.posture_state = self._dest_state sim.on_posture_event(PostureEvent.POSTURE_CHANGED, self._dest_state, posture.track, prev_posture, posture) yield sim.si_state.notify_posture_change_and_remove_incompatible_gen(timeline, prev_posture_state, self._dest_state) prev_posture.clear_owning_interactions() if multi_sim_posture_transition: linked_posture_begin = posture.linked_posture.begin(self._animate_in, self._dest_state.linked_posture_state, posture._context) self._dest_state = None yield element_utils.run_child(timeline, linked_posture_begin) else: self._dest_state = None return True def end_posture_on_same_track(timeline): if self._prev_posture is not None and self._prev_posture is not posture: prev_posture = self._prev_posture self._prev_posture = None result = yield element_utils.run_child(timeline, build_element(prev_posture.end())) return result return True if services.current_zone().animate_instantly: flush = flush_all_animations_instantly else: flush = flush_all_animations sequence = (posture_change, animate_in, flush, end_posture_on_same_track, my_stage) sequence = build_element(sequence, critical=CleanupType.RunAll) sequence = build_critical_section_with_finally(sequence, lambda _: posture._release_animation_context()) if self._posture.jig is not None and self._posture.target is not None and self._posture.slot_constraint is not None: def create_and_place_jig(_): self._jig = objects.system.create_object(self._posture.jig) for constraint in self._posture.slot_constraint: self._jig.transform = constraint.containment_transform break sim.routing_context.ignore_footprint_contour(self._jig.routing_context.object_footprint_id) def destroy_jig(_): if self._jig is not None: sim.routing_context.remove_footprint_contour_override(self._jig.routing_context.object_footprint_id) self._jig.destroy(source=self, cause='Destroying jig for posture.') sequence = build_critical_section_with_finally(create_and_place_jig, sequence, destroy_jig) sequence = elements.GeneratorElement(self.with_censor_grid(sim, sequence)) if posture.target is not None: reserver = create_reserver(sim, posture.target, reserver=posture, handler=MultiReserveObjectHandler) sequence = reserver.do_reserve(sequence=sequence) def stage_on_fail(timeline): if not self.has_staged: yield element_utils.run_child(timeline, self._stage_fail()) sequence = element_utils.build_critical_section(sequence, stage_on_fail) sequence = maybe(posture.test, sequence) return sequence
def without_sim_focus(owner_sim, sim, *args): sim_id = sim.id return build_critical_section_with_finally(lambda _: FocusDisable(owner_sim, sim_id, True), args, lambda _: FocusDisable(owner_sim, sim_id, False))
def _build_outcome_sequence(self, *args, **kwargs): sequence = super()._build_outcome_sequence(*args, **kwargs) pregnancy_tracker = self.sim.sim_info.pregnancy_tracker return element_utils.must_run(element_utils.build_critical_section_with_finally(self._name_and_create_babies_gen, sequence, lambda _: pregnancy_tracker.clear_pregnancy()))
def with_sim_focus(owner_sim, sim, target, layer, *args, score=1, flags=0, bone=0, offset=sims4.math.Vector3.ZERO()): if bone == 0 and offset == sims4.math.Vector3.ZERO() and target is not None: bone = target.focus_bone focus_element = SimFocus(owner_sim, sim, target, offset, get_next_focus_id(), layer=layer, score=score, flags=flags, bone=bone) return build_critical_section_with_finally(focus_element.begin, args, focus_element.end)
def do_reserve(self, sequence=None): return build_critical_section_with_finally(self._begin, sequence, self.end)
def build_basic_elements(self, sequence=()): sequence = super().build_basic_elements(sequence=sequence) sequence = build_critical_section_with_finally(self.interaction_start, sequence, self.interaction_end) return sequence
def _build_outer_elements(self, sequence): if self._game_speed_change.set_speed_type == self.REQUEST_SPEED: return build_critical_section_with_finally(sequence, self._unrequest_speed) return sequence
def build_critical_section(cls, sim, buff_reason, *sequence): buff_handler = BuffHandler(sim, cls, buff_reason=buff_reason) return build_critical_section_with_finally(buff_handler.begin, sequence, buff_handler.end)
def retarget_interaction(interaction, target, *args): if interaction is not None: interaction_retarget_handler = InteractionRetargetHandler(interaction, target) return build_critical_section_with_finally(interaction_retarget_handler.begin, args, interaction_retarget_handler.end) return args
def build_basic_elements(self, sequence=(), **kwargs): sequence = super().build_basic_elements(sequence=sequence, **kwargs) sequence = element_utils.build_critical_section_with_finally(self._interaction_start, sequence, self._interaction_end) return sequence
def _run(self, timeline): sequence = build_critical_section_with_finally(self.start, self._sequence, self.stop) return timeline.run_child(sequence)