def __init__(self,
interaction,
operations,
operation_actions,
trigger_gain_on_start=False,
suppress_skill_bars=False,
sequence=DEFAULT):
super().__init__()
self._interaction = interaction
self._basic_content_operations = operations
if operation_actions is not None:
self._loot_operations = operation_actions.actions
self._alarm_interval = operation_actions.alarm_interval
else:
self._loot_operations = None
self._alarm_interval = StatisticOperation.STATIC_CHANGE_INTERVAL
self._alarm_handle = None
if sequence is DEFAULT:
sequence = soft_sleep_forever()
self._sequence = sequence
self._autonomy_modifiers = weakref.WeakKeyDictionary()
self._operations_on_alarm = []
self._change_helper = None
self._trigger_gain_on_start = trigger_gain_on_start
self._suppress_skill_bars = suppress_skill_bars
def _trigger_idle_animation(self, state, new_value, from_init):
if self._component_suppressed:
return
if new_value in self.idle_animation_map:
current_zone = services.current_zone()
if current_zone is None or from_init and current_zone.is_zone_loading:
return False
else:
new_animation = self.idle_animation_map[new_value]
self._stop_animation_element()
self._current_idle_state_value = new_value
if new_animation is not None:
sequence = ()
if new_animation.repeat:
self._wakeable_element = element_utils.soft_sleep_forever(
)
sequence = self._wakeable_element
animation_element = new_animation(self.owner,
sequence=sequence)
self._idle_animation_element = build_element(
(animation_element, flush_all_animations))
services.time_service().sim_timeline.schedule(
self._idle_animation_element)
return True
return False
def _register(self, autonomy_request):
if self._processor is None:
sim_timeline = services.time_service().sim_timeline
self._processor = sim_timeline.schedule(elements.GeneratorElement(self._process_gen))
sleep_element = element_utils.soft_sleep_forever()
autonomy_request.sleep_element = sleep_element
self.queue.append(autonomy_request)
autonomy_queue_logger.debug('Enqueuing {}', autonomy_request.sim)
return sleep_element
def _run_interaction_gen(self, timeline):
self._show_picker_dialog(self.sim, target_sim=self.sim, target=self.target)
yield from element_utils.run_child(timeline, element_utils.soft_sleep_forever())
if not self._picked_sim_ids:
return False
yield
self.adoption_action(self, self._picked_sim_ids)
return True
yield
def __init__(self, interaction, subject, categories, rate, sequence=DEFAULT):
super().__init__()
self._subject = subject
self._interaction = interaction
self._categories = set(categories)
self._rate = rate
if sequence is DEFAULT:
sequence = soft_sleep_forever()
self._sequence = sequence
self._affected_commodities = []
def _register(self, autonomy_request):
if self._processor is None:
sim_timeline = services.time_service().sim_timeline
self._processor = sim_timeline.schedule(
elements.GeneratorElement(self._process_gen))
sleep_element = element_utils.soft_sleep_forever()
autonomy_request.sleep_element = sleep_element
self.queue.append(autonomy_request)
autonomy_queue_logger.debug('Enqueuing {}', autonomy_request.sim)
return sleep_element
def _run_interaction_gen(self, timeline):
yield self._get_valid_choices_gen(timeline)
self._show_picker_dialog(self.sim, target_sim=self.sim, target=self.target)
yield element_utils.run_child(timeline, element_utils.soft_sleep_forever())
if self._picked_sim_id is None:
self.remove_liability(PaymentLiability.LIABILITY_TOKEN)
return False
picked_item_set = {self._picked_sim_id}
self.interaction_parameters['picked_item_ids'] = frozenset(picked_item_set)
self.push_tunable_continuation(self.actor_continuation, picked_item_ids=picked_item_set)
return True
def _run(self, timeline):
additional_tokens = (self._offspring_data,) + self._additional_tokens
if isinstance(self._offspring_data, SimInfo):
trait_overrides_for_baby = None
gender_overrides_for_baby = None
else:
trait_overrides_for_baby = self._offspring_data.traits
gender_overrides_for_baby = self._offspring_data.gender
self._dialog.show_dialog(self._on_response, additional_tokens=additional_tokens, trait_overrides_for_baby=trait_overrides_for_baby, gender_overrides_for_baby=gender_overrides_for_baby)
if self._result is None:
self.sleep_element = element_utils.soft_sleep_forever()
return timeline.run_child(self.sleep_element)
return self._result
def next_stage(self):
if self._progress == _StageProgress.Init:
timeline = services.time_service().sim_timeline
self._sim.schedule_element(timeline, self)
if self._progress == _StageProgress.Done:
raise RuntimeError('StageControllElement is past the point of sleeping')
if self._wakeable_element is not None:
raise RuntimeError("Attempting to get an element from next_stage on '{}' before consuming the previous one ({})".format(self, self._progress))
self._wakeable_element = element_utils.soft_sleep_forever()
if self._progress != _StageProgress.Sleeping:
sequence = self._wakeable_element
else:
sequence = element_utils.build_element([lambda _: self._wake(), self._wakeable_element])
sequence = element_utils.return_true_wrapper(element_utils.must_run(sequence))
return sequence
def _fill_and_send_save_game_protobufs_gen(self, timeline, slot_id, slot_name, auto_save_slot_id=None):
self.save_error_code = persistence_error_types.ErrorCodes.SETTING_SAVE_SLOT_DATA_FAILED
save_slot_data_msg = self.get_save_slot_proto_buff()
save_slot_data_msg.slot_id = slot_id
save_slot_data_msg.slot_name = slot_name
if services.active_household_id() is not None:
save_slot_data_msg.active_household_id = services.active_household_id()
sims4.core_services.service_manager.save_all_services(self, persistence_error_types.ErrorCodes.CORE_SERICES_SAVE_FAILED, save_slot_data=save_slot_data_msg)
self.save_error_code = persistence_error_types.ErrorCodes.SAVE_CAMERA_DATA_FAILED
camera.serialize(save_slot_data=save_slot_data_msg)
def on_save_complete(slot_id, success):
wakeable_element.trigger_soft_stop()
self.save_error_code = persistence_error_types.ErrorCodes.SAVE_TO_SLOT_FAILED
wakeable_element = element_utils.soft_sleep_forever()
persistence_module.run_persistence_operation(persistence_module.PersistenceOpType.kPersistenceOpSave, self._save_game_data_proto, slot_id, on_save_complete)
yield element_utils.run_child(timeline, wakeable_element)
if auto_save_slot_id is not None:
self.save_error_code = persistence_error_types.ErrorCodes.AUTOSAVE_TO_SLOT_FAILED
wakeable_element = element_utils.soft_sleep_forever()
persistence_module.run_persistence_operation(persistence_module.PersistenceOpType.kPersistenceOpSave, self._save_game_data_proto, auto_save_slot_id, on_save_complete)
yield element_utils.run_child(timeline, wakeable_element)
self.save_error_code = persistence_error_types.ErrorCodes.NO_ERROR
def _run(self, timeline):
additional_tokens = (self._offspring_data,)
if self._additional_tokens is not None:
additional_tokens = additional_tokens + self._additional_tokens
if isinstance(self._offspring_data, PregnancyOffspringData):
trait_overrides_for_baby = self._offspring_data.traits
gender_overrides_for_baby = self._offspring_data.gender
else:
trait_overrides_for_baby = None
gender_overrides_for_baby = None
self._dialog.show_dialog(on_response=self._on_response, additional_tokens=additional_tokens, trait_overrides_for_baby=trait_overrides_for_baby, gender_overrides_for_baby=gender_overrides_for_baby)
if self._result is None:
self.sleep_element = element_utils.soft_sleep_forever()
return timeline.run_child(self.sleep_element)
return self._result
def __init__(self,
interaction,
subject,
categories,
rate,
sequence=DEFAULT):
super().__init__()
self._subject = subject
self._interaction = interaction
self._categories = set(categories)
self._rate = rate
if sequence is DEFAULT:
sequence = soft_sleep_forever()
self._sequence = sequence
self._affected_commodities = []
def _run_interaction_gen(self, timeline):
yield self._get_valid_choices_gen(timeline)
self._show_picker_dialog(self.sim,
target_sim=self.sim,
target=self.target)
yield element_utils.run_child(timeline,
element_utils.soft_sleep_forever())
if self._picked_sim_id is None:
self.remove_liability(PaymentLiability.LIABILITY_TOKEN)
return False
picked_item_set = {self._picked_sim_id}
self.interaction_parameters['picked_item_ids'] = frozenset(
picked_item_set)
self.push_tunable_continuation(self.actor_continuation,
picked_item_ids=picked_item_set)
return True
def do_acquire(timeline):
key_data = mutex_data[key]
if key_data:
waiting_element = element_utils.soft_sleep_forever()
key_data.append(waiting_element)
yield from element_utils.run_child(timeline, waiting_element)
else:
key_data.append(None)
yield from element_utils.run_child(timeline, sequence)
key_data = mutex_data[key]
del key_data[0]
if key_data:
key_data[0].trigger_soft_stop()
else:
del mutex_data[key]
return True
yield
def __init__(self, interaction, operations, operation_actions, trigger_gain_on_start=False, sequence=DEFAULT):
super().__init__()
self._interaction = interaction
self._basic_content_operations = operations
if operation_actions is not None:
self._loot_operations = operation_actions.actions
self._alarm_interval = operation_actions.alarm_interval
else:
self._loot_operations = None
self._alarm_interval = StatisticOperation.STATIC_CHANGE_INTERVAL
self._alarm_handle = None
if sequence is DEFAULT:
sequence = soft_sleep_forever()
self._sequence = sequence
self._autonomy_modifiers = weakref.WeakKeyDictionary()
self._operations_on_alarm = []
self._change_helper = None
self._trigger_gain_on_start = trigger_gain_on_start
def _run(self, timeline):
self._dialog.show_dialog(additional_tokens=self._additional_tokens)
if self._result is None:
return timeline.run_child(element_utils.soft_sleep_forever())
return self._result
def _run(self, timeline):
self._dialog.show_dialog(additional_tokens=self._additional_tokens)
if self._result is None:
return timeline.run_child(element_utils.soft_sleep_forever())
return self._result
def _stage(self):
self._sleeping_element = element_utils.soft_sleep_forever()
stage_element = element_utils.build_critical_section_with_finally(
self._set_suspended, self._sleeping_element, self._end_suspended)
return element_utils.return_true_wrapper(
element_utils.must_run(stage_element))
def get_idle_element(self):
self._idle_element = soft_sleep_forever()
return (self._idle_element, self._cancel_idle_behavior)
def generate_path(self, timeline):
start_time = services.time_service().sim_now
ticks = 0
try:
self.path.status = routing.Path.PLANSTATUS_PLANNING
self.path.nodes.clear_route_data()
if not self.route.goals:
self.path.status = routing.Path.PLANSTATUS_FAILED
else:
for goal in self.route.goals:
self.path.add_goal(goal)
for origin in self.route.origins:
self.path.add_start(origin)
self.sim.on_plan_path(self.route.goals, True)
if self.path.nodes.make_path() is True:
def is_planning_done():
nonlocal ticks
ticks += 1
return not self.path.nodes.plan_in_progress
yield element_utils.run_child(timeline, elements.BusyWaitElement(soft_sleep_forever(), is_planning_done))
self.path.nodes.finalize(self._is_failure_route)
else:
self.path.status = routing.Path.PLANSTATUS_FAILED
new_route = routing.Route(self.route.origin, self.route.goals, additional_origins=self.route.origins, routing_context=self.route.context)
new_route.path.copy(self.route.path)
new_path = routing.Path(self.path.sim, new_route)
new_path.status = self.path.status
new_path._start_ids = self.path._start_ids
new_path._goal_ids = self.path._goal_ids
result_path = new_path
if len(new_path.nodes) > 0:
start_index = 0
current_index = 0
for n in self.path.nodes:
if n.portal_object_id != 0:
portal_object = services.object_manager(services.current_zone_id()).get(n.portal_object_id)
if portal_object is not None and portal_object.split_path_on_portal():
new_path.nodes.clip_nodes(start_index, current_index)
new_route = routing.Route(self.route.origin, self.route.goals, additional_origins=self.route.origins, routing_context=self.route.context)
new_route.path.copy(self.route.path)
next_path = routing.Path(self.path.sim, new_route)
next_path.status = self.path.status
next_path._start_ids = self.path._start_ids
next_path._goal_ids = self.path._goal_ids
new_path.next_path = next_path
new_path.portal = portal_object
new_path = next_path
start_index = current_index + 1
current_index = current_index + 1
new_path.nodes.clip_nodes(start_index, current_index - 1)
self.route = result_path.route
self.path = result_path
self.sim.on_plan_path(self.route.goals, False)
except Exception:
logger.exception('Exception in generate_path')
self.path.status = routing.Path.PLANSTATUS_FAILED
self.sim.on_plan_path(self.route.goals, False)
if self.path.status == routing.Path.PLANSTATUS_PLANNING:
self.path.set_status(routing.Path.PLANSTATUS_READY)
else:
self.path.set_status(routing.Path.PLANSTATUS_FAILED)
if gsi_handlers.routing_handlers.archiver.enabled:
gsi_handlers.routing_handlers.archive_plan(self.sim, self.path, ticks, (services.time_service().sim_now - start_time).in_real_world_seconds())
def _stage(self):
self._sleeping_element = element_utils.soft_sleep_forever()
stage_element = element_utils.build_critical_section_with_finally(self._set_suspended, self._sleeping_element, self._end_suspended)
return element_utils.return_true_wrapper(element_utils.must_run(stage_element))