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 start(self):
self._alarm_handle = alarms.add_alarm_real_time(
self,
clock.interval_in_real_seconds(1.0),
self._process,
repeating=True,
use_sleep_time=False)
def enable_performance_logging(*args, enableLog=False, **kwargs):
global previous_log_time_stamp, previous_log_time_ticks, performance_log_alarm
if enableLog:
def alarm_callback(_):
global previous_log_time_stamp, previous_log_time_ticks
generate_statistics()
_log_performance_metrics()
previous_log_time_stamp = time.time()
previous_log_time_ticks = services.server_clock_service().now(
).absolute_ticks()
previous_log_time_stamp = time.time()
previous_log_time_ticks = services.server_clock_service().now(
).absolute_ticks()
set_gsi_performance_metric('ticks_per_sec', 'N/A')
_log_performance_metrics()
current_zone = services.current_zone()
if performance_log_alarm is not None:
alarms.cancel_alarm(performance_log_alarm)
performance_log_alarm = alarms.add_alarm_real_time(
current_zone,
clock.interval_in_real_seconds(SECONDS_BETWEEN_LOGGING),
alarm_callback,
repeating=True,
use_sleep_time=False)
elif performance_log_alarm is not None:
alarms.cancel_alarm(performance_log_alarm)
performance_log_alarm = None
previous_log_time_stamp = 0
set_gsi_performance_metric('ticks_per_sec', 'N/A')
def _initial_update_callback(self, alarm_handle):
self._pulse()
time_span = clock.interval_in_real_seconds(self.update_frequency)
self._alarm = alarms.add_alarm_real_time(self.owner,
time_span,
self._update_callback,
repeating=True,
use_sleep_time=False)
def _start(self):
if self._alarm is None:
time_span = clock.interval_in_real_seconds(self.update_frequency)
time_span *= random.random()
self._alarm = alarms.add_alarm_real_time(
self.owner,
time_span,
self._initial_update_callback,
repeating=False,
use_sleep_time=False)
def schedule_environment_score_update(self, force_run=False):
def _update_environment_score_callback(timeline):
if not force_run and self.queue is not None and self.transition_controller is not None:
self._environment_score_alarm_handle = None
return
self._update_environment_score()
if self._environment_score_alarm_handle is not None and force_run:
alarms.cancel_alarm(self._environment_score_alarm_handle)
self._environment_score_alarm_handle = None
if self._environment_score_alarm_handle is None:
self._environment_score_alarm_handle = alarms.add_alarm(self, clock.interval_in_real_seconds(1.0), _update_environment_score_callback, repeating=False)
def set_build_buy_lockout_state(self, lockout_state, lockout_timer=None):
if self._build_buy_lockout_alarm_handler is not None:
alarms.cancel_alarm(self._build_buy_lockout_alarm_handler)
self._build_buy_lockout_alarm_handler = None
elif self._build_buy_lockout and lockout_state:
return
if lockout_state and lockout_timer is not None:
time_span_real_time = clock.interval_in_real_seconds(lockout_timer)
self._build_buy_lockout_alarm_handler = alarms.add_alarm_real_time(self, time_span_real_time, lambda *_: self.set_build_buy_lockout_state(False))
if lockout_state and not self.build_buy_lockout:
self.reset(ResetReason.RESET_EXPECTED)
self._build_buy_lockout = lockout_state
self.resend_interactable()
self.resend_tint()
def strike_terrain(position=None):
lightning_strike_tuning = LightningTuning.STRIKE_TERRAIN_TUNING
if position is None:
(position, routing_surface) = LightningStrike._get_terrain_position_and_routing_surface_for_lightning_strike()
if position is None:
return
else:
routing_surface = routing.SurfaceIdentifier(services.current_zone_id(), 0, routing.SurfaceType.SURFACETYPE_WORLD)
terrain_point = TerrainPoint.create_for_position_and_orientation(position, routing_surface)
lot = services.active_lot()
if lot.is_position_on_lot(position):
fire_service = services.get_fire_service()
fire_service.add_delayed_scorch_mark(position, routing_surface, clock.interval_in_real_seconds(lightning_strike_tuning.scorch_mark_delay))
effect = lightning_strike_tuning.effect_on_lot(None, transform_override=terrain_point.transform)
else:
effect = lightning_strike_tuning.effect_off_lot(None, transform_override=terrain_point.transform)
effect.start_one_shot()
broadcaster_request = lightning_strike_tuning.broadcaster(terrain_point)
broadcaster_request.start_one_shot()
create_tuning = lightning_strike_tuning.create_object_tuning
if random.random() < create_tuning.chance:
weather_service = services.weather_service()
weather_service.create_lightning_collectible_alarm(clock.interval_in_real_seconds(lightning_strike_tuning.scorch_mark_delay), terrain_point.location)
def start(self):
self._alarm_handle = add_alarm_real_time(self,
interval_in_real_seconds(
self.INTERVAL),
self._on_update,
repeating=True,
use_sleep_time=False)
object_manager = services.object_manager()
object_manager.register_callback(
CallbackTypes.ON_OBJECT_LOCATION_CHANGED,
self._update_object_cache)
object_manager.register_callback(CallbackTypes.ON_OBJECT_ADD,
self._update_object_cache)
services.current_zone().wall_contour_update_callbacks.append(
self._update_object_cache)
def schedule_environment_score_update(self, force_run=False):
def _update_environment_score_callback(timeline):
if not force_run and self.queue is not None and self.transition_controller is not None:
self._environment_score_alarm_handle = None
return
self._update_environment_score()
if self._environment_score_alarm_handle is not None and force_run:
alarms.cancel_alarm(self._environment_score_alarm_handle)
self._environment_score_alarm_handle = None
if self._environment_score_alarm_handle is None:
self._environment_score_alarm_handle = alarms.add_alarm(
self,
clock.interval_in_real_seconds(1.0),
_update_environment_score_callback,
repeating=False)
def _do_spawn_gen(timeline):
nonlocal middle_bassinet, new_bassinet
self.interaction.add_exit_function(_on_interaction_exit)
self.interaction.remove_liability('ReservationLiability')
if is_external:
middle_bassinet = self.interaction.target
target_sim = bassinet
else:
for handler in bassinet.get_reservation_handlers():
if handler.sim is self.interaction.sim:
bassinet.remove_reservation_handler(handler)
middle_bassinet = bassinet.replace_for_age_up(
interaction=self.interaction)
yield timeline.run_child(
SleepElement(interval_in_real_seconds(1)))
target_sim = self.spawn_for_age_up(
sim_info,
bassinet.position,
sim_location=bassinet.location)
self.interaction.context.create_target_override = target_sim
yield from target_sim._startup_sim_gen(timeline)
master_controller = services.get_master_controller()
master_controller.add_global_lock(target_sim)
self.interaction.add_exit_function(
lambda *_, **__: master_controller.remove_global_lock(
target_sim))
self.interaction.add_liability(
WorkLockLiability.LIABILITY_TOKEN,
WorkLockLiability(sim=target_sim))
def _add_bassinet(obj):
obj.location = middle_bassinet.location
obj.opacity = 0
new_bassinet = create_object(
BabyTuning.get_corresponding_definition(
middle_bassinet.definition),
init=_add_bassinet)
def _on_age_up_event(*_, **__):
new_bassinet.opacity = 1
middle_bassinet.remove_from_client()
self._action = AgeUpBaby(sim_info, callback=_on_age_up_event)
def _log(self, level, message, frame=sims4.log.DEFAULT):
if not self._logqueue and self._auto_flush_time is not None:
alarms.add_alarm_real_time(
self, clock.interval_in_real_seconds(self._auto_flush_time),
self.flush)
self._logqueue.append((level, message, frame))
def _get_track_length(self):
real_seconds = self._track.length
if self.use_buffer:
real_seconds += self._track.buffer
interval = clock.interval_in_real_seconds(real_seconds)
return interval
def _get_track_length(self):
real_seconds = self._track.length
if self.use_buffer:
real_seconds += self._track.buffer
interval = clock.interval_in_real_seconds(real_seconds)
return interval
def create_update_alarm(self):
self._alarm_handle = add_alarm_real_time(self, interval_in_real_seconds(self.INTERVAL), self._on_update, repeating=True, use_sleep_time=False)
def _start(self):
if self._alarm is None:
time_span = clock.interval_in_real_seconds(self.update_frequency)
time_span *= random.random()
self._alarm = alarms.add_alarm_real_time(self.owner, time_span, self._initial_update_callback, repeating=False, use_sleep_time=False)
def _initial_update_callback(self, alarm_handle):
self._pulse()
time_span = clock.interval_in_real_seconds(self.update_frequency)
self._alarm = alarms.add_alarm_real_time(self.owner, time_span, self._update_callback, repeating=True, use_sleep_time=False)
def start(self):
self._alarm_handle = add_alarm_real_time(self, interval_in_real_seconds(self.INTERVAL), self._on_update, repeating=True, use_sleep_time=False)
object_manager = services.object_manager()
object_manager.register_callback(CallbackTypes.ON_OBJECT_LOCATION_CHANGED, self._update_object_cache)
object_manager.register_callback(CallbackTypes.ON_OBJECT_ADD, self._update_object_cache)
services.current_zone().wall_contour_update_callbacks.append(self._update_object_cache)
def start_services(self, gameplay_zone_data, save_slot_data):
_distributor = distributor.system.Distributor.instance()
self.sim_quadtree = placement.get_sim_quadtree_for_zone(self.id)
self.single_part_condition_list = weakref.WeakKeyDictionary()
self.multi_part_condition_list = weakref.WeakKeyDictionary()
from objects.object_manager import ObjectManager, PropManager, PartyManager, InventoryManager, SocialGroupManager
from sims.sim_info_manager import SimInfoManager
from server.clientmanager import ClientManager
from sims.household_manager import HouseholdManager
from autonomy.autonomy_service import AutonomyService
from ui.ui_dialog_service import UiDialogService
from server.config_service import ConfigService
from event_testing.test_events import EventManager
from situations.situation_manager import SituationManager
from filters.sim_filter_service import SimFilterService
from socials.clustering import ObjectClusterService, SocialGroupClusterService
from postures.posture_graph import PostureGraphService
from animation.arb_accumulator import ArbAccumulatorService
from world.travel_service import TravelService
from situations.service_npcs.service_npc_manager import ServiceNpcService
from story_progression.story_progression_service import StoryProgressionService
from sims.master_controller import MasterController
from filters.neighborhood_population_service import NeighborhoodPopulationService
from services.lot_spawner_service import LotSpawnerService
from zone_spin_up_service import ZoneSpinUpService
from interactions.privacy import PrivacyService
from services.age_service import AgeService
from situations.ambient.ambient_service import AmbientService
from broadcasters.broadcaster_service import BroadcasterService
from services.super_speed_three_service import SuperSpeedThreeService
from services.fire_service import FireService
from services.cleanup_service import CleanupService
from time_service import TimeService
from sims4.sim_irq_service import SimIrqService
from venues.venue_service import VenueService
from services.reset_and_delete_service import ResetAndDeleteService
services = [
GameClock(), TimeService(), ConfigService(), SimIrqService(),
EventManager(), ClientManager(manager_id=MGR_CLIENT),
HouseholdManager(manager_id=MGR_HOUSEHOLD),
ResetAndDeleteService(), ObjectManager(manager_id=MGR_OBJECT),
InventoryManager(manager_id=MGR_OBJECT), AgeService(),
SimInfoManager(manager_id=MGR_SIM_INFO),
PropManager(manager_id=MGR_OBJECT), PostureGraphService(),
ArbAccumulatorService(None, None), AutonomyService(),
SituationManager(manager_id=MGR_SITUATION), SimFilterService(),
PartyManager(manager_id=MGR_PARTY),
SocialGroupManager(manager_id=MGR_SOCIAL_GROUP), UiDialogService(),
ObjectClusterService(), SocialGroupClusterService(),
TravelService(), NeighborhoodPopulationService(),
ServiceNpcService(), LotSpawnerService(), VenueService(),
AmbientService(), StoryProgressionService(), ZoneSpinUpService(),
PrivacyService(), FireService(), BroadcasterService(),
CleanupService(), SuperSpeedThreeService(), CareerService(),
MasterController()
]
from sims4.service_manager import ServiceManager
self.service_manager = ServiceManager()
for service in services:
self.service_manager.register_service(service)
self.client_object_managers = set()
self.service_manager.start_services(
zone=self,
gameplay_zone_data=gameplay_zone_data,
save_slot_data=save_slot_data)
self.navmesh_alarm_handle = alarms.add_alarm_real_time(
self,
clock.interval_in_real_seconds(1),
self._check_navmesh_updated_alarm_callback,
repeating=True,
use_sleep_time=False)
self._royalty_alarm_manager.start_schedule()
def _run_gen(self, timeline):
self._hide_held_props()
if self.actor.should_route_instantly:
final_path_node = self.path.nodes[-1]
final_position = sims4.math.Vector3(*final_path_node.position)
final_orientation = sims4.math.Quaternion(*final_path_node.orientation)
routing_surface = final_path_node.routing_surface_id
final_position.y = services.terrain_service.terrain_object().get_routing_surface_height_at(final_position.x, final_position.z, routing_surface)
self.actor.location = sims4.math.Location(sims4.math.Transform(final_position, final_orientation), routing_surface)
return True
accumulator = services.current_zone().arb_accumulator_service
if accumulator.MAXIMUM_TIME_DEBT > 0:
time_debt = accumulator.get_time_debt((self.actor,))
self._time_to_shave = accumulator.get_shave_time_given_duration_and_debt(self.path.duration(), time_debt)
self.wait_time = time_debt
new_time_debt = time_debt + self._time_to_shave
else:
time_debt = 0
self._time_to_shave = 0
self.wait_time = 0
new_time_debt = 0
try:
if self.canceled:
return False
if self.path and self.path.nodes:
try:
final_path_node = self.path.nodes[-1]
final_position = sims4.math.Vector3(*final_path_node.position)
final_orientation = sims4.math.Quaternion(*final_path_node.orientation)
self.actor.current_path = self.path
self._apply_walkstyle(self.path, self.actor)
accumulator = services.current_zone().arb_accumulator_service
self.start_time = services.time_service().sim_now + clock.interval_in_real_seconds(time_debt)
if self.actor.primitives:
for primitive in tuple(self.actor.primitives):
while isinstance(primitive, FollowPath):
primitive.detach(self.actor)
self.attach(self.actor)
self._sleep_element = elements.SoftSleepElement(self._next_update_interval(self._current_time()))
yield element_utils.run_child(timeline, self._sleep_element)
self._sleep_element = None
while True:
current_time = self._current_time()
if self._callback_fn is not None:
time_left = self._time_left(current_time).in_real_world_seconds()
distance_left = self.get_remaining_distance(time_left)
route_action = self._callback_fn(distance_left)
if route_action == FollowPath.Action.CANCEL:
self.canceled = True
if self.canceled or self.finished:
break
elif self.update_walkstyle:
time_offset = current_time + 0.5
self._update_walkstyle(self.path, self.actor, time_offset)
self.send_updated_msg()
self.update_walkstyle = False
else:
self.update_routing_location(current_time)
if current_time > self.path.nodes[-1].time*2.0 + 5.0:
break
next_interval = self._next_update_interval(current_time)
self._sleep_element = elements.SoftSleepElement(next_interval)
yield element_utils.run_child(timeline, self._sleep_element)
self._sleep_element = None
if self.canceled:
cancellation_info = self.choose_cancellation_time()
if cancellation_info:
self.send_canceled_msg(cancellation_info[0])
location = self.actor.location
location.routing_surface = self.path.node_at_time(cancellation_info[0]).routing_surface_id
translation = sims4.math.Vector3(*self.path.position_at_time(cancellation_info[0]))
translation.y = services.terrain_service.terrain_object().get_routing_surface_height_at(translation.x, translation.z, location.routing_surface)
orientation = sims4.math.Quaternion(*self.path.orientation_at_time(cancellation_info[0]))
location.transform = sims4.math.Transform(translation, orientation)
self.path.add_location_to_quad_tree(location)
with telemetry_helper.begin_hook(writer, TELEMETRY_HOOK_ROUTE_FAILURE, sim=self.actor) as hook:
hook.write_int(TELEMETRY_FIELD_ID, self.id)
hook.write_float(TELEMETRY_FIELD_POSX, translation.x)
hook.write_float(TELEMETRY_FIELD_POSY, translation.y)
hook.write_float(TELEMETRY_FIELD_POSZ, translation.z)
self.actor.location = location
while True:
if self.finished:
break
current_time = self._current_time()
if current_time > self.path.nodes[-1].time*2.0 + 5.0:
break
next_interval = self._next_update_interval(current_time)
self._sleep_element = elements.SoftSleepElement(next_interval)
yield element_utils.run_child(timeline, self._sleep_element)
self._sleep_element = None
return False
with telemetry_helper.begin_hook(writer, TELEMETRY_HOOK_ROUTE_FAILURE) as hook:
hook.write_int(TELEMETRY_FIELD_ID, self.id)
location = self.actor.location
location.routing_surface = final_path_node.routing_surface_id
final_position.y = services.terrain_service.terrain_object().get_routing_surface_height_at(final_position.x, final_position.z, location.routing_surface)
location.transform = sims4.math.Transform(final_position, final_orientation)
self.actor.location = location
finally:
self.detach(self.actor)
self.actor.current_path = None
self._sleep_element = None
return True
finally:
if accumulator.MAXIMUM_TIME_DEBT > 0:
accumulator.set_time_debt((self.actor,), new_time_debt)
def _next_update_interval(self, current_time):
update_interval = clock.interval_in_real_seconds(self.ROUTE_SIM_POSITION_UPDATE_FREQUENCY)
return update_interval
def _time_left(self, current_time):
return clock.interval_in_real_seconds(self.path.nodes[-1].time - current_time - self._time_to_shave)
def start(self):
self._alarm_handle = alarms.add_alarm_real_time(self, clock.interval_in_real_seconds(1.0), self._process, repeating=True, use_sleep_time=False)
def strike_object(obj_to_strike=None):
lightning_strike_tuning = LightningTuning.STRIKE_OBJECT_TUNING
if obj_to_strike is None:
obj_to_strike = LightningStrike._get_object_for_lightning_strike()
if obj_to_strike is None:
LightningStrike.strike_terrain()
return
lot = services.active_lot()
position = obj_to_strike.position
if lot.is_position_on_lot(position):
fire_service = services.get_fire_service()
fire_service.add_delayed_scorch_mark(position, obj_to_strike.routing_surface, clock.interval_in_real_seconds(lightning_strike_tuning.scorch_mark_delay))
effect = lightning_strike_tuning.effect(obj_to_strike)
weather_aware_component = obj_to_strike.weather_aware_component
if weather_aware_component is not None:
lightning_effect_override = weather_aware_component.lightning_effect_override
if lightning_effect_override is not None:
effect = lightning_effect_override(obj_to_strike)
effect.start_one_shot()
broadcaster_request = lightning_strike_tuning.broadcaster(obj_to_strike)
broadcaster_request.start_one_shot()
loot_ops_list = LootOperationList(SingleObjectResolver(obj_to_strike), lightning_strike_tuning.generic_loot_on_strike)
loot_ops_list.apply_operations()
if weather_aware_component is not None:
weather_aware_component.on_struck_by_lightning()
