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