def _route(timeline):
origin_location = sim.routing_location
if path.status == routing.Path.PLANSTATUS_READY:
if not FollowPath.should_follow_path(sim, path):
if callback_fn is not None:
result = callback_fn(0)
if result == FollowPath.Action.CANCEL:
return False
return True
distance_left = path.length()
if callback_fn is not None and distance_left < FollowPath.DISTANCE_TO_RECHECK_INUSE:
route_action = callback_fn(distance_left)
if route_action == FollowPath.Action.CANCEL:
return False
if sim.position != origin_location.position:
logger.error("Route-to-position has outdated starting location. Sim's position ({}) is {:0.2f}m from the original starting position ({})", sim.position, (sim.position - origin_location.position).magnitude(), origin_location.position)
follow_element = FollowPath(sim, path, callback_fn=callback_fn)
if path.is_route_fail():
if handle_failure:
yield element_utils.run_child(timeline, follow_element)
if lockout_target is not None:
sim.add_lockout(lockout_target, ReserveObjectHandler.LOCKOUT_TIME)
return Result.ROUTE_FAILED
critical_element = elements.WithFinallyElement(follow_element, lambda _: path.remove_from_quad_tree())
result = yield element_utils.run_child(timeline, critical_element)
return result
if lockout_target is not None:
sim.add_lockout(lockout_target, ReserveObjectHandler.LOCKOUT_TIME)
return Result.ROUTE_PLAN_FAILED
def do_transition_animation(timeline):
yield element_utils.run_child(timeline, do_auto_exit)
source.append_exit_to_arb(arb, self._dest_state, dest, self._var_map, locked_params=source_locked_params)
dest.append_transition_to_arb(arb, source, locked_params=dest_locked_params, posture_spec=dest_posture_spec)
dest_begin = dest.begin(arb, self._dest_state, self._context)
result = yield element_utils.run_child(timeline, [do_auto_exit, dest_begin])
return result
def _do_route_gen(timeline):
location = routing.Location(Vector3(x, y, z),
routing_surface=obj.routing_surface)
goal = routing.Goal(location)
routing_context = obj.get_routing_context()
route = routing.Route(obj.routing_location, (goal, ),
routing_context=routing_context)
plan_primitive = PlanRoute(route, obj)
result = yield from element_utils.run_child(timeline, plan_primitive)
if not result:
return result
yield
nodes = plan_primitive.path.nodes
if not (nodes and nodes.plan_success):
return False
yield
else:
follow_path_element = FollowPath(obj, plan_primitive.path)
result = yield from element_utils.run_child(
timeline, follow_path_element)
if not result:
return result
yield
return True
yield
def do_transition_animation(timeline):
yield from element_utils.run_child(timeline, do_auto_exit)
if PostureTrack.is_carry(
dest.track
) and dest.target is not None and dest.target.is_sim:
auto_exit_element = get_auto_exit((dest.target, ),
asm=source.asm)
if auto_exit_element is not None:
yield from element_utils.run_child(
timeline, auto_exit_element)
source.append_exit_to_arb(arb,
self._dest_state,
dest,
self._var_map,
locked_params=source_locked_params,
target_override=target_override)
dest.append_transition_to_arb(arb,
source,
locked_params=dest_locked_params,
posture_spec=dest_posture_spec,
target_override=target_override)
dest_begin = dest.begin(arb, self._dest_state, self._context,
new_routing_surface)
result = yield from element_utils.run_child(
timeline, [do_auto_exit, dest_begin])
return result
yield
def do_transition(timeline):
result = yield from element_utils.run_child(
timeline, transition)
if result:
if target.is_sim:
body_posture_type = sim.posture_state.spec.body.posture_type
if not body_posture_type.multi_sim:
post_transition_spec = sim.posture_state.spec.clone(
body=PostureAspectBody(
(body_posture_type, None)),
surface=PostureAspectSurface(
(None, None, None)))
post_posture_state = PostureState(
sim, sim.posture_state,
post_transition_spec, var_map)
post_posture_state.body.source_interaction = sim.posture.source_interaction
post_transition = PostureTransition(
post_posture_state.body,
post_posture_state,
sim.posture.posture_context, var_map)
post_transition.must_run = True
yield from element_utils.run_child(
timeline, post_transition)
interaction_target_was_target = False
si_target_was_target = False
new_posture.source_interaction = None
return True
yield
return False
yield
def _run_gen(self, timeline):
if self._duration_must_run > 0:
sequence = build_animation_drift_monitor_sequence(
self,
elements.SleepElement(
clock.interval_in_real_seconds(self._duration_must_run)))
yield from element_utils.run_child(timeline, sequence)
if self._stop_requested:
return False
yield
if self._duration_repeat > 0.0:
while True:
while not self._stop_requested:
yield from element_utils.run_child(
timeline,
elements.SleepElement(
clock.interval_in_real_seconds(
self._duration_repeat)))
elif self.enable_optional_sleep_time and self._duration_interrupt > 0:
then = timeline.now
yield from element_utils.run_child(
timeline,
elements.SoftSleepElement(
clock.interval_in_real_seconds(self._duration_interrupt)))
now = timeline.now
self._optional_time_elapsed = (now - then).in_real_world_seconds()
else:
yield from element_utils.run_child(
timeline, element_utils.sleep_until_next_tick_element())
return True
yield
def set_up_transition_gen(timeline):
(old_carry_posture, new_posture, _, transition, var_map) = create_exit_carry_posture(sim, target, interaction, use_posture_animations)
if transition is None:
yield element_utils.run_child(timeline, sequence)
return
exited_carry = False
if not use_posture_animations:
def event_handler_exit_carry(event_data):
nonlocal exited_carry
exited_carry = True
arb = animation.arb.Arb()
old_carry_posture.append_exit_to_arb(arb, None, new_posture, var_map, exit_while_holding=True)
new_posture.append_transition_to_arb(arb, old_carry_posture, in_xevt_handler=True)
ArbElement(arb, master=sim).distribute()
interaction.animation_context.register_event_handler(event_handler_exit_carry, handler_id=SCRIPT_EVENT_ID_STOP_CARRY)
if callback is not None:
interaction.animation_context.register_event_handler(callback, handler_id=SCRIPT_EVENT_ID_STOP_CARRY)
def maybe_do_transition(timeline):
if not use_posture_animations and not exited_carry:
event_handler_exit_carry(None)
if callback is not None:
callback()
if use_posture_animations or exited_carry:
interaction_target_was_target = False
si_target_was_target = False
if interaction.target == target:
interaction_target_was_target = True
interaction.set_target(None)
if old_carry_posture.target_is_transient and si.target == target:
si_target_was_target = True
si.set_target(None)
if carry_system_target is not None:
old_carry_posture.carry_system_target = carry_system_target
def do_transition(timeline):
result = yield element_utils.run_child(timeline, transition)
if result:
interaction_target_was_target = False
si_target_was_target = False
new_posture.source_interaction = None
return True
return False
def post_transition(_):
if interaction_target_was_target:
interaction.set_target(target)
if si_target_was_target:
si.set_target(target)
if carry_system_target is not None:
old_carry_posture.carry_system_target = None
yield element_utils.run_child(timeline, must_run(build_critical_section_with_finally(do_transition, post_transition)))
new_sequence = disable_asm_auto_exit(sim, sequence)
yield element_utils.run_child(timeline, build_critical_section(build_critical_section(new_sequence, flush_all_animations), maybe_do_transition))
def maybe_do_transition(timeline):
def push_si(_):
context = InteractionContext(sim, InteractionContext.SOURCE_POSTURE_GRAPH, si.priority, run_priority=si.run_priority, insert_strategy=QueueInsertStrategy.NEXT, must_run_next=True, group_id=si.group_id)
result = final_source_aop.interaction_factory(context)
if not result:
return result
final_source_interaction = result.interaction
si.acquire_posture_ownership(final_posture)
yield final_source_interaction.run_direct_gen(timeline)
final_posture.source_interaction = final_source_interaction
return result
if not got_callback:
event_handler_swap_carry(None)
if callback is not None:
callback()
if original_carry_posture.target_is_transient:
if interaction.target == original_carry_target:
interaction_target_was_target = True
interaction.set_target(None)
else:
interaction_target_was_target = False
if si.target == original_carry_target:
si_target_was_target = True
si.set_target(None)
else:
si_target_was_target = False
else:
interaction_target_was_target = False
si_target_was_target = False
if carry_system_target is not None:
original_carry_posture.carry_system_target = carry_system_target
def do_transition(timeline):
nonlocal interaction_target_was_target, si_target_was_target
result = yield element_utils.run_child(timeline, transition_to_carry_nothing)
if not result:
return False
interaction_target_was_target = False
si_target_was_target = False
carry_nothing_posture.source_interaction = None
return True
def post_transition(_):
if interaction_target_was_target:
interaction.set_target(original_carry_target)
if si_target_was_target:
si.set_target(original_carry_target)
if carry_system_target is not None:
original_carry_posture.carry_system_target = None
exit_carry_result = yield element_utils.run_child(timeline, must_run(build_critical_section_with_finally(do_transition, post_transition)))
if not (got_callback and exit_carry_result):
raise RuntimeError('[maxr] Failed to exit carry: {}'.format(original_carry_posture))
if got_callback:
context = si.context.clone_for_sim(sim)
yield element_utils.run_child(timeline, (PostureTransition(final_posture, final_posture_state, context, final_var_map), push_si))
def kickstart_linked_carried_posture_gen(self, timeline):
yield from element_utils.run_child(
timeline,
(self.target.posture.get_idle_behavior(), flush_all_animations))
begin_element = self._carried_linked_posture.get_begin(
Arb(), self.target.posture_state, self.target.routing_surface)
yield from element_utils.run_child(timeline, begin_element)
yield from self._carried_linked_posture.kickstart_source_interaction_gen(
timeline)
yield from element_utils.run_child(
timeline, self._carried_linked_previous_posture_state.body.end())
def _run_gen(self, timeline):
dest_state = self._dest_state
sim = dest_state.sim
source_state = sim.posture_state
dest_aspect = None
if source_state.body != dest_state.body:
dest_aspect = dest_state.body
if source_state.left != dest_state.left:
dest_aspect = dest_state.left
if source_state.right != dest_state.right:
dest_aspect = dest_state.right
def create_transition(dest_aspect):
reserve_target_interaction = None
if self._should_reserve:
reserve_target_interaction = self._reason_interaction_ref()
return PostureTransition(dest_aspect, dest_state, self._context,
self._var_map, self._transition_spec,
reserve_target_interaction,
self._destination_constraint)
if dest_aspect is None:
if source_state.body.mobile and dest_state.body.mobile:
self._transition = create_transition(dest_state.body)
transition_result = yield from element_utils.run_child(
timeline, self._transition)
if not transition_result:
return transition_result
yield
new_posture_spec = sim.posture_state.get_posture_spec(
self._var_map)
self._dest_state = PostureState(sim, sim.posture_state,
new_posture_spec, self._var_map)
dest_state = self._dest_state
sim.posture_state = dest_state
if self._source_interaction is not None:
dest_state.body.source_interaction = self._source_interaction
if self._owning_interaction_ref is not None:
self._owning_interaction_ref().acquire_posture_ownership(
dest_state.body)
yield from sim.si_state.notify_posture_change_and_remove_incompatible_gen(
timeline, source_state, dest_state)
return TestResult.TRUE
yield
if self._source_interaction is not None:
dest_aspect.source_interaction = self._source_interaction
if self._owning_interaction_ref is not None:
self._owning_interaction_ref().acquire_posture_ownership(
dest_aspect)
self._transition = create_transition(dest_aspect)
result = yield from element_utils.run_child(timeline, self._transition)
return result
yield
def _run_gen(self, timeline):
if self.pre_route_animation is not None:
animation_element = self.pre_route_animation(self._obj)
self._element = build_element(
(animation_element, flush_all_animations))
result = yield from element_utils.run_child(
timeline, self._element)
if not result:
return result
yield
def do_routes(timeline):
result = False
for route in self._route_data.get_routes_gen():
result = yield from self._do_single_route_gen(timeline, route)
if not result:
break
if not result:
yield from element_utils.run_child(
timeline, element_utils.sleep_until_next_tick_element())
return result
yield
if self.walkstyle_override is None:
yield from do_routes(timeline)
else:
walkstyle_request = self.walkstyle_override(self._obj)
yield from element_utils.run_child(
timeline, walkstyle_request(sequence=do_routes))
target = self._route_data.get_target()
if target:
if target.is_sim:
yield from self._route_data.do_target_action_rules_gen(
timeline)
else:
reservation_handler = target.get_reservation_handler(self._obj)
if reservation_handler and reservation_handler.may_reserve():
reservation_handler.begin_reservation()
try:
yield from self._route_data.do_target_action_rules_gen(
timeline)
finally:
reservation_handler.end_reservation()
else:
self._route_data.on_no_target()
resolver = SingleObjectResolver(self._obj)
for loot_action in self.completion_loot:
loot_action.apply_to_resolver(resolver)
return True
yield
def do_route_to_constraint(self, constraint, timeline):
goals = []
handles = constraint.get_connectivity_handles(self.sim)
for handle in handles:
goals.extend(handle.get_goals())
route = routing.Route(self.sim.routing_location, goals, routing_context=self.sim.routing_context)
plan_primitive = PlanRoute(route, self.sim)
result = yield element_utils.run_child(timeline, plan_primitive)
if not result:
return False
if not plan_primitive.path.nodes or not plan_primitive.path.nodes.plan_success:
return False
route = get_route_element_for_path(self.sim, plan_primitive.path)
result = yield element_utils.run_child(timeline, with_walkstyle(self.sim, WalkStyle.JOG, self.id, sequence=route, priority=self.WALKSTYLE_PRIORITY))
return result
def behavior_element(self, timeline):
total_constraint = ANYWHERE
for (relative_participant,
constraints) in self.route_constraints.items():
relative_object = self.interaction.get_participant(
relative_participant)
if relative_object is None:
continue
for constraint in constraints:
relative_constraint = constraint.create_constraint(
self.interaction.sim,
relative_object,
objects_to_ignore=[relative_object])
total_constraint = total_constraint.intersect(
relative_constraint)
if not total_constraint.valid:
logger.error(
'Routing Element cannot resolve constraints for {}',
self.interaction)
return False
yield
sim = self.interaction.sim
goals = []
handles = total_constraint.get_connectivity_handles(sim)
for handle in handles:
goals.extend(handle.get_goals())
if not goals:
return False
yield
route = routing.Route(sim.routing_location,
goals,
routing_context=sim.routing_context)
plan_primitive = PlanRoute(route, sim, interaction=self.interaction)
result = yield from element_utils.run_child(timeline, plan_primitive)
if not result:
return False
yield
if not (plan_primitive.path.nodes
and plan_primitive.path.nodes.plan_success):
return False
yield
route = get_route_element_for_path(sim,
plan_primitive.path,
interaction=self.interaction)
result = yield from element_utils.run_child(
timeline, build_critical_section(route))
return result
yield
def _run_gen(self, timeline):
try:
self._start_statistic_gains()
result = yield element_utils.run_child(timeline, self._sequence)
return result
finally:
self._end_statistic_gains()
def maybe_do_transition(timeline):
if not use_posture_animations and not exited_carry:
event_handler_exit_carry(None)
if callback is not None:
callback()
if use_posture_animations or exited_carry:
interaction_target_was_target = False
si_target_was_target = False
if interaction.target == target:
interaction_target_was_target = True
interaction.set_target(None)
if old_carry_posture.target_is_transient and si.target == target:
si_target_was_target = True
si.set_target(None)
if carry_system_target is not None:
old_carry_posture.carry_system_target = carry_system_target
def do_transition(timeline):
result = yield element_utils.run_child(timeline, transition)
if result:
interaction_target_was_target = False
si_target_was_target = False
new_posture.source_interaction = None
return True
return False
def post_transition(_):
if interaction_target_was_target:
interaction.set_target(target)
if si_target_was_target:
si.set_target(target)
if carry_system_target is not None:
old_carry_posture.carry_system_target = None
yield element_utils.run_child(timeline, must_run(build_critical_section_with_finally(do_transition, post_transition)))
def _do(timeline):
nonlocal outcome_sequence
self.outcome.decide(self)
if self.outcome_result == OutcomeResult.FAILURE:
outcome_sequence = self.death_element(self, sequence=outcome_sequence)
result = yield element_utils.run_child(timeline, outcome_sequence)
return result
def _do_behavior(timeline):
target = self.interaction.get_participant(self.participant)
if target is None:
return False
target.fade_out()
timespan = date_and_time.create_time_span(
minutes=target.FADE_DURATION)
yield element_utils.run_child(timeline,
elements.SleepElement(timespan))
sim = self.interaction.sim
target.set_household_owner_id(sim.household_id)
replace_reserve = False
if target.in_use_by(sim, owner=self.interaction):
target.release(sim, self.interaction)
replace_reserve = True
try:
if target == self.interaction.target:
self.interaction.set_target(None)
if self.use_sim_inventory:
sim.inventory_component.system_add_object(target, sim)
else:
build_buy.move_object_to_household_inventory(target)
finally:
target.opacity = 1
if replace_reserve:
target.reserve(sim, self.interaction)
return True
def maybe_do_transition_gen(timeline):
def push_si_gen(timeline):
context = InteractionContext(sim, InteractionContext.SOURCE_POSTURE_GRAPH, si.priority, run_priority=si.run_priority, insert_strategy=QueueInsertStrategy.NEXT, must_run_next=True, group_id=si.group_id)
result = new_source_aop.interaction_factory(context)
if not result:
return result
source_interaction = result.interaction
new_posture.source_interaction = source_interaction
owning_interaction = None
if create_si_fn is not None:
(aop, context) = create_si_fn()
if aop is not None and context is not None and aop.test(context):
result = aop.interaction_factory(context)
if result:
owning_interaction = result.interaction
owning_interaction.acquire_posture_ownership(new_posture)
aop.execute_interaction(owning_interaction)
if owning_interaction is None:
si.acquire_posture_ownership(new_posture)
yield source_interaction.run_direct_gen(timeline)
return result
def call_callback(_):
if callback is not None:
callback(new_posture, new_posture.source_interaction)
if got_callback:
result = yield element_utils.run_child(timeline, must_run([PostureTransition(new_posture, new_posture_state, context, var_map), push_si_gen, call_callback]))
return result
return True
def unholster(timeline):
if carry_object.is_sim:
return
if not carry_posture.holster_count:
return
arb_unholster = animation.arb.Arb()
def start_carry(*_, **__):
idle_arb = animation.arb.Arb()
carry_posture.asm.request(carry_posture._state_name, idle_arb)
distribute_arb_element(idle_arb)
arb_unholster.register_event_handler(
start_carry, handler_id=SCRIPT_EVENT_ID_START_CARRY)
carry_posture.asm.context.register_custom_event_handler(
functools.partial(hide_held_props, carry_posture.sim),
None,
0,
allow_stub_creation=True)
carry_posture.asm.set_current_state('entry')
carry_posture.asm.request(carry_posture._enter_state_name,
arb_unholster)
unholster_element = create_run_animation(arb_unholster)
if flush_before_sequence:
unholster_element = (unholster_element, flush_all_animations)
yield from element_utils.run_child(timeline, unholster_element)
def _complete_pregnancy_gen(self, timeline, pregnancy_tracker):
is_off_lot_birth = False
for offspring_data in pregnancy_tracker.get_offspring_data_gen():
sim_info = pregnancy_tracker.create_sim_info(offspring_data)
current_zone = services.current_zone()
if current_zone.id == sim_info.zone_id:
create_and_place_baby(sim_info, ignore_daycare=True)
else:
is_off_lot_birth = True
offspring_count = pregnancy_tracker.offspring_count
pregnancy_tracker.complete_pregnancy()
pregnancy_tracker.clear_pregnancy()
if is_off_lot_birth:
travel_liability = TravelSimLiability(self, self.sim.sim_info, self.sim.sim_info.household.home_zone_id, expecting_dialog_response=True)
self.add_liability(TRAVEL_SIM_LIABILITY, travel_liability)
def on_travel_dialog_response(dialog):
if dialog.accepted:
save_lock_liability = self.get_liability(SaveLockLiability.LIABILITY_TOKEN)
if save_lock_liability is not None:
save_lock_liability.release()
travel_liability.travel_dialog_response(dialog)
travel_dialog_element = UiDialogElement(self.sim, self.get_resolver(), dialog=self.off_lot_birth_dialog, on_response=on_travel_dialog_response, additional_tokens=(offspring_count,))
result = yield element_utils.run_child(timeline, travel_dialog_element)
return result
return True
def posture_change(timeline):
posture.log_info(
'Change',
msg='{}'.format(posture.track.name if posture.
track is not None else 'NO TRACK!'))
prev_posture_state = sim.posture_state
prev_posture = prev_posture_state.get_aspect(posture.track)
sim.posture_state = self._dest_state
sim.on_posture_event(PostureEvent.POSTURE_CHANGED,
self._dest_state, posture.track, prev_posture,
posture)
if sim.routing_surface != self._routing_surface:
sim.move_to(routing_surface=self._routing_surface)
yield from sim.si_state.notify_posture_change_and_remove_incompatible_gen(
timeline, prev_posture_state, self._dest_state)
prev_posture.clear_owning_interactions()
if multi_sim_posture_transition:
linked_posture_begin = posture.linked_posture.begin(
self._animate_in, self._dest_state.linked_posture_state,
posture._context, self._routing_surface)
self._dest_state = None
yield from element_utils.run_child(timeline,
linked_posture_begin)
else:
self._dest_state = None
return True
yield
def _trigger_phone_call_gen(self, timeline):
client = services.client_manager().get_first_client()
if client is None:
return
client_household = client.household
if client_household is None:
return
sims_to_check = [sim for sim in client_household.instanced_sims_gen()]
random.shuffle(sims_to_check)
for sim in sims_to_check:
call_types = []
ask_to_come_over_phone_call = HouseholdManager.PHONE_CALL_INFO.ask_to_come_over(sim)
call_types.append((ask_to_come_over_phone_call.weight, ask_to_come_over_phone_call))
chat_phone_call = HouseholdManager.PHONE_CALL_INFO.chat(sim)
call_types.append((chat_phone_call.weight, chat_phone_call))
invite_over_phone_call = HouseholdManager.PHONE_CALL_INFO.invite_over(sim)
call_types.append((invite_over_phone_call.weight, invite_over_phone_call))
while call_types:
call_type = pop_weighted(call_types)
if call_type.try_and_setup():
call_type.execute()
self._phone_call_element = None
return
yield element_utils.run_child(timeline, element_utils.sleep_until_next_tick_element())
self._phone_call_element = None
def _do_behavior(timeline):
target = self.interaction.get_participant(self.participant)
if target is None:
return False
target.fade_out()
timespan = date_and_time.create_time_span(minutes=target.FADE_DURATION)
yield element_utils.run_child(timeline, elements.SleepElement(timespan))
sim = self.interaction.sim
target.set_household_owner_id(sim.household_id)
replace_reserve = False
if target.in_use_by(sim, owner=self.interaction):
target.release(sim, self.interaction)
replace_reserve = True
try:
if target == self.interaction.target:
self.interaction.set_target(None)
if self.use_sim_inventory:
sim.inventory_component.system_add_object(target, sim)
else:
build_buy.move_object_to_household_inventory(target)
finally:
target.opacity = 1
if replace_reserve:
target.reserve(sim, self.interaction)
return True
def _run_gen(self, timeline):
try:
self._start_statistic_gains()
result = yield element_utils.run_child(timeline, self._sequence)
return result
finally:
self._end_statistic_gains()
def holster(timeline):
def stop_carry(*_, **__):
idle_arb = animation.arb.Arb()
carry_nothing_posture.asm.request(
carry_nothing_posture._state_name, idle_arb)
ArbElement(idle_arb).distribute()
arb_holster = animation.arb.Arb()
arb_holster.register_event_handler(
stop_carry, handler_id=SCRIPT_EVENT_ID_STOP_CARRY)
carry_posture.asm.context.register_custom_event_handler(
functools.partial(hide_held_props, carry_posture.sim),
None,
0,
allow_stub_creation=True)
setup_asm_fn_carry = _get_holstering_setup_asm_func(
carry_posture, carry_object)
setup_asm_fn_carry(carry_posture.asm)
carry_posture.asm.request(carry_posture._exit_state_name, arb_holster)
carry_nothing_posture.setup_asm_posture(carry_nothing_posture.asm,
carry_nothing_posture.sim,
None)
setup_asm_fn_carry_nothing = _get_holstering_setup_asm_func(
carry_nothing_posture, carry_object)
setup_asm_fn_carry_nothing(carry_nothing_posture.asm)
carry_nothing_posture.asm.request(
carry_nothing_posture._enter_state_name, arb_holster)
holster_element = create_run_animation(arb_holster)
if flush_before_sequence:
holster_element = (holster_element, flush_all_animations)
yield element_utils.run_child(timeline, holster_element)
def process_request_gen(self, timeline):
(household_population_data, neighborhood_proto) = self._get_region_household_population_data_and_neighborhood_proto()
if not (household_population_data or self._try_existing_households):
logger.debug('There is no HouseholdPopulationRegionData for region: {}', neighborhood_proto.region_id)
return
while self._num_to_fill > 0:
while self._available_zone_ids:
zone_id = self._available_zone_ids.pop(random.randint(0, len(self._available_zone_ids) - 1))
templates_and_bed_data = self._get_household_templates_and_bed_data(zone_id, household_population_data)
(household_templates, total_beds, lot_has_double_bed, lot_has_kid_bed) = templates_and_bed_data
if total_beds <= 0:
continue
moved_household_into_zone = False
if self._try_existing_households:
weighted_households = self._get_available_households(total_beds, lot_has_double_bed, lot_has_kid_bed)
if household_templates:
ideal_household_curve = NeighborhoodPopulationService.NUM_BEDS_TO_IDEAL_HOUSEHOLD_CURVE.get(total_beds, None)
if ideal_household_curve is not None:
ideal_household_weight = next(iter(sorted(ideal_household_curve.points, key=operator.itemgetter(1), reverse=True)))
weighted_households.append((ideal_household_weight[1], GENERATE_HOUSEHOLD_ID))
if weighted_households:
household_id = sims4.random.weighted_random_item(weighted_households)
if household_id != GENERATE_HOUSEHOLD_ID:
household = services.household_manager().get(household_id)
if household is not None:
self._move_household_into_zone(household, neighborhood_proto, zone_id)
moved_household_into_zone = True
if not moved_household_into_zone and household_templates:
moved_household_into_zone = self._add_household_template_to_zone(household_templates, total_beds, lot_has_double_bed, lot_has_kid_bed, neighborhood_proto, zone_id)
if moved_household_into_zone:
pass
yield element_utils.run_child(timeline, element_utils.sleep_until_next_tick_element())
def _run_gen(self, timeline):
if not self._arb_element_sequence:
return True
duration_must_run = 0
for arb_element in self._arb_element_sequence:
(arb_duration_total, arb_duration_must_run, arb_duration_repeat) = arb_element.arb.get_timing()
arb_duration_interrupt = arb_duration_total - arb_duration_must_run
duration_must_run += arb_duration_must_run
arb_element.distribute()
duration_interrupt = arb_duration_interrupt
duration_repeat = arb_duration_repeat
if ArbAccumulatorService.MAXIMUM_TIME_DEBT > 0:
actors = _get_actors_for_arb_element_sequence(self._arb_element_sequence, main_timeline_only=True)
arb_accumulator = services.current_zone().arb_accumulator_service
time_debt_max = arb_accumulator.get_time_debt(actors)
shave_time_actual = arb_accumulator.get_shave_time_given_duration_and_debt(duration_must_run, time_debt_max)
duration_must_run -= shave_time_actual
for actor in actors:
time_debt = arb_accumulator.get_time_debt((actor,))
time_debt += shave_time_actual
arb_accumulator.set_time_debt((actor,), time_debt)
animation_sleep_element = AnimationSleepElement(duration_must_run, duration_interrupt, duration_repeat)
if not self._animate_instantly:
yield element_utils.run_child(timeline, animation_sleep_element)
optional_time_elapsed = animation_sleep_element.optional_time_elapsed
if ArbAccumulatorService.MAXIMUM_TIME_DEBT > 0 and optional_time_elapsed > 0:
while True:
for actor in actors:
time_debt = arb_accumulator.get_time_debt((actor,))
new_time_debt = time_debt - optional_time_elapsed
new_time_debt = max(new_time_debt, 0)
arb_accumulator.set_time_debt((actor,), new_time_debt)
return True
def end_posture_on_same_track(timeline):
if self._prev_posture is not None and self._prev_posture is not posture:
prev_posture = self._prev_posture
self._prev_posture = None
result = yield element_utils.run_child(timeline, build_element(prev_posture.end()))
return result
return True
def end_body_aspect(_timeline):
if previous_posture_state.body:
result = yield from element_utils.run_child(_timeline, previous_posture_state.body.end())
if not result:
return result
yield
return True
yield
def end_posture_on_same_track(timeline):
if self._prev_posture is not None and self._prev_posture is not posture:
prev_posture = self._prev_posture
self._prev_posture = None
result = yield element_utils.run_child(
timeline, build_element(prev_posture.end()))
return result
return True
def _do_single_route_gen(self, timeline, route):
if not route:
yield from self._route_data.do_route_fail_gen(timeline)
return True
yield
self._element = plan_primitive = PlanRoute(route, self._obj)
result = yield from element_utils.run_child(timeline, plan_primitive)
if not result:
return result
yield
nodes = plan_primitive.path.nodes
if not (nodes and nodes.plan_success):
yield from self._route_data.do_route_fail_gen(timeline)
return True
yield
if self._canceled:
return False
yield
plan_primitive.path.blended_orientation = self._route_data.get_randomize_orientation(
)
mask_override = None
track_override = None
if self.clear_locomotion_mask:
mask_override = 0
track_override = 9999
self._element = follow_path_element = FollowPath(
self._obj,
plan_primitive.path,
track_override=track_override,
mask_override=mask_override)
result = yield from element_utils.run_child(timeline,
follow_path_element)
if not result:
return result
yield
if self._canceled:
return False
yield
for action in self.actions:
result = yield from action.run_action_gen(
timeline, self._obj, self._route_data.get_target())
if not result:
return result
yield
return True
yield
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 do_transition(timeline):
result = yield element_utils.run_child(timeline, transition)
if result:
interaction_target_was_target = False
si_target_was_target = False
new_posture.source_interaction = None
return True
return False
def grab_sequence(timeline):
nonlocal sequence
sequence = super_build_basic_content(sequence)
if swap_carry:
sequence = swap_carry_while_holding(self, self._original_carry_target, self.created_target, callback=self._object_create_helper.claim, sequence=sequence)
else:
sequence = enter_carry_while_holding(self, self.created_target, callback=self._object_create_helper.claim, create_si_fn=None, sequence=sequence)
result = yield element_utils.run_child(timeline, sequence)
def _do(timeline):
nonlocal outcome_sequence
self.outcome.decide(self)
if self.outcome_result == OutcomeResult.FAILURE:
outcome_sequence = self.death_element(
self, sequence=outcome_sequence)
result = yield element_utils.run_child(timeline, outcome_sequence)
return result
def process_request_gen(self, timeline):
households = [(template_data.weight, template_data.household_template) for template_data in NeighborhoodPopulationService.HOMELESS_HOUSEHOLD_TEMPLATES]
if not households:
return
while self._num_to_fill > 0:
household_template = sims4.random.weighted_random_item(households)
self._create_household_from_template_and_add_to_zone(household_template, None, 0, creation_source='neigh_pop_service: homeless')
yield element_utils.run_child(timeline, element_utils.sleep_until_next_tick_element())
def _do_transition_failure(timeline):
if source_interaction_target is not None:
sim.add_lockout(source_interaction_target, autonomy.autonomy_modes.AutonomyMode.LOCKOUT_TIME)
if transition_interaction is None:
return
if transition_interaction.context.source == InteractionSource.AUTONOMY:
return
yield element_utils.run_child(timeline, route_failure(sim, transition_interaction, failure_reason, failure_object_id))
def maybe_do_transition_gen(timeline):
def push_si_gen(timeline):
context = InteractionContext(
sim,
InteractionContext.SOURCE_POSTURE_GRAPH,
si.priority
if priority_override is None else priority_override,
run_priority=si.run_priority
if priority_override is None else priority_override,
insert_strategy=QueueInsertStrategy.FIRST,
must_run_next=True,
group_id=si.group_id)
result = new_source_aop.interaction_factory(context)
if not result:
return result
yield
source_interaction = result.interaction
new_posture.source_interaction = source_interaction
owning_interaction = None
if create_si_fn is not None:
(aop, context) = create_si_fn()
if aop is not None:
if context is not None:
if aop.test(context):
result = aop.interaction_factory(context)
if result:
owning_interaction = result.interaction
if owning_interaction is None:
si.acquire_posture_ownership(new_posture)
yield from source_interaction.run_direct_gen(timeline)
else:
owning_interaction.acquire_posture_ownership(new_posture)
aop.execute_interaction(owning_interaction)
new_source_aop.execute_interaction(source_interaction)
if target_posture_state is not None:
yield from new_posture.kickstart_linked_carried_posture_gen(
timeline)
return result
yield
def call_callback(_):
if callback is not None:
callback(new_posture, new_posture.source_interaction)
if got_callback:
if target_posture_state is not None:
obj.posture_state = target_posture_state
result = yield from element_utils.run_child(
timeline,
must_run([
PostureTransition(new_posture, new_posture_state,
context, var_map), push_si_gen,
call_callback
]))
return result
yield
return True
yield
def _do_route_to_constraint_gen(self, waypoints, timeline):
if self.is_finishing:
return False
yield
plan_primitives = []
for (i, routing_info) in enumerate(self._routing_infos):
routing_agent = routing_info[0]
routing_context = routing_info[1]
route = routing.Route(routing_agent.routing_location, waypoints[-1], waypoints=waypoints[:-1], routing_context=routing_context)
plan_primitive = PlanRoute(route, routing_agent, interaction=self)
result = yield from element_utils.run_child(timeline, plan_primitive)
if not result:
self._show_route_fail_balloon()
return False
yield
if not (plan_primitive.path.nodes and plan_primitive.path.nodes.plan_success):
self._show_route_fail_balloon()
return False
yield
plan_primitive.path.blended_orientation = self.waypoint_randomize_orientation
plan_primitives.append(plan_primitive)
if i == len(self._routing_infos) - 1:
continue
for node in plan_primitive.path.nodes:
position = Vector3(*node.position)
for goal in itertools.chain.from_iterable(waypoints):
if goal.routing_surface_id != node.routing_surface_id:
continue
dist_sq = (Vector3(*goal.position) - position).magnitude_2d_squared()
if dist_sq < self._goal_size:
goal.cost = routing.get_default_obstacle_cost()
route_primitives = []
track_override = None
mask_override = None
if self.waypoint_clear_locomotion_mask:
mask_override = 0
track_override = 9999
for plan_primitive in plan_primitives:
sequence = get_route_element_for_path(plan_primitive.sim, plan_primitive.path, interaction=self, force_follow_path=True, track_override=track_override, mask_override=mask_override)
walkstyle_request = self.waypoint_walk_style(plan_primitive.sim)
sequence = walkstyle_request(sequence=sequence)
route_primitives.append(sequence)
result = yield from element_utils.run_child(timeline, do_all(*route_primitives))
return result
yield
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 _run_interaction_gen(self, timeline):
self.sim.on_slot = None
result = yield super()._run_interaction_gen(timeline)
if not result:
return False
if self._run_element is not None:
result = yield element_utils.run_child(timeline, self._run_element)
return result
return True
def _run_interaction_gen(self, timeline):
self.sim.on_slot = None
result = yield super()._run_interaction_gen(timeline)
if not result:
return False
if self._run_element is not None:
result = yield element_utils.run_child(timeline, self._run_element)
return result
return True
def crafting_sequence(timeline):
nonlocal sequence
sequence = super_build_basic_content(sequence, **kwargs)
sequence = build_critical_section(sequence, flush_all_animations)
sequence = self._build_sequence_with_callback(callback,
sequence=sequence)
result = yield from element_utils.run_child(timeline, sequence)
return result
yield
def do_transition(timeline):
nonlocal interaction_target_was_target, si_target_was_target
result = yield element_utils.run_child(timeline, transition_to_carry_nothing)
if not result:
return False
interaction_target_was_target = False
si_target_was_target = False
carry_nothing_posture.source_interaction = None
return True
def do_transition(timeline):
result = yield element_utils.run_child(
timeline, transition)
if result:
interaction_target_was_target = False
si_target_was_target = False
new_posture.source_interaction = None
return True
return False
def set_up_transition_gen(timeline):
nonlocal sequence
(new_posture_state, new_posture, new_source_aop, var_map) = create_enter_carry_posture(sim, sim.posture_state, obj, track)
got_callback = False
def event_handler_enter_carry(event_data):
nonlocal got_callback
if got_callback:
logger.warn('Animation({}) calling to start a carry multiple times', event_data.event_data.get('clip_name'))
return
got_callback = True
arb = animation.arb.Arb()
locked_params = new_posture.get_locked_params(None)
old_carry_posture = sim.posture_state.get_aspect(track)
if old_carry_posture is not None:
old_carry_posture.append_exit_to_arb(arb, new_posture_state, new_posture, var_map)
new_posture.append_transition_to_arb(arb, old_carry_posture, locked_params=locked_params, in_xevt_handler=True)
ArbElement(arb).distribute()
si.animation_context.register_event_handler(event_handler_enter_carry, handler_id=SCRIPT_EVENT_ID_START_CARRY)
def maybe_do_transition_gen(timeline):
def push_si_gen(timeline):
context = InteractionContext(sim, InteractionContext.SOURCE_POSTURE_GRAPH, si.priority, run_priority=si.run_priority, insert_strategy=QueueInsertStrategy.NEXT, must_run_next=True, group_id=si.group_id)
result = new_source_aop.interaction_factory(context)
if not result:
return result
source_interaction = result.interaction
new_posture.source_interaction = source_interaction
owning_interaction = None
if create_si_fn is not None:
(aop, context) = create_si_fn()
if aop is not None and context is not None and aop.test(context):
result = aop.interaction_factory(context)
if result:
owning_interaction = result.interaction
owning_interaction.acquire_posture_ownership(new_posture)
aop.execute_interaction(owning_interaction)
if owning_interaction is None:
si.acquire_posture_ownership(new_posture)
yield source_interaction.run_direct_gen(timeline)
return result
def call_callback(_):
if callback is not None:
callback(new_posture, new_posture.source_interaction)
if got_callback:
result = yield element_utils.run_child(timeline, must_run([PostureTransition(new_posture, new_posture_state, context, var_map), push_si_gen, call_callback]))
return result
return True
sequence = disable_asm_auto_exit(sim, sequence)
with si.cancel_deferred((si,)):
yield element_utils.run_child(timeline, must_run(build_critical_section(build_critical_section(sequence, flush_all_animations), maybe_do_transition_gen)))
def _get_valid_choices_gen(self, timeline):
self.sim_ids = []
requesting_sim_info = self.sim.sim_info
blacklist = {sim_info.id for sim_info in services.sim_info_manager().instanced_sims_gen(allow_hidden_flags=ALL_HIDDEN_REASONS)}
for sim_filter in self.sim_filters:
for _ in range(sim_filter.number_of_sims):
sim_infos = services.sim_filter_service().submit_matching_filter(1, sim_filter.filter, None, blacklist_sim_ids=blacklist, requesting_sim_info=requesting_sim_info, allow_yielding=False, zone_id=0)
for sim_info in sim_infos:
self.sim_ids.append(sim_info.id)
blacklist.add(sim_info.id)
yield element_utils.run_child(timeline, element_utils.sleep_until_next_tick_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 _with_skippable_animation_time(timeline):
game_clock_service = services.game_clock_service()
then = game_clock_service.now()
yield element_utils.run_child(timeline, sequence)
now = game_clock_service.now()
duration = (now - then).in_real_world_seconds()
arb_accumulator = services.current_zone().arb_accumulator_service
for actor in actors:
time_debt = arb_accumulator.get_time_debt((actor,))
new_time_debt = max(0, time_debt - duration)
arb_accumulator.set_time_debt((actor,), new_time_debt)
def _create_constraint_set(self, sim, timeline):
orient = sims4.math.Quaternion.IDENTITY()
positions = services.current_zone().lot.corners
position = positions[0]
goals = []
for pos in positions:
while not sims4.geometry.test_point_in_compound_polygon(pos, self._privacy.constraint.geometry.polygon):
goals.append(routing.Goal(routing.Location(pos, orient, sim.routing_surface)))
if not goals:
return Nowhere()
route = routing.Route(sim.routing_location, goals, routing_context=sim.routing_context)
plan_primitive = PlanRoute(route, sim, reserve_final_location=False)
yield element_utils.run_child(timeline, plan_primitive)
max_distance = self._privacy._max_line_of_sight_radius*self._privacy._max_line_of_sight_radius*4
nodes = plan_primitive.path.nodes
if nodes:
previous_node = nodes[0]
for node in nodes:
node_vector = sims4.math.Vector3(node.position[0], node.position[1], node.position[2])
if not sims4.geometry.test_point_in_compound_polygon(node_vector, self._privacy.constraint.geometry.polygon):
position = node_vector
if node.portal_id != 0:
pass
circle_constraint = interactions.constraints.Circle(position, self.TRIVIAL_SHOO_RADIUS, node.routing_surface_id)
if circle_constraint.intersect(self._privacy.constraint).valid:
pass
break
previous_node = node
position2 = sims4.math.Vector3(previous_node.position[0], previous_node.position[1], previous_node.position[2])
if (position - position2).magnitude_2d_squared() > max_distance:
position = self._find_close_position(position, position2)
elif (position - sim.position).magnitude_2d_squared() > max_distance:
position = self._find_close_position(position, sim.position)
p1 = position
p2 = self._privacy.central_object.position
forward = sims4.math.vector_normalize(p1 - p2)
radius_min = 0
radius_max = self._privacy._SHOO_CONSTRAINT_RADIUS
angle = sims4.math.PI
(cone_geometry, scoring_functions) = build_weighted_cone(position, forward, radius_min, radius_max, angle, ideal_radius_min=0, ideal_radius_max=0, ideal_angle=1)
subtracted_cone_polygon_list = []
for cone_polygon in cone_geometry.polygon:
for privacy_polygon in self._privacy.constraint.geometry.polygon:
subtracted_cone_polygons = cone_polygon.subtract(privacy_polygon)
while subtracted_cone_polygons:
subtracted_cone_polygon_list.extend(subtracted_cone_polygons)
compound_subtracted_cone_polygon = sims4.geometry.CompoundPolygon(subtracted_cone_polygon_list)
subtracted_cone_geometry = sims4.geometry.RestrictedPolygon(compound_subtracted_cone_polygon, [])
subtracted_cone_constraint = Constraint(geometry=subtracted_cone_geometry, scoring_functions=scoring_functions, routing_surface=sim.routing_surface, debug_name='ShooedSimsCone', los_reference_point=position)
point_cost = 5
point_constraint = interactions.constraints.Position(position, routing_surface=sim.routing_surface)
point_constraint = point_constraint.generate_constraint_with_cost(point_cost)
constraints = (subtracted_cone_constraint, point_constraint)
return interactions.constraints.create_constraint_set(constraints, debug_name='ShooPositions')
def defer_cancel_around_sequence_gen(s, timeline):
deferred_sis = []
for sim in self.required_sims():
while not (sim is self.sim or self.social_group is None):
if sim not in self.social_group:
pass
sis = self.social_group.get_sis_registered_for_sim(sim)
while sis:
deferred_sis.extend(sis)
with self.super_interaction.cancel_deferred(deferred_sis):
result = yield element_utils.run_child(timeline, s)
return result
def _do_renames_gen(self, timeline, all_offspring, additional_tokens=()):
offspring_index = 0
while offspring_index < len(all_offspring):
offspring_data = all_offspring[offspring_index]
dialog = self._get_name_dialog()
rename_element = RenameDialogElement(dialog, offspring_index, offspring_data, additional_tokens=additional_tokens)
result = yield element_utils.run_child(timeline, rename_element)
if not result:
self.cancel(FinishingType.DIALOG, cancel_reason_msg='Time out or missing first/last name')
return False
offspring_index += 1
return True
def _run_gen(self, timeline):
if self.canceled:
return
self._work_entry.running = True
try:
logger.debug('STARTING WORK: {}', self._work_entry)
self._master_controller._gsi_add_sim_time_line_entry(self._work_entry, 'Run', 'Calling work')
yield element_utils.run_child(timeline, self._work_element)
finally:
logger.debug('FINISHED WORK: {}', self._work_entry)
self._work_entry.remove_from_master_controller()
self._work_entry.running = False
self._master_controller._process(*self._work_entry.resources)
def _run_gen(self, timeline):
dest_state = self._dest_state
sim = dest_state.sim
source_state = sim.posture_state
dest_aspect = None
if source_state.body != dest_state.body:
dest_aspect = dest_state.body
if source_state.left != dest_state.left:
dest_aspect = dest_state.left
if source_state.right != dest_state.right:
dest_aspect = dest_state.right
def create_transition(dest_aspect):
reserve_target_interaction = None
if self._should_reserve:
reserve_target_interaction = self._reason_interaction_ref()
return PostureTransition(dest_aspect, dest_state, self._context, self._var_map, self._transition_spec, reserve_target_interaction, self._destination_constraint)
if dest_aspect is None:
if source_state.body.mobile and dest_state.body.mobile:
self._transition = create_transition(dest_state.body)
transition_result = yield element_utils.run_child(timeline, self._transition)
if not transition_result:
return transition_result
sim.posture_state = dest_state
if self._source_interaction is not None:
dest_state.body.source_interaction = self._source_interaction
if self._owning_interaction_ref is not None:
self._owning_interaction_ref().acquire_posture_ownership(dest_state.body)
yield sim.si_state.notify_posture_change_and_remove_incompatible_gen(timeline, source_state, dest_state)
return TestResult.TRUE
if self._source_interaction is not None:
dest_aspect.source_interaction = self._source_interaction
if self._owning_interaction_ref is not None:
self._owning_interaction_ref().acquire_posture_ownership(dest_aspect)
self._transition = create_transition(dest_aspect)
result = yield element_utils.run_child(timeline, self._transition)
return result
