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