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 _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 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 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 _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 _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 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 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 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)
