def on_sim_added_to_skewer(self, sim_info, send_relationship_update=True): if send_relationship_update: sim_info.relationship_tracker.send_relationship_info() is_zone_running = services.current_zone().is_zone_running sim_info.on_sim_added_to_skewer() if not is_zone_running: sim_info.commodity_tracker.start_low_level_simulation() else: services.active_household().distribute_household_data() sim_info.commodity_tracker.send_commodity_progress_update( from_add=True) sim_info.career_tracker.on_sim_added_to_skewer() if sim_info.degree_tracker is not None: sim_info.degree_tracker.on_sim_added_to_skewer() sim_info.send_whim_bucks_update(SetWhimBucks.LOAD) sim_info.resend_trait_ids() sim = sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS) if sim is not None: if is_zone_running: sim.inventory_component.visible_storage.allow_ui = True sim.inventory_component.publish_inventory_items() sim.ui_manager.refresh_ui_data() services.autonomy_service().logging_sims.add(sim) sim_info.start_aspiration_tracker_on_instantiation( force_ui_update=True) if sim_info.whim_tracker is not None: sim_info.whim_tracker.start_whims_tracker() zone_director = services.venue_service().get_zone_director() if zone_director is not None: zone_director.on_sim_added_to_skewer(sim_info) sim_info.trait_tracker.sort_and_send_commodity_list()
def start_autonomy_load_test(motive_value:float=-40, _connection=None): sim_list = [sim for sim in services.sim_info_manager().instanced_sims_gen()] global_autonomy_randomization('disabled', _connection) for sim in sim_list: sim.run_full_autonomy_next_ping() _randomize_all_motives_deterministically(sim_list, motive_value) services.autonomy_service().start_automated_load_test(_connection, len(sim_list))
def _set_sim_autonomy_log(sim, state=None): if state: services.autonomy_service().logging_sims.add(sim) else: services.autonomy_service().logging_sims.discard(sim) logger.debug('Autonomy log toggled to {0} on {1}', state, sim) return True
def start_single_sim_performance_test(opt_sim:OptionalTargetParam=None, _connection=None): sim = get_optional_target(opt_sim, _connection) if sim is None: sims4.commands.output('No target for qa.automation.start_single_sim_performance_test', _connection) return sim.reset(ResetReason.RESET_EXPECTED, None, 'start_single_sim_performance_test') services.autonomy_service().start_single_sim_load_test(_connection, sim) sim.run_full_autonomy_next_ping()
def start_autonomy_load_test(motive_value: float = -40, _connection=None): sim_list = [ sim for sim in services.sim_info_manager().instanced_sims_gen() ] global_autonomy_randomization('disabled', _connection) for sim in sim_list: sim.run_full_autonomy_next_ping() _randomize_all_motives_deterministically(sim_list, motive_value) services.autonomy_service().start_automated_load_test( _connection, len(sim_list))
def _do_rally_behavior(self, sim, constraint): if self.rally_data is not None: target = None if self.rally_constraint is not None: constraint = self.rally_constraint context = self.context.clone_for_sim(sim, insert_strategy=QueueInsertStrategy.NEXT) affordance = self._get_rally_affordance() context.run_priority = Priority.Low if affordance is None: static_commodity = self._get_rally_static_commodity() if static_commodity is not None: request = AutonomyRequest(sim, static_commodity_list=(static_commodity,), skipped_static_commodities=None, object_list=self._rally_targets, constraint=constraint, context=context, autonomy_mode=FullAutonomy, autonomy_mode_label_override='RallyBehavior') autonomy_result = services.autonomy_service().score_all_interactions(request) if self._rally_targets is None: self._rally_targets = {} for scored_interaction_data in autonomy_result: num_possible_parts = 0 possible_target = scored_interaction_data.interaction.target if possible_target is not None and possible_target.parts is not None: for part in possible_target.parts: while not part.in_use or part.in_use_by(sim): if part.supports_affordance(scored_interaction_data.interaction.affordance): num_possible_parts = num_possible_parts + 1 else: num_possible_parts = 1 if self.target == possible_target: num_possible_parts = num_possible_parts - 1 while num_possible_parts > 0: self._rally_targets[possible_target] = num_possible_parts appropriate_scored_interactons = tuple([scored_interaction_data for scored_interaction_data in autonomy_result if scored_interaction_data.interaction.target in self._rally_targets]) chosen_interaction = services.autonomy_service().choose_best_interaction(appropriate_scored_interactons, request) request.invalidate_created_interactions(excluded_si=chosen_interaction) affordance = chosen_interaction.affordance target = chosen_interaction.target if target is not None: num_parts_remaining = self._rally_targets.get(target, 1) - 1 if num_parts_remaining <= 0: del self._rally_targets[target] else: self._rally_targets[target] = num_parts_remaining return False else: return False else: target = self._get_rally_affordance_target() if target is not None and target.is_part: for adjacent_part in target.adjacent_parts_gen(): while adjacent_part.may_reserve(sim, affordance=self, context=self.context) and adjacent_part.supports_posture_type(affordance.provided_posture_type, interaction=affordance): target = adjacent_part break target = target.part_owner if affordance is not None: affordance = self.generate_continuation_affordance(affordance, rally_constraint=constraint) return sim.push_super_affordance(affordance, target, context, from_rally_interaction=self, push_social=self.rally_push_social, **self.interaction_parameters) return False
def show_queue(_connection=None): output = sims4.commands.CheatOutput(_connection) output('Autonomy Queue:') if services.autonomy_service()._active_sim is not None: output(' 0) {}'.format(services.autonomy_service()._active_sim)) else: output(' 0) None') for (index, request) in enumerate(services.autonomy_service().queue, start=1): output(' {}) {}'.format(index, request.sim)) queue_size = len(services.autonomy_service().queue) output('Queue size: {}'.format(queue_size))
def start_single_sim_performance_test(opt_sim: OptionalTargetParam = None, _connection=None): sim = get_optional_target(opt_sim, _connection) if sim is None: sims4.commands.output( 'No target for qa.automation.start_single_sim_performance_test', _connection) return sim.reset(ResetReason.RESET_EXPECTED, None, 'start_single_sim_performance_test') services.autonomy_service().start_single_sim_load_test(_connection, sim) sim.run_full_autonomy_next_ping()
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 _choose_role_interaction( self, sim, push_priority=interactions.priority.Priority.High, run_priority=interactions.priority.Priority.High, allow_failed_path_plans=False): context = interactions.context.InteractionContext( sim, interactions.context.InteractionSource.SCRIPT, push_priority, run_priority=run_priority) distance_estimation_behavior = autonomy.autonomy_request.AutonomyDistanceEstimationBehavior.FULL if allow_failed_path_plans: distance_estimation_behavior = autonomy.autonomy_request.AutonomyDistanceEstimationBehavior.ALLOW_UNREACHABLE_LOCATIONS autonomy_request = autonomy.autonomy_request.AutonomyRequest( sim, autonomy_mode=autonomy.autonomy_modes.FullAutonomy, skipped_static_commodities=objects.components.autonomy. AutonomyComponent.STANDARD_STATIC_COMMODITY_SKIP_SET, limited_autonomy_allowed=False, context=context, distance_estimation_behavior=distance_estimation_behavior, autonomy_mode_label_override='ChooseRoleInteraction') best_interaction = services.autonomy_service().find_best_action( autonomy_request, randomization_override=AutonomyRandomization.DISABLED) return best_interaction
def run_preroll_autonomy(self, ignored_objects): sim = self.owner sim_info = sim.sim_info current_away_action = sim_info.current_away_action if current_away_action is not None: commodity_list = current_away_action.get_commodity_preroll_list() static_commodity_list = current_away_action.get_static_commodity_preroll_list( ) else: commodity_list = None static_commodity_list = None autonomy_request = AutonomyRequest( self.owner, autonomy_mode=FullAutonomy, commodity_list=commodity_list, static_commodity_list=static_commodity_list, skipped_affordance_list=self.PREROLL_AUTONOMY_AFFORDANCE_SKIP_SET, distance_estimation_behavior=AutonomyDistanceEstimationBehavior. IGNORE_DISTANCE, ignored_object_list=ignored_objects, limited_autonomy_allowed=False, autonomy_mode_label_override='PrerollAutonomy') selected_interaction = services.autonomy_service().find_best_action( autonomy_request) if selected_interaction is None: return (None, None) if self._push_interaction(selected_interaction): return (selected_interaction.affordance, selected_interaction.target) return (None, None)
def _get_appropriate_autonomy_setting(self, setting_class): autonomy_service = services.autonomy_service() setting = autonomy_service.global_autonomy_settings.get_setting( setting_class) if setting != setting_class.UNDEFINED: return setting if self._role_tracker is not None: setting = self._role_tracker.get_autonomy_state() if setting != setting_class.UNDEFINED: return setting setting = self._autonomy_settings.get_setting(setting_class) if setting != setting_class.UNDEFINED: return setting household = self.owner.household if household: setting = household.autonomy_settings.get_setting(setting_class) if setting != setting_class.UNDEFINED: return setting setting = autonomy_service.default_autonomy_settings.get_setting( setting_class) if setting == setting_class.UNDEFINED: logger.error('Sim {} has an UNDEFINED autonomy setting!', self.owner, owner='rez') return setting
def run_preroll(self, sim): autonomy_service = services.autonomy_service() context = InteractionContext(sim, self.preroll_source, self.preroll_priority, client=None, pick=None) autonomy_distance_estimation_behavior = AutonomyDistanceEstimationBehavior.ALLOW_UNREACHABLE_LOCATIONS if self.allow_unreachable_destinations else AutonomyDistanceEstimationBehavior.FULL autonomy_request = AutonomyRequest( sim, autonomy_mode=FullAutonomy, skipped_static_commodities=AutonomyComponent. STANDARD_STATIC_COMMODITY_SKIP_SET, limited_autonomy_allowed=False, context=context, distance_estimation_behavior=autonomy_distance_estimation_behavior, autonomy_mode_label_override='NPCPrerollAutonomy') scored_interactions = autonomy_service.score_all_interactions( autonomy_request) compatible_scored_interactions = tuple([ scored_interaction_data for scored_interaction_data in scored_interactions if self.super_affordance_compatibility( scored_interaction_data.interaction.affordance) ]) chosen_interaction = autonomy_service.choose_best_interaction( compatible_scored_interactions, autonomy_request) autonomy_request.invalidate_created_interactions( excluded_si=chosen_interaction) return chosen_interaction
def handle_vote_interaction(self, sim_info, target_id, push_continuation): sim = sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS) if sim is None: return target_object = services.object_manager().get(target_id) if not target_object: return for current_interaction in sim.si_state: interaction_target = current_interaction.target if interaction_target is None: continue if interaction_target.is_part: if interaction_target.part_owner is target_object: target_object = interaction_target break if interaction_target is target_object: break else: return if push_continuation: context = current_interaction.context.clone_for_continuation(current_interaction) autonomy_request = autonomy.autonomy_request.AutonomyRequest(sim, FullAutonomy, static_commodity_list=self.VOTING_CONTINUATION_AUTONOMY_COMMODITIES, object_list=(target_object,), insert_strategy=QueueInsertStrategy.NEXT, apply_opportunity_cost=False, is_script_request=True, ignore_user_directed_and_autonomous=True, context=context, si_state_view=sim.si_state, limited_autonomy_allowed=True, autonomy_mode_label_override='ParameterizedAutonomy', off_lot_autonomy_rule_override=UNLIMITED_AUTONOMY_RULE) autonomy_service = services.autonomy_service() results = autonomy_service.score_all_interactions(autonomy_request) chosen_interaction = autonomy_service.choose_best_interaction(results, autonomy_request) autonomy_request.invalidate_created_interactions(excluded_si=chosen_interaction) if chosen_interaction: target_affordance = current_interaction.generate_continuation_affordance(chosen_interaction.affordance) sim.push_super_affordance(target_affordance, target_object, context) current_interaction.cancel(FinishingType.NATURAL, 'Finished viewing board')
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 _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 _get_appropriate_autonomy_setting(self, setting_class): autonomy_service = services.autonomy_service() setting = autonomy_service.global_autonomy_settings.get_setting( setting_class, self.get_autonomy_settings_group()) if setting != setting_class.UNDEFINED: return setting if self._role_tracker is not None: setting = self._role_tracker.get_autonomy_state() if setting != setting_class.UNDEFINED: return setting if services.current_zone().is_zone_running: tutorial_service = services.get_tutorial_service() if tutorial_service is not None and tutorial_service.is_tutorial_running( ): return autonomy.settings.AutonomyState.FULL setting = self._autonomy_settings.get_setting( setting_class, self.get_autonomy_settings_group()) if setting != setting_class.UNDEFINED: return setting household = self.owner.household if household: setting = household.autonomy_settings.get_setting( setting_class, self.get_autonomy_settings_group()) if setting != setting_class.UNDEFINED: return setting setting = autonomy_service.default_autonomy_settings.get_setting( setting_class, self.get_autonomy_settings_group()) if setting == setting_class.UNDEFINED: logger.error('Sim {} has an UNDEFINED autonomy setting!', self.owner, owner='rez') return setting
def get_autonomous_availability_of_object(self, obj, autonomy_rule, off_lot_radius, sim_is_on_active_lot, reference_object=None): reference_object = self.owner if reference_object is None else reference_object if obj is self.owner: return True object_is_on_active_lot = obj.is_on_active_lot() if object_is_on_active_lot: if autonomy_rule == autonomy.autonomy_modifier.OffLotAutonomyRules.DEFAULT and not sim_is_on_active_lot: return False if autonomy_rule == autonomy.autonomy_modifier.OffLotAutonomyRules.OFF_LOT_ONLY: return False else: if autonomy_rule == autonomy.autonomy_modifier.OffLotAutonomyRules.ON_LOT_ONLY: return False if off_lot_radius == 0: return False if off_lot_radius > 0: delta = obj.position - reference_object.position if delta.magnitude() > off_lot_radius: return False if autonomy_rule != autonomy.autonomy_modifier.OffLotAutonomyRules.UNLIMITED and obj.is_sim and not object_is_on_active_lot: if self.owner.is_on_active_lot(tolerance=self.owner.get_off_lot_autonomy_tolerance()): return False autonomy_service = services.autonomy_service() target_delta = obj.intended_position - obj.position if target_delta.magnitude_squared() > autonomy_service.MAX_OPEN_STREET_ROUTE_DISTANCE_FOR_SOCIAL_TARGET_SQUARED: return False distance_from_me = obj.intended_position - self.owner.intended_position if distance_from_me.magnitude_squared() > autonomy_service.MAX_OPEN_STREET_ROUTE_DISTANCE_FOR_INITIATING_SOCIAL_SQUARED: return False if self.owner.locked_from_obj_by_privacy(obj): return False return True
def on_sim_added_to_skewer(self, sim_info, send_relationship_update=True): if send_relationship_update: sim_info.relationship_tracker.send_relationship_info() sim_info.relationship_tracker.enable_selectable_sim_track_decay() sim_info.on_sim_added_to_skewer() sim_info.commodity_tracker.send_commodity_progress_update() sim_info.career_tracker.on_sim_added_to_skewer() sim_info.send_whim_bucks_update(SetWhimBucks.LOAD) sim = sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS) if sim is not None: sim.ui_manager.refresh_ui_data() services.autonomy_service().logging_sims.add(sim) sim.family_funds.empty_sim_personal_funds(sim) sim_info.aspiration_tracker.force_send_data_update() sim_info.aspiration_tracker.initialize_aspiration() sim_info.aspiration_tracker.set_update_alarm() sim_info.career_tracker.activate_career_aspirations()
def show_queue_automation(_connection=None): sims4.commands.automation_output('Autonomy; Queue:Begin', _connection) automation_logger.debug('Autonomy; Queue:Begin') for request in services.autonomy_service().queue: sims4.commands.automation_output('Autonomy; Queue:Data, Id:{}'.format(request.sim.id), _connection) automation_logger.debug('Autonomy; Queue:Data, Id:{}'.format(request.sim.id)) sims4.commands.automation_output('Autonomy; Queue:End', _connection) automation_logger.debug('Autonomy; Queue:End')
def all_autonomy_state(state, _connection=None): autonomy_service = services.autonomy_service() true_state = _parse_state(state, _connection=_connection) if true_state is None: return for settings_group in AutonomySettingsGroup: autonomy_service.global_autonomy_settings.set_setting( true_state, settings_group)
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 _find_phase_affordances(self, phases, sim, context, default_target, display_errors=True, **kwargs): affordance_to_phase = {} affordance_list = [] ico_affordance_list = [] for phase in phases: affordance = phase.super_affordance affordance_to_phase[affordance] = phase if phase.target_ico: ico_affordance_list.append(affordance) else: affordance_list.append(affordance) if not affordance_list and not ico_affordance_list: logger.error("Couldn't find any interactions to look for for phases: {}", phases) return ((), affordance_to_phase) if context.carry_target is None and self.current_ico is not None and self.current_ico.set_ico_as_carry_target: context.carry_target = self.current_ico if self.original_target is not None: context.add_preferred_object(self.original_target) def get_interaction_parameters(affordance, base_interaction_parameters): if affordance not in affordance_to_phase: return base_interaction_parameters interaction_parameters = base_interaction_parameters.copy() interaction_parameters['phase'] = affordance_to_phase[affordance] return interaction_parameters def run_request(autonomy_service, affordance_list, required_objects=None): request = self._create_autonomy_request(sim, context, autonomy.autonomy_modes.FullAutonomy, affordance_list=affordance_list, required_objects=required_objects, crafting_process=self, get_interaction_parameters=get_interaction_parameters) result = autonomy_service.score_all_interactions(request) request.invalidate_created_interactions() return result result = None ico_result = None autonomy_service = services.autonomy_service() if autonomy_service is None: return ((), affordance_to_phase) if affordance_list: required_objects = [] if self.original_target is not None: required_objects.append(self.original_target) if default_target is not None: required_objects.append(default_target) if required_objects: result = run_request(autonomy_service, affordance_list, required_objects=required_objects) if not result: result = run_request(autonomy_service, affordance_list) if ico_affordance_list: ico_result = run_request(autonomy_service, ico_affordance_list, required_objects=[self.current_ico]) if result: result = result + ico_result else: result = ico_result if affordance_list: logger.warn("{}: Couldn't find object to run one of these interactions on: {}", phases, affordance_list) if not result and display_errors and ico_affordance_list: logger.warn("{}: Couldn't find one of these interactions on {}: {}", phases, self.current_ico, ico_affordance_list) return (result, affordance_to_phase)
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 global_autonomy_randomization( randomization, settings_group: AutonomySettingsGroup = AutonomySettingsGroup.DEFAULT, _connection=None): autonomy_service = services.autonomy_service() true_randomization = _parse_randomization(randomization) if true_randomization is not None: autonomy_service.global_autonomy_settings.set_setting( true_randomization, settings_group)
def show_autonomy_settings(opt_sim:OptionalTargetParam=None, _connection=None): sim = get_optional_target(opt_sim, _connection) if sim is None: sims4.commands.output("Couldn't find Sim.", _connection) return autonomy_state = _convert_state_to_string(sim.get_autonomy_state_setting()) autonomy_randomization = _convert_randomization_to_string(sim.get_autonomy_randomization_setting()) selected_sim_autonomy_enabled = services.autonomy_service()._selected_sim_autonomy_enabled sims4.commands.output('Autonomy State: {}\nAutonomyRandomization: {}\nSelected Sim Autonomy: {}'.format(autonomy_state, autonomy_randomization, selected_sim_autonomy_enabled), _connection)
def show_queue_automation(_connection=None): sims4.commands.automation_output('Autonomy; Queue:Begin', _connection) automation_logger.debug('Autonomy; Queue:Begin') for request in services.autonomy_service().queue: sims4.commands.automation_output( 'Autonomy; Queue:Data, Id:{}'.format(request.sim.id), _connection) automation_logger.debug('Autonomy; Queue:Data, Id:{}'.format( request.sim.id)) sims4.commands.automation_output('Autonomy; Queue:End', _connection) automation_logger.debug('Autonomy; Queue:End')
def generate_autonomy_queue_view_data(sim_id:int=None): autonomy_service = services.autonomy_service() autonomy_queue_data = [] if autonomy_service._active_sim is not None: entry = {'position': '0', 'sim': str(autonomy_service._active_sim)} autonomy_queue_data.append(entry) for (index, autonomy_request) in enumerate(autonomy_service.queue): entry = {'position': str(index + 1), 'sim': str(autonomy_request.sim)} autonomy_queue_data.append(entry) return autonomy_queue_data
def run_preroll(self, sim): autonomy_service = services.autonomy_service() context = InteractionContext(sim, self.preroll_source, self.preroll_priority, client=None, pick=None) autonomy_distance_estimation_behavior = AutonomyDistanceEstimationBehavior.ALLOW_UNREACHABLE_LOCATIONS if self.allow_unreachable_destinations else AutonomyDistanceEstimationBehavior.FULL autonomy_request = AutonomyRequest(sim, autonomy_mode=FullAutonomy, skipped_static_commodities=AutonomyComponent.STANDARD_STATIC_COMMODITY_SKIP_SET, limited_autonomy_allowed=False, context=context, distance_estimation_behavior=autonomy_distance_estimation_behavior, autonomy_mode_label_override='NPCPrerollAutonomy') scored_interactions = autonomy_service.score_all_interactions(autonomy_request) compatible_scored_interactions = tuple([scored_interaction_data for scored_interaction_data in scored_interactions if self.super_affordance_compatibility(scored_interaction_data.interaction.affordance)]) chosen_interaction = autonomy_service.choose_best_interaction(compatible_scored_interactions, autonomy_request) autonomy_request.invalidate_created_interactions(excluded_si=chosen_interaction) return chosen_interaction
def generate_autonomy_queue_view_data(sim_id: int = None): autonomy_service = services.autonomy_service() autonomy_queue_data = [] if autonomy_service._active_sim is not None: entry = {'position': '0', 'sim': str(autonomy_service._active_sim)} autonomy_queue_data.append(entry) for (index, autonomy_request) in enumerate(autonomy_service.queue): entry = {'position': str(index + 1), 'sim': str(autonomy_request.sim)} autonomy_queue_data.append(entry) return autonomy_queue_data
def on_sim_removed_from_skewer(self, sim_info, update_relationship_tracker=True): if update_relationship_tracker: if sim_info.is_child and sim_info.is_dead: sim_info.relationship_tracker.destroy_all_relationships() else: sim_info.relationship_tracker.enable_selectable_sim_track_decay(False) sim_info.aspiration_tracker.clear_update_alarm() sim = sim_info.get_sim_instance() if sim is not None: autonomy_service = services.autonomy_service() if autonomy_service is not None: autonomy_service.logging_sims.discard(sim)
def global_autonomy_state( state, settings_group: AutonomySettingsGroup = AutonomySettingsGroup.DEFAULT, _connection=None): autonomy_service = services.autonomy_service() true_state = _parse_state(state, _connection=_connection) if true_state is None: return autonomy_service.global_autonomy_settings.set_setting( true_state, settings_group) sims4.commands.output( 'Setting Global autonomy state to {} '.format(true_state), _connection)
def run_test_autonomy_ping(self, affordance_list=None, commodity_list=None): autonomy_request = AutonomyRequest( self.owner, autonomy_mode=FullAutonomy, commodity_list=commodity_list, affordance_list=affordance_list, skipped_static_commodities=self.standard_static_commodity_skip_set, limited_autonomy_allowed=False) selected_interaction = services.autonomy_service().find_best_action( autonomy_request) return selected_interaction
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 _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 show_autonomy_settings(opt_sim: OptionalTargetParam = None, _connection=None): sim = get_optional_target(opt_sim, _connection) if sim is None: sims4.commands.output("Couldn't find Sim.", _connection) return autonomy_state = _convert_state_to_string(sim.get_autonomy_state_setting()) autonomy_randomization = _convert_randomization_to_string( sim.get_autonomy_randomization_setting()) selected_sim_autonomy_enabled = services.autonomy_service( )._selected_sim_autonomy_enabled sims4.commands.output( 'Autonomy State: {}\nAutonomyRandomization: {}\nSelected Sim Autonomy: {}' .format(autonomy_state, autonomy_randomization, selected_sim_autonomy_enabled), _connection)
def autonomy_distance_estimates_perform_timed_run(time_to_run_in_seconds:int=180, _connection=None): global g_distance_estimate_alarm_handle if g_distance_estimate_alarm_handle is not None: autonomy_distance_estimates_disable(_connection=_connection) alarms.cancel_alarm(g_distance_estimate_alarm_handle) g_distance_estimate_alarm_handle = None autonomy_distance_estimates_enable(_connection=_connection) def _finish_test_and_write_file(_): global g_distance_estimate_alarm_handle autonomy_distance_estimates_log_file(_connection=_connection) autonomy_distance_estimates_disable(_connection=_connection) g_distance_estimate_alarm_handle = None time_span = date_and_time.create_time_span(minutes=time_to_run_in_seconds) g_distance_estimate_alarm_handle = alarms.add_alarm_real_time(services.autonomy_service(), time_span, _finish_test_and_write_file)
def run_preroll_autonomy(self, ignored_objects): sim = self.owner sim_info = sim.sim_info current_away_action = sim_info.current_away_action if current_away_action is not None: commodity_list = current_away_action.get_commodity_preroll_list() static_commodity_list = current_away_action.get_static_commodity_preroll_list() else: commodity_list = None static_commodity_list = None autonomy_request = AutonomyRequest(self.owner, autonomy_mode=FullAutonomy, commodity_list=commodity_list, static_commodity_list=static_commodity_list, skipped_affordance_list=self.PREROLL_AUTONOMY_AFFORDANCE_SKIP_SET, distance_estimation_behavior=AutonomyDistanceEstimationBehavior.IGNORE_DISTANCE, ignored_object_list=ignored_objects, limited_autonomy_allowed=False, autonomy_mode_label_override='PrerollAutonomy') selected_interaction = services.autonomy_service().find_best_action(autonomy_request) if selected_interaction is None: return (None, None) if self._push_interaction(selected_interaction): return (selected_interaction.affordance, selected_interaction.target) return (None, None)
def _push_interaction(self, selected_interaction): if AffordanceObjectPair.execute_interaction(selected_interaction): if self.get_comfortable is not None: get_comfortable_liability = AutonomousGetComfortableLiability( self.owner) selected_interaction.add_liability( AutonomousGetComfortableLiability.LIABILITY_TOKEN, get_comfortable_liability) return True should_log = services.autonomy_service().should_log(self.owner) 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 _attempt_full_autonomy_gen(self, timeline): if self._full_autonomy_request is not None and self._full_autonomy_request.valid: logger.debug('Ignoring full autonomy request for {} due to pending request in the queue.', self.owner) return False if self.to_skip_autonomy(): if gsi_handlers.autonomy_handlers.archiver.enabled: gsi_handlers.autonomy_handlers.archive_autonomy_data(self.owner, 'None - Running SIs are preventing autonomy from running: {}'.format(self._autonomy_skip_sis), 'FullAutonomy', None) return False if not self._test_full_autonomy(): return False try: selected_interaction = None try: self._full_autonomy_request = self._create_autonomy_request() selected_interaction = yield services.autonomy_service().find_best_action_gen(timeline, self._full_autonomy_request, archive_if_enabled=False) finally: self._full_autonomy_request.valid = False if not self._autonomy_enabled: if gsi_handlers.autonomy_handlers.archiver.enabled: gsi_handlers.autonomy_handlers.archive_autonomy_data(self.owner, 'None - Autonomy Disabled', 'FullAutonomy', None) return False if not self._test_full_autonomy(): if selected_interaction: selected_interaction.invalidate() return False chose_get_comfortable = False if selected_interaction is None: selected_interaction = self.get_comfortable_interaction() chose_get_comfortable = True if gsi_handlers.autonomy_handlers.archiver.enabled: gsi_handlers.autonomy_handlers.archive_autonomy_data(self._full_autonomy_request.sim, selected_interaction, self._full_autonomy_request.autonomy_mode_label, self._full_autonomy_request.gsi_data) if selected_interaction is not None: result = self._push_interaction(selected_interaction) if not result and gsi_handlers.autonomy_handlers.archiver.enabled: gsi_handlers.autonomy_handlers.archive_autonomy_data(self.owner, 'Failed - interaction failed to be pushed {}.'.format(selected_interaction), 'FullAutonomy', None) if result: if gsi_handlers.autonomy_handlers.archiver.enabled: gsi_handlers.autonomy_handlers.archive_autonomy_data(self._full_autonomy_request.sim, selected_interaction, self._full_autonomy_request.autonomy_mode_label, self._full_autonomy_request.gsi_data) if chose_get_comfortable: return False return True return False finally: if selected_interaction is not None: selected_interaction.invalidate()
def autonomy_distance_estimates_perform_timed_run( time_to_run_in_seconds: int = 180, _connection=None): global g_distance_estimate_alarm_handle if g_distance_estimate_alarm_handle is not None: autonomy_distance_estimates_disable(_connection=_connection) alarms.cancel_alarm(g_distance_estimate_alarm_handle) g_distance_estimate_alarm_handle = None autonomy_distance_estimates_enable(_connection=_connection) def _finish_test_and_write_file(_): global g_distance_estimate_alarm_handle autonomy_distance_estimates_log_file(_connection=_connection) autonomy_distance_estimates_disable(_connection=_connection) g_distance_estimate_alarm_handle = None time_span = date_and_time.create_time_span(minutes=time_to_run_in_seconds) g_distance_estimate_alarm_handle = alarms.add_alarm_real_time( services.autonomy_service(), time_span, _finish_test_and_write_file)
def _create_autonomy_request(self, sim, **kwargs): autonomy_service = services.autonomy_service() if autonomy_service is None: return (None, None) obstacles = [] object_manager = services.object_manager() for obj_id in self.owner.obstacle_ids: obstacle = object_manager.get(obj_id) if obstacle is not None: obstacles.append(obstacle) if not obstacles: return (None, None) self._interaction_context = interactions.context.InteractionContext( sim, interactions.context.InteractionContext.SOURCE_SCRIPT, interactions.priority.Priority.High, client=None, pick=None) commodity_list = [] for affordance in self.obstacle_affordance_list: commodity_list.extend(affordance.commodity_flags) self._autonomy_request = autonomy.autonomy_request.AutonomyRequest( sim, commodity_list=commodity_list, skipped_static_commodities=None, object_list=obstacles, affordance_list=self.obstacle_affordance_list, channel=None, context=self._interaction_context, autonomy_mode=autonomy.autonomy_modes.FullAutonomy, ignore_user_directed_and_autonomous=True, is_script_request=True, consider_scores_of_zero=True, ignore_lockouts=True, apply_opportunity_cost=False, record_test_result=None, distance_estimation_behavior=autonomy.autonomy_request. AutonomyDistanceEstimationBehavior.FINAL_PATH, off_lot_autonomy_rule_override=UNLIMITED_AUTONOMY_RULE, autonomy_mode_label_override='ObstacleCourse', **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 _get_appropriate_autonomy_setting(self, setting_class): autonomy_service = services.autonomy_service() setting = autonomy_service.global_autonomy_settings.get_setting(setting_class) if setting != setting_class.UNDEFINED: return setting if self._role_tracker is not None: setting = self._role_tracker.get_autonomy_state() if setting != setting_class.UNDEFINED: return setting setting = self._autonomy_settings.get_setting(setting_class) if setting != setting_class.UNDEFINED: return setting household = self.owner.household if household: setting = household.autonomy_settings.get_setting(setting_class) if setting != setting_class.UNDEFINED: return setting setting = autonomy_service.default_autonomy_settings.get_setting(setting_class) if setting == setting_class.UNDEFINED: logger.error('Sim {} has an UNDEFINED autonomy setting!', self.owner, owner='rez') return setting
def get_autonomous_availability_of_object(self, obj, autonomy_rule, off_lot_radius, sim_is_on_active_lot, reference_object=None): reference_object = self.owner if reference_object is None else reference_object if obj is self.owner: return True object_is_on_active_lot = obj.is_on_active_lot() if object_is_on_active_lot: if autonomy_rule == autonomy.autonomy_modifier.OffLotAutonomyRules.DEFAULT and not sim_is_on_active_lot: return False if autonomy_rule == autonomy.autonomy_modifier.OffLotAutonomyRules.OFF_LOT_ONLY: return False else: if autonomy_rule == autonomy.autonomy_modifier.OffLotAutonomyRules.ON_LOT_ONLY: return False if off_lot_radius == 0: return False if off_lot_radius > 0: delta = obj.position - reference_object.position if delta.magnitude() > off_lot_radius: return False if autonomy_rule != autonomy.autonomy_modifier.OffLotAutonomyRules.UNLIMITED and obj.is_sim and not object_is_on_active_lot: if self.owner.is_on_active_lot( tolerance=self.owner.get_off_lot_autonomy_tolerance()): return False autonomy_service = services.autonomy_service() target_delta = obj.intended_position - obj.position if target_delta.magnitude_squared( ) > autonomy_service.MAX_OPEN_STREET_ROUTE_DISTANCE_FOR_SOCIAL_TARGET_SQUARED: return False distance_from_me = obj.intended_position - self.owner.intended_position if distance_from_me.magnitude_squared( ) > autonomy_service.MAX_OPEN_STREET_ROUTE_DISTANCE_FOR_INITIATING_SOCIAL_SQUARED: return False if self.owner.locked_from_obj_by_privacy(obj): return False return True
def solve_motive(stat_type, opt_sim:OptionalTargetParam=None, _connection=None): sim = get_optional_target(opt_sim, _connection) if sim is None or stat_type is None: sims4.commands.output('Unable to identify Sim or Motive - invalid arguments.', _connection) return stat = sim.commodity_tracker.get_statistic(stat_type) if stat is None: sims4.commands.output('Unable to motive {} on the Sim .'.format(stat_type), _connection) return if not sim.queue.can_queue_visible_interaction(): sims4.commands.output('Interaction queue is full, cannot add anymore interactions.', _connection) return context = InteractionContext(sim, InteractionContext.SOURCE_AUTONOMY, priority.Priority.High, bucket=InteractionBucketType.DEFAULT) autonomy_request = autonomy.autonomy_request.AutonomyRequest(sim, autonomy_mode=autonomy.autonomy_modes.FullAutonomy, commodity_list=[stat], context=context, consider_scores_of_zero=True, posture_behavior=AutonomyPostureBehavior.IGNORE_SI_STATE, is_script_request=True, allow_opportunity_cost=False, autonomy_mode_label_override='AutoSolveMotive') selected_interaction = services.autonomy_service().find_best_action(autonomy_request) if selected_interaction is None: stat_str = '{}'.format(stat_type) commodity_interaction = CommodityTuning.BLADDER_SOLVING_FAILURE_INTERACTION if stat_str == "<class 'sims4.tuning.instances.motive_Energy'>": commodity_interaction = CommodityTuning.ENERGY_SOLVING_FAILURE_INTERACTION elif stat_str == "<class 'sims4.tuning.instances.motive_Fun'>": commodity_interaction = CommodityTuning.FUN_SOLVING_FAILURE_INTERACTION elif stat_str == "<class 'sims4.tuning.instances.motive_Hunger'>": commodity_interaction = CommodityTuning.HUNGER_SOLVING_FAILURE_INTERACTION elif stat_str == "<class 'sims4.tuning.instances.motive_Hygiene'>": commodity_interaction = CommodityTuning.HYGIENE_SOLVING_FAILURE_INTERACTION elif stat_str == "<class 'sims4.tuning.instances.motive_Social'>": commodity_interaction = CommodityTuning.SOCIAL_SOLVING_FAILURE_INTERACTION if not sim.queue.has_duplicate_super_affordance(commodity_interaction, sim, None): failure_aop = AffordanceObjectPair(commodity_interaction, None, commodity_interaction, None) failure_aop.test_and_execute(context) sims4.commands.output('Could not find a good interaction to solve {}.'.format(stat_type), _connection) return if sim.queue.has_duplicate_super_affordance(selected_interaction.affordance, sim, selected_interaction.target): sims4.commands.output('Duplicate Interaction in the queue.', _connection) return if not AffordanceObjectPair.execute_interaction(selected_interaction): sims4.commands.output('Failed to execute SI {}.'.format(selected_interaction), _connection) return sims4.commands.output('Successfully executed SI {}.'.format(selected_interaction), _connection)
def global_autonomy_state_off(_connection=None): services.autonomy_service().global_autonomy_settings.set_state_setting(autonomy.settings.AutonomyState.DISABLED)
def global_autonomy_randomization(randomization, _connection=None): autonomy_service = services.autonomy_service() true_randomization = _parse_randomization(randomization) if true_randomization is not None: autonomy_service.global_autonomy_settings.set_randomization_setting(true_randomization)
def run_test_autonomy_ping(self): autonomy_request = self._create_autonomy_request() selected_interaction = services.autonomy_service().find_best_action(autonomy_request) return selected_interaction
def global_autonomy_state(state, _connection=None): autonomy_service = services.autonomy_service() true_state = _parse_state(state) if true_state is not None: autonomy_service.global_autonomy_settings.set_state_setting(true_state)
def set_autonomy_for_active_sim_option(enabled, _connection=None): services.autonomy_service().set_autonomy_for_active_sim(enabled)