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