def potential_interactions(cls, target, sa, si, **kwargs):
if not target.has_component(STORED_AUDIO_COMPONENT):
return
resolver = si.get_resolver()
for (channel, channel_data) in si.channels.items():
if channel_data.channel_tests.run_tests(resolver):
if channel is not ChannelFlags.CHANNEL1:
stored_audio_component = target.get_component(
STORED_AUDIO_COMPONENT)
if not stored_audio_component.get_channel_value(channel):
display_name = si.turn_on_channel_display_name(
channel_data.channel_name)
yield AffordanceObjectPair(
cls,
target,
sa,
si,
display_name=display_name,
channel_name=channel_data.channel_name,
icon=si.turn_on_channel_icon,
channel=channel,
channel_value=1)
else:
display_name = si.turn_off_channel_display_name(
channel_data.channel_name)
yield AffordanceObjectPair(
cls,
target,
sa,
si,
display_name=display_name,
channel_name=channel_data.channel_name,
icon=si.turn_off_channel_icon,
channel=channel,
channel_value=0)
def _on_spawn(sim):
affordance = bassinet.get_age_up_addordance()
aop = AffordanceObjectPair(affordance, middle_bassinet, affordance, None, is_baby_age_up=True)
context = InteractionContext(sim, InteractionSource.SCRIPT, Priority.Critical, insert_strategy=QueueInsertStrategy.NEXT)
result = aop.test_and_execute(context)
if not result:
logger.error('Failed to run baby age up interaction: {}', result, owner='jjacobson')
def run_age_up(kid):
def age_up_exit_behavior():
new_bassinet = create_object(
Baby.get_corresponding_definition(
middle_bassinet.definition))
new_bassinet.location = middle_bassinet.location
middle_bassinet.make_transient()
kid.fade_opacity(1, 0)
kid.visibility = VisibilityState(False)
affordance = Baby.BABY_AGE_UP.age_up_affordance
aop = AffordanceObjectPair(
affordance,
middle_bassinet,
affordance,
None,
exit_functions=(age_up_exit_behavior, ))
context = InteractionContext(
kid,
InteractionSource.SCRIPT,
interactions.priority.Priority.Critical,
insert_strategy=QueueInsertStrategy.NEXT)
result = aop.test_and_execute(context)
if result:
result.interaction.add_liability(
AGING_LIABILITY, AgingLiability(sim_info, Age.BABY))
else:
logger.error('Failed to run baby age up interaction.',
owner='jjacobson')
return True
def build_msg(self, **kwargs):
message = super().build_msg(**kwargs)
message.dialog_type = Dialog_pb2.UiDialogMessage.MULTI_PICKER
if self.text_input is not None:
text_input_overrides = {}
(text_name, text) = self.existing_text
text_input_overrides = {}
if text:
text_input_overrides[text_name] = lambda *_, **__: LocalizationHelperTuning.get_raw_text(text)
self.text_input.build_msg(self, message, name=text_name, text_input_overrides=text_input_overrides if text_input_overrides else None)
context = InteractionContext(self._owner(), InteractionSource.SCRIPT, Priority.Low)
multi_picker_msg = Dialog_pb2.UiDialogMultiPicker()
for picker_data in self.pickers:
aop = AffordanceObjectPair(picker_data.picker_interaction, None, picker_data.picker_interaction, None)
result = aop.interaction_factory(context)
if not result:
continue
interaction = result.interaction
picker_tuning = picker_data.picker_interaction.picker_dialog
if picker_tuning.title is None:
title = lambda *_, **__: interaction.get_name(apply_name_modifiers=False)
else:
title = self.picker_dialog.title
dialog = picker_tuning(self._owner(), title=title, resolver=interaction.get_resolver(context=context))
interaction._setup_dialog(dialog)
dialog.add_listener(interaction._on_picker_selected)
self._picker_dialogs[dialog.dialog_id] = dialog
new_message = dialog.build_msg()
multi_picker_item = multi_picker_msg.multi_picker_items.add()
multi_picker_item.picker_data = new_message.picker_data
multi_picker_item.picker_id = new_message.dialog_id
multi_picker_item.disabled_tooltip = picker_data.disabled_tooltip
message.multi_picker_data = multi_picker_msg
return message
def _run_obstacle_course_autonomy_request(self, timeline):
try:
selected_interaction = yield from services.autonomy_service(
).find_best_action_gen(
timeline,
self._autonomy_request,
randomization_override=AutonomyRandomization.DISABLED)
finally:
self._autonomy_request_handle = None
if self.owner is None:
return False
yield
if selected_interaction is not None:
selected_interaction.invalidate()
affordance = selected_interaction.affordance
aop = AffordanceObjectPair(affordance, selected_interaction.target,
affordance, None)
result = aop.test_and_execute(self._interaction_context)
if not result:
return result
yield
self.owner.continue_course()
return True
yield
self.owner.finish_course()
return True
yield
def _changed_state_callback(self, target, state, old_value, new_value):
if new_value != Television.TV_OFF_STATE:
context = self.context.clone_for_continuation(self)
affordance = self.generate_continuation_affordance(new_value.affordance)
aop = AffordanceObjectPair(affordance, self.target, affordance, None)
aop.test_and_execute(context)
self.cancel(FinishingType.OBJECT_CHANGED, cancel_reason_msg='state: interaction canceled on state change ({} != {})'.format(new_value.value, self.required_channel.value))
def potential_interactions(cls, target, context, **kwargs):
sim = context.sim
if sim is None:
return
resolver = SingleSimResolver(sim.sim_info)
for style in cls.music_styles:
for track in style.music_tracks:
if track.tests.run_tests(resolver):
if not track.check_for_unlock:
yield AffordanceObjectPair(
cls,
target,
cls,
None,
track=track,
pie_menu_category=style.pie_menu_category,
**kwargs)
else:
unlocks = sim.sim_info.unlock_tracker.get_unlocks(
track
) if sim.sim_info.unlock_tracker is not None else None
if unlocks:
for unlock in unlocks:
yield AffordanceObjectPair(
cls,
target,
cls,
None,
track=unlock.tuning_class,
pie_menu_category=style.pie_menu_category,
unlockable_name=unlock.name,
**kwargs)
def on_activate(self, reader=None):
super().on_activate(reader)
leader_sim = self.owner.initiating_sim_info.get_sim_instance()
if leader_sim is None:
self.owner._self_destruct()
members = list(self.owner.all_sims_in_situation_gen())
constraint_affordance = self.owner.constraint_affordance
follower_sim_ids = set()
for sim in members:
if sim is leader_sim:
if not sim.si_state.is_running_affordance(
self.owner.constraint_leader_affordance):
self.owner.remove_sim_from_situation(sim)
if not sim.si_state.is_running_affordance(
constraint_affordance):
self.owner.remove_sim_from_situation(sim)
else:
follower_sim_ids.add(sim.id)
elif not sim.si_state.is_running_affordance(constraint_affordance):
self.owner.remove_sim_from_situation(sim)
else:
follower_sim_ids.add(sim.id)
interaction_context = InteractionContext(
leader_sim, InteractionSource.SCRIPT_WITH_USER_INTENT,
Priority.High)
aop = AffordanceObjectPair(self.owner.affordance,
self.owner._target_object,
self.owner.affordance,
None,
picked_item_ids=follower_sim_ids)
aop.test_and_execute(interaction_context)
def run_subaction_autonomy(self):
if not SubActionAutonomy.test(self.owner):
if gsi_handlers.autonomy_handlers.archiver.enabled:
gsi_handlers.autonomy_handlers.archive_autonomy_data(self.owner, 'None - Autonomy Disabled', 'SubActionAutonomy', gsi_handlers.autonomy_handlers.EMPTY_ARCHIVE)
return EnqueueResult.NONE
attempt_to_use_cache = False
if gsi_handlers.autonomy_handlers.archiver.enabled:
caching_info = []
else:
caching_info = None
while self._cached_mixer_interactions:
attempt_to_use_cache = True
interaction_to_run = self._cached_mixer_interactions.pop(0)
if self._should_run_cached_interaction(interaction_to_run):
enqueue_result = AffordanceObjectPair.execute_interaction(interaction_to_run)
if enqueue_result:
if gsi_handlers.autonomy_handlers.archiver.enabled:
gsi_handlers.autonomy_handlers.archive_autonomy_data(self.owner, 'Using Cache: {}'.format(interaction_to_run), 'SubActionAutonomy', gsi_handlers.autonomy_handlers.EMPTY_ARCHIVE)
return enqueue_result
if interaction_to_run:
interaction_to_run.invalidate()
while caching_info is not None:
caching_info.append('Failed to use cache interaction: {}'.format(interaction_to_run))
continue
if caching_info is not None and attempt_to_use_cache:
caching_info.append('Cache invalid:Regenerating')
self.invalidate_mixer_interaction_cache(None)
context = InteractionContext(self.owner, InteractionSource.AUTONOMY, Priority.Low)
autonomy_request = AutonomyRequest(self.owner, context=context, consider_scores_of_zero=True, autonomy_mode=SubActionAutonomy)
if caching_info is not None:
caching_info.append('Caching: Mixers - START')
initial_probability_result = None
while len(self._cached_mixer_interactions) < self.MIXERS_TO_CACHE:
interaction = services.autonomy_service().find_best_action(autonomy_request, consider_all_options=True, archive_if_enabled=False)
if interaction is None:
break
if caching_info is not None:
caching_info.append('caching interaction: {}'.format(interaction))
if initial_probability_result is None:
initial_probability_result = list(autonomy_request.gsi_data['Probability'])
self._cached_mixer_interactions.append(interaction)
if caching_info is not None:
caching_info.append('Caching: Mixers - DONE')
if self._cached_mixer_interactions:
interaction = self._cached_mixer_interactions.pop(0)
if caching_info is not None:
caching_info.append('Executing mixer: {}'.format(interaction))
enqueue_result = AffordanceObjectPair.execute_interaction(interaction)
if caching_info is not None:
autonomy_request.gsi_data['caching_info'] = caching_info
autonomy_request.gsi_data['Probability'] = initial_probability_result
if enqueue_result:
result_info = str(interaction)
else:
result_info = 'None - failed to execute: {}'.format(interaction)
gsi_handlers.autonomy_handlers.archive_autonomy_data(autonomy_request.sim, result_info, autonomy_request.autonomy_mode_label, autonomy_request.gsi_data)
return enqueue_result
return EnqueueResult.NONE
def push_travel_interaction(sim, from_zone_id, to_zone_id, callback, context):
travel_affordance = TravelService.TRAVEL_AFFORDANCE
travel_aop = AffordanceObjectPair(travel_affordance, None, travel_affordance, None, from_zone_id=from_zone_id, to_zone_id=to_zone_id, on_complete_callback=callback, on_complete_context=context)
interaction_context = InteractionContext(sim, InteractionContext.SOURCE_PIE_MENU, Priority.High)
if not travel_aop.test_and_execute(interaction_context):
logger.error('Critical Failure: Failed to push travel affordance: {0} on sim: {1}', travel_affordance, sim, owner='mduke')
callback(from_zone_id, sim.sim_info.sim_id, 0, context)
else:
services.travel_service().add_pending_travel(sim)
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)
def create_route_interaction(self):
if self.owner.is_sim:
aop = AffordanceObjectPair(AnimationInteraction, None, AnimationInteraction, None, hide_unrelated_held_props=False)
context = InteractionContext(self.owner, InteractionContext.SOURCE_SCRIPT, Priority.High)
self._route_interaction = aop.interaction_factory(context).interaction
else:
self._animation_context = AnimationContext()
self._animation_context.add_ref(self._current_path)
for slave_data in self.get_routing_slave_data():
slave_data.slave.routing_component.create_route_interaction()
def start_overlay(self):
aop = AffordanceObjectPair(AnimationInteraction,
None,
AnimationInteraction,
None,
hide_unrelated_held_props=False)
context = InteractionContext(self._sim,
InteractionContext.SOURCE_SCRIPT,
Priority.High)
self._overlay_interaction = aop.interaction_factory(
context).interaction
def _count_callback(self, _):
for sim in self.owner.all_sims_in_situation_gen():
parent_si = sim.si_state.get_si_by_affordance(
self.countdown_affordance)
if parent_si is not None:
interaction_context = InteractionContext(
sim, InteractionSource.PIE_MENU, Priority.Critical)
aop = AffordanceObjectPair(self.count_mixer, None,
self.countdown_affordance,
parent_si)
aop.test_and_execute(interaction_context)
def get_comfortable_interaction(self):
sim = self.owner
if not sim.posture.unconstrained:
return
if sim.get_main_group():
return
affordance = interactions.utils.satisfy_constraint_interaction.SatisfyConstraintSuperInteraction
aop = AffordanceObjectPair(affordance, None, affordance, None, constraint_to_satisfy=STAND_OR_SIT_CONSTRAINT, route_fail_on_transition_fail=False, name_override='Satisfy[GetComfortable]', allow_posture_changes=True)
context = InteractionContext(sim, InteractionContext.SOURCE_GET_COMFORTABLE, Priority.Low, insert_strategy=QueueInsertStrategy.NEXT, must_run_next=True, cancel_if_incompatible_in_queue=True)
execute_result = aop.interaction_factory(context)
return execute_result.interaction
def _route_sim(self, sim):
interaction_context = InteractionContext(
sim, InteractionSource.SCRIPT_WITH_USER_INTENT, Priority.High)
leader_sim = self.initiating_sim_info.get_sim_instance()
if leader_sim is sim:
affordance = self.constraint_leader_affordance
else:
affordance = self.constraint_affordance
aop = AffordanceObjectPair(affordance, self._target_object, affordance,
None)
aop.test_and_execute(interaction_context)
self._routing_sims.append(sim.id)
def __call__(self,
role_state,
role_affordance_target,
situation=None,
**kwargs):
sim = role_state.sim
affordance = self.affordance
source = self.source
priority = self.priority
run_priority = self.run_priority
if run_priority is None:
run_priority = priority
interaction_context = InteractionContext(sim,
source,
priority,
run_priority=run_priority,
**kwargs)
target = role_state._get_target_for_push_affordance(
self.target,
situation=situation,
role_affordance_target=role_affordance_target)
try:
push_result = False
if affordance.is_super:
push_result = sim.push_super_affordance(
affordance, target, interaction_context)
else:
super_affordance = self.super_affordance_for_mixer
if super_affordance is not None:
potential_parent_si = sim.si_state.get_si_by_affordance(
super_affordance)
if potential_parent_si is not None:
aop = AffordanceObjectPair(affordance, target,
super_affordance,
potential_parent_si)
push_result = aop.test_and_execute(interaction_context)
if push_result:
if self.add_situation_liability:
liability = SituationLiability(situation)
push_result.interaction.add_liability(
SITUATION_LIABILITY, liability)
elif self.leave_situation_on_failure:
situation_manager = services.get_zone_situation_manager()
situation_manager.remove_sim_from_situation(sim, situation.id)
except AttributeError:
logger.error(
'Attribute Error occurred pushing interaction {} on sim: {} for role_state:{}',
affordance,
sim,
role_state,
owner='msantander')
raise
def _apply_daycare_effects_to_sim(self, sim_info):
self._excluded_sims.discard(sim_info)
sim = services.object_manager().get(sim_info.id)
if sim_info.is_baby:
sim.empty_baby_state()
elif sim_info.is_toddler:
daycare_interaction = self._daycare_interactions.get(sim_info)
if daycare_interaction is None:
aop = AffordanceObjectPair(DaycareTuning.GO_TO_DAYCARE_INTERACTION, None, DaycareTuning.GO_TO_DAYCARE_INTERACTION, None)
context = InteractionContext(sim, InteractionContext.SOURCE_SCRIPT, Priority.High, insert_strategy=QueueInsertStrategy.FIRST, must_run_next=True)
execute_result = aop.test_and_execute(context)
if execute_result:
self._daycare_interactions[sim_info] = execute_result.interaction
return True
def _make_guests_watch(self, _):
static_commodity_list = [
self.owner.guest.watch_wedding_static_commodity
]
object_list = list(
self.owner.all_sims_in_job_gen(self.owner.betrothed.situation_job))
for sim_info in tuple(self._guest_sim_infos_to_force_watch):
sim = sim_info.get_sim_instance()
if sim is None:
self._guest_sim_infos_to_force_watch.remove(sim_info)
InteractionCancelCompatibility.cancel_interactions_for_reason(
sim, InteractionCancelReason.WEDDING, FinishingType.WEDDING,
'Interaction was cancelled due to the wedding situation.')
autonomy_request = AutonomyRequest(
sim,
autonomy_mode=FullAutonomy,
object_list=object_list,
static_commodity_list=static_commodity_list,
limited_autonomy_allowed=False,
autonomy_mode_label_override='WeddingMakeGuestsWatch')
selected_interaction = services.autonomy_service(
).find_best_action(autonomy_request)
while selected_interaction is not None:
if AffordanceObjectPair.execute_interaction(
selected_interaction):
self._guest_sim_infos_to_force_watch.remove(sim_info)
if self._guest_sim_infos_to_force_watch:
self._alarm_handle = alarms.add_alarm(
self,
create_time_span(minutes=self.MAKE_GUESTS_WATCH_ALARM_TIME),
self._make_guests_watch)
def _do_perform_gen(self, timeline):
sim = self.get_participant(self.sim_to_push_affordance_on)
if sim == self.context.sim:
context = self.context.clone_for_continuation(self)
else:
context = context.clone_for_sim(sim)
max_priority = None
aops_valid = []
for (priority, aop) in self._aops_sorted_gen(self.target, **self.interaction_parameters):
if max_priority is not None and priority < max_priority:
break
if aop.test(context):
aops_valid.append(aop)
max_priority = priority
if not aops_valid:
raise RuntimeError('Failed to find valid super affordance in AggregateSuperInteraction, did we not run its test immediately before executing it? [jpollak]')
interactions_by_distance = []
for aop in aops_valid:
interaction_result = aop.interaction_factory(context)
if not interaction_result:
raise RuntimeError('Failed to generate interaction from aop {}. {} [maxr/tastle]'.format(aop, interaction_result))
interaction = interaction_result.interaction
if len(aops_valid) == 1:
distance = 0
else:
(distance, _, _) = interaction.estimate_distance()
if distance is not None:
interactions_by_distance.append((distance, interaction))
(_, interaction) = max(interactions_by_distance, key=operator.itemgetter(0))
return AffordanceObjectPair.execute_interaction(interaction)
yield None
def _aops_from_template_gen(self, template, target, **kwargs):
for affordance_template in template.template_affordances:
affordance_kwargs = kwargs.copy()
affordance_kwargs.update(affordance_template.get_template_kwargs())
affordance_kwargs.update({'template_affordance': template})
affordance = affordance_template.get_template_affordance()
yield AffordanceObjectPair(affordance, target, affordance, None, **affordance_kwargs)
def create_si():
drink_target = self.created_target
target_affordance = drink_target.get_consume_affordance()
context = InteractionContext(self.order_sim, self.source, self.priority, insert_strategy=QueueInsertStrategy.NEXT, group_id=self.group_id)
context.carry_target = drink_target
aop = AffordanceObjectPair(target_affordance, drink_target, target_affordance, None)
return (aop, context)
def potential_interactions(cls, target, context, **kwargs):
(position, surface) = cls._get_position_and_surface(target, context)
main_group = context.sim.get_visible_group()
group_constraint = next(iter(main_group.get_constraint(context.sim)))
for constraint in group_constraint:
group_geometry = constraint.geometry
if not not group_geometry is not None and group_geometry.contains_point(
position):
yield AffordanceObjectPair(cls,
target,
cls,
None,
ignore_party=True,
**kwargs)
return
for aop in cls.get_rallyable_aops_gen(target, context, **kwargs):
yield aop
if not ((not position is not None or
(not context is not None or
(not context.sim is not None or
(not main_group is not None or
(main_group.is_solo or
(not group_constraint is not None
or not group_constraint.routing_surface == surface)))))
or cls._can_rally(context)) and cls.only_available_as_rally):
yield cls.generate_aop(target, context, **kwargs)
def sim_skewer_affordances_gen(self, context, **kwargs):
for tone in self.get_available_tones_gen():
yield AffordanceObjectPair(self.CAREER_TONE_INTERACTION, None, self.CAREER_TONE_INTERACTION, None, away_action=tone, away_action_sim_info=self._sim_info, **kwargs)
affordance = self.current_level_tuning.tones.leave_work_early
if affordance is not None:
for aop in affordance.potential_interactions(self._get_sim(), context, sim_info=self._sim_info, **kwargs):
yield aop
def _run_interaction_gen(self, timeline):
target_sim = self.get_participant(
interactions.ParticipantType.TargetSim)
logger.assert_log(
target_sim is not None,
'target_sim is invalid in SocialPickerSuperInteraction._run_interaction_gen()',
owner='rez')
self.force_inertial = True
context = self.context.clone_for_sim(
self.sim, bucket=InteractionBucketType.BASED_ON_SOURCE)
autonomy_request = AutonomyRequest(
self.sim,
autonomy_mode=autonomy.autonomy_modes.SocialAutonomy,
static_commodity_list=[self.SOCIAL_STATIC_COMMODITY],
object_list=[target_sim],
context=context,
push_super_on_prepare=True,
consider_scores_of_zero=True)
social_mixer = services.autonomy_service().find_best_action(
autonomy_request)
if social_mixer:
if not social_mixer.super_interaction.running:
social_mixer.super_interaction = None
for si in autonomy_request.interactions_to_invalidate:
si.invalidate()
autonomy_request.interactions_to_invalidate.clear()
if social_mixer:
social_mixer.push_super_affordance_target = target_sim
return AffordanceObjectPair.execute_interaction(social_mixer)
yield
else:
return event_testing.results.EnqueueResult.NONE
yield
def potential_interactions(cls, target, context, **kwargs):
if context.sim is None:
return
career = context.sim.sim_info.career_tracker.career_currently_within_hours
if career is not None and not career.currently_at_work:
affordance = career.get_work_affordance()
yield AffordanceObjectPair(affordance, target, affordance, None,
**kwargs)
def _get_destroy_aop(self, sim, **kwargs):
affordance = CarryableComponent.PUT_DOWN_HERE_AFFORDANCE
return AffordanceObjectPair(affordance,
self.owner,
affordance,
None,
put_down_transform=None,
**kwargs)
def _push_interaction(self, selected_interaction):
should_log = services.autonomy_service().should_log(self.owner)
if AffordanceObjectPair.execute_interaction(selected_interaction):
return True
if should_log:
logger.debug('Autonomy failed to push {}', selected_interaction.affordance)
if selected_interaction.target:
self.owner.add_lockout(selected_interaction.target, AutonomyMode.LOCKOUT_TIME)
return False
def _aops_sorted_gen(cls, target, **interaction_parameters):
affordances = []
for aggregated_affordance in cls.aggregated_affordances:
aop = AffordanceObjectPair(aggregated_affordance.affordance,
target,
aggregated_affordance.affordance, None,
**interaction_parameters)
affordances.append((aggregated_affordance.priority, aop))
return sorted(affordances, key=operator.itemgetter(0), reverse=True)
def _push_loss_on_player(self):
motherplant = self._get_motherplant()
for (sim, situation_sim) in self._situation_sims.items():
if situation_sim.current_job_type is self.player_job:
parent_si = sim.si_state.get_si_by_affordance(
self.fight_affordance)
if parent_si is not None:
interaction_context = InteractionContext(
sim, InteractionSource.PIE_MENU, Priority.Critical)
aop = AffordanceObjectPair(self.loss_interaction_mixer,
motherplant,
self.fight_affordance,
parent_si)
if not aop.test_and_execute(interaction_context):
logger.error(
'Attempting to push Motherplant Battle Ending Interaction, but failed.'
)
self._push_interaction_on_all_helpers(self.helper_lose_affordance)
def on_activate(self, reader=None):
super().on_activate(reader)
dancers = list(self.owner.all_sims_in_situation_gen())
constraint_affordance = self.owner.constraint_affordance
for sim in dancers:
if not sim.si_state.is_running_affordance(constraint_affordance):
self.owner.remove_sim_from_situation(sim)
leader_sim = self.owner.initiating_sim_info.get_sim_instance()
interaction_context = InteractionContext(
leader_sim, InteractionSource.SCRIPT_WITH_USER_INTENT,
Priority.High)
aop = AffordanceObjectPair(self.owner.dance_affordance,
None,
self.owner.dance_affordance,
None,
jig_object=self.owner._jig_object,
jig_part_index=0)
aop.test_and_execute(interaction_context)
def run_age_up(kid):
def age_up_exit_behavior():
new_bassinet = create_object(Baby.get_corresponding_definition(middle_bassinet.definition))
new_bassinet.location = middle_bassinet.location
middle_bassinet.make_transient()
kid.fade_opacity(1, 0)
kid.visibility = VisibilityState(False)
affordance = Baby.BABY_AGE_UP.age_up_affordance
aop = AffordanceObjectPair(affordance, middle_bassinet, affordance, None, exit_functions=(age_up_exit_behavior,))
context = InteractionContext(kid, InteractionSource.SCRIPT, interactions.priority.Priority.Critical, insert_strategy=QueueInsertStrategy.NEXT)
result = aop.test_and_execute(context)
if result:
result.interaction.add_liability(AGING_LIABILITY, AgingLiability(sim_info, Age.BABY))
else:
logger.error('Failed to run baby age up interaction.', owner='jjacobson')
return True
def _gen_affordance_score_and_aops(self,
interaction,
multiplier=1,
add_putdown_liability=False):
for affordance in self.current_put_down_strategy.affordances:
aop = AffordanceObjectPair(affordance, self.owner, affordance,
None)
if add_putdown_liability:
_add_putdown_liability_to_aop(aop, interaction)
yield ScoredAOP(multiplier, aop)
def potential_interactions(cls, target, context, **kwargs):
for service_tuning_type in services.service_npc_manager().types:
service_tuning = services.service_npc_manager().get(
service_tuning_type)
yield AffordanceObjectPair(cls,
target,
cls,
None,
service_tuning=service_tuning,
**kwargs)
def _push_interaction(self, selected_interaction):
should_log = services.autonomy_service().should_log(self.owner)
if AffordanceObjectPair.execute_interaction(selected_interaction):
return True
if should_log:
logger.debug('Autonomy failed to push {}',
selected_interaction.affordance)
if selected_interaction.target:
self.owner.add_lockout(selected_interaction.target,
AutonomyMode.LOCKOUT_TIME)
return False
def activate(cls):
client = services.client_manager().get_first_client()
active_sim = client.active_sim
if cls.gameplay_immediate_test is not None:
resolver = event_testing.resolver.SingleSimResolver(active_sim.sim_info)
if resolver(cls.gameplay_immediate_test):
cls.satisfy()
else:
return
for buff_ref in cls.buffs:
active_sim.add_buff_from_op(buff_ref.buff_type, buff_reason=buff_ref.buff_reason)
if cls.gameplay_test is not None:
services.get_event_manager().register_tests(cls, [cls.gameplay_test])
if cls.commodities_to_solve:
context = InteractionContext(active_sim, InteractionContext.SOURCE_SCRIPT_WITH_USER_INTENT, priority.Priority.High, bucket=InteractionBucketType.DEFAULT)
for commodity in cls.commodities_to_solve:
if not active_sim.queue.can_queue_visible_interaction():
break
autonomy_request = autonomy.autonomy_request.AutonomyRequest(active_sim, autonomy_mode=autonomy.autonomy_modes.FullAutonomy, commodity_list=(commodity,), context=context, consider_scores_of_zero=True, posture_behavior=AutonomyPostureBehavior.IGNORE_SI_STATE, distance_estimation_behavior=AutonomyDistanceEstimationBehavior.ALLOW_UNREACHABLE_LOCATIONS, allow_opportunity_cost=False, autonomy_mode_label_override='Tutorial')
selected_interaction = services.autonomy_service().find_best_action(autonomy_request)
AffordanceObjectPair.execute_interaction(selected_interaction)
def _run_interaction_gen(self, timeline):
target_sim = self.get_participant(interactions.ParticipantType.TargetSim)
logger.assert_log(target_sim is not None, 'target_sim is invalid in SocialPickerSuperInteraction._run_interaction_gen()', owner='rez')
self.force_inertial = True
context = self.context.clone_for_sim(self.sim, bucket=InteractionBucketType.BASED_ON_SOURCE)
autonomy_request = AutonomyRequest(self.sim, autonomy_mode=autonomy.autonomy_modes.SocialAutonomy, static_commodity_list=[self.SOCIAL_STATIC_COMMODITY], object_list=[target_sim], context=context, push_super_on_prepare=True, consider_scores_of_zero=True)
social_mixer = services.autonomy_service().find_best_action(autonomy_request)
if social_mixer and not social_mixer.super_interaction.running:
social_mixer.super_interaction = None
for si in autonomy_request.interactions_to_invalidate:
si.invalidate()
autonomy_request.interactions_to_invalidate.clear()
if social_mixer:
return AffordanceObjectPair.execute_interaction(social_mixer)
return event_testing.results.EnqueueResult.NONE
def _make_guests_watch(self, _):
static_commodity_list = [self.owner.guest.watch_wedding_static_commodity]
object_list = list(self.owner.all_sims_in_job_gen(self.owner.betrothed.situation_job))
for sim_info in tuple(self._guest_sim_infos_to_force_watch):
sim = sim_info.get_sim_instance()
if sim is None:
self._guest_sim_infos_to_force_watch.remove(sim_info)
InteractionCancelCompatibility.cancel_interactions_for_reason(sim, InteractionCancelReason.WEDDING, FinishingType.WEDDING, 'Interaction was cancelled due to the wedding situation.')
autonomy_request = AutonomyRequest(sim, autonomy_mode=FullAutonomy, object_list=object_list, static_commodity_list=static_commodity_list, limited_autonomy_allowed=False, autonomy_mode_label_override='WeddingMakeGuestsWatch')
selected_interaction = services.autonomy_service().find_best_action(autonomy_request)
while selected_interaction is not None:
if AffordanceObjectPair.execute_interaction(selected_interaction):
self._guest_sim_infos_to_force_watch.remove(sim_info)
if self._guest_sim_infos_to_force_watch:
self._alarm_handle = alarms.add_alarm(self, create_time_span(minutes=self.MAKE_GUESTS_WATCH_ALARM_TIME), self._make_guests_watch)
def _on_starting_work(self):
if self.preroll_autonomy is not None:
chosen_interaction = self.preroll_autonomy().run_preroll(self.service_sim())
if chosen_interaction is None:
self._had_preroll_work = False
else:
execute_result = AffordanceObjectPair.execute_interaction(chosen_interaction)
if not execute_result:
if self.fail_on_preroll_execute_failure:
self._had_preroll_work = False
if self.fake_perform_on_preroll_failure is not None:
self._on_preroll_cancelled(chosen_interaction)
elif self.fake_perform_on_preroll_failure is not None:
chosen_interaction.register_on_cancelled_callback(self._on_preroll_cancelled)
elif self.fake_perform_on_preroll_failure is not None:
chosen_interaction.register_on_cancelled_callback(self._on_preroll_cancelled)
if not self._had_preroll_work:
self._change_state(LeaveSituationState(ServiceNpcEndWorkReason.NO_WORK_TO_DO))
