def _start_delayed_decay_timer(self):
self.refresh_threshold_callback()
if self._delayed_decay_timer is not None:
alarms.cancel_alarm(self._delayed_decay_timer)
self._delayed_decay_timer = None
initial_delay = self._get_initial_delay()
final_delay = self._get_final_delay()
now = services.time_service().sim_now
time_passed = 0
if self._time_of_last_value_change is not None:
time_passed = now - self._time_of_last_value_change
time_passed = time_passed.in_minutes()
if time_passed < initial_delay:
length = date_and_time.create_time_span(minutes=initial_delay -
time_passed)
self._delayed_decay_timer = alarms.add_alarm(
self, length, self._display_decay_warning)
elif time_passed < initial_delay + final_delay:
time_into_final_delay = time_passed - initial_delay
length = date_and_time.create_time_span(minutes=final_delay -
time_into_final_delay)
self._delayed_decay_timer = alarms.add_alarm(
self, length, self._start_delayed_decay)
else:
self._start_delayed_decay(None)
def cleanup(self, from_service_stop=False):
super().cleanup(from_service_stop=from_service_stop)
if self._end_alarm_handle is not None:
alarms.cancel_alarm(self._end_alarm_handle)
self._lottery_sims.clear()
services.get_event_manager().unregister_single_event(
self, self.lottery_event)
def enable_sim_motive_graph_logging(*args, enableLog=False, **kwargs):
global sim_motive_graph_alarm
if enableLog and sim_motive_graph_alarm is None:
sim_motive_graph_alarm = alarms.add_alarm(sim_motive_archiver, TimeSpan(5000), lambda _: archive_sim_motives(), repeating=True)
else:
alarms.cancel_alarm(sim_motive_graph_alarm)
sim_motive_graph_alarm = None
def stop(self):
if self._update_alarm_handle is not None:
alarms.cancel_alarm(self._update_alarm_handle)
self._update_alarm_handle = None
if self._flavor_alarm_handle is not None:
alarms.cancel_alarm(self._flavor_alarm_handle)
self._flavor_alarm_handle = None
def stop(self):
if self._update_alarm_handle is not None:
alarms.cancel_alarm(self._update_alarm_handle)
self._update_alarm_handle = None
if self._flavor_alarm_handle is not None:
alarms.cancel_alarm(self._flavor_alarm_handle)
self._flavor_alarm_handle = None
def on_deactivate(self):
self._unregister_for_all_test_events()
for state_alarm in self._alarms.values():
alarms.cancel_alarm(state_alarm.alarm_handle)
self._alarms.clear()
self.owner = None
self._active = False
def _destroy(self):
if self._duration_alarm_handle is not None:
alarms.cancel_alarm(self._duration_alarm_handle)
if self._goal_tracker is not None:
self._goal_tracker.destroy()
self._goal_tracker = None
super()._destroy()
def clear_pregnancy(self):
pregnancy_commodity_type = self.PREGNANCY_COMMODITY_MAP.get(
self._sim_info.species)
tracker = self._sim_info.get_tracker(pregnancy_commodity_type)
if tracker is not None:
stat = tracker.get_statistic(pregnancy_commodity_type, add=True)
if stat is not None:
stat.set_value(stat.min_value)
stat.remove_statistic_modifier(self.PREGNANCY_RATE)
if self._completion_callback_listener is not None:
tracker.remove_listener(self._completion_callback_listener)
self._completion_callback_listener = None
tracker = self._sim_info.get_tracker(self.GENDER_CHANCE_STAT)
if tracker is not None:
tracker.remove_statistic(self.GENDER_CHANCE_STAT)
if self._sim_info.has_trait(self.PREGNANCY_TRAIT):
self._sim_info.remove_trait(self.PREGNANCY_TRAIT)
traits_pack_tuple = self.PREGNANCY_ORIGIN_TRAIT_MAPPING.get(
self._origin)
if traits_pack_tuple is not None:
for trait in traits_pack_tuple.traits:
if self._sim_info.has_trait(trait):
self._sim_info.remove_trait(trait)
if self._completion_alarm_handle is not None:
alarms.cancel_alarm(self._completion_alarm_handle)
self._completion_alarm_handle = None
self.clear_pregnancy_visuals()
self._clear_pregnancy_data()
def cleanup(self, from_service_stop=False):
super().cleanup(from_service_stop=from_service_stop)
if self.festival_contest_tuning is None:
return
if self._score_alarm is not None:
alarms.cancel_alarm(self._score_alarm)
self._score_alarm = None
def _cancel_sound_alarm(self, *args, **kwargs):
if self._sound_alarm is not None:
alarms.cancel_alarm(self._sound_alarm)
self._sound_alarm = None
if self._sound is not None:
self._sound.stop()
self._sound = None
def update_sleep_schedule(self):
self._remove_sleep_schedule_buff()
for alarm_handle in self._sleep_buff_alarms.keys():
alarms.cancel_alarm(alarm_handle)
self._sleep_buff_alarms.clear()
time_span_until_wakeup = self.get_time_until_next_wakeup()
sleep_schedule = self._get_sleep_schedule()
most_appropriate_buff = None
for sleep_schedule_entry in sorted(
sleep_schedule.schedule,
key=lambda entry: entry.time_from_work_start,
reverse=True):
if time_span_until_wakeup.in_hours(
) <= sleep_schedule_entry.time_from_work_start:
most_appropriate_buff = sleep_schedule_entry.buff
else:
time_until_buff_alarm = time_span_until_wakeup - create_time_span(
hours=sleep_schedule_entry.time_from_work_start)
alarm_handle = alarms.add_alarm(
self, time_until_buff_alarm, self._add_buff_callback, True,
create_time_span(hours=date_and_time.HOURS_PER_DAY))
self._sleep_buff_alarms[
alarm_handle] = sleep_schedule_entry.buff
if most_appropriate_buff:
if most_appropriate_buff.buff_type:
self._sleep_buff_handle = self.owner.add_buff(
most_appropriate_buff.buff_type)
if self._sleep_buff_reset:
alarms.cancel_alarm(self._sleep_buff_reset)
self._sleep_buff_reset = alarms.add_alarm(self, time_span_until_wakeup,
self._reset_alarms_callback)
def on_client_disconnect(self):
if self._buff_alarm is not None:
alarms.cancel_alarm(self._buff_alarm)
self._buff_alarm = None
if self._emotion_relationship_alarm is not None:
alarms.cancel_alarm(self._emotion_relationship_alarm)
self._emotion_relationship_alarm = None
def _destroy(self):
if self._duration_alarm_handle is not None:
alarms.cancel_alarm(self._duration_alarm_handle)
if self._goal_tracker is not None:
self._goal_tracker.destroy()
self._goal_tracker = None
super()._destroy()
def _cancel_sound_alarm(self, *args, **kwargs):
if self._sound_alarm is not None:
alarms.cancel_alarm(self._sound_alarm)
self._sound_alarm = None
if self._sound is not None:
self._sound.stop()
self._sound = None
def on_destroy(self):
if self._celebrity_container_situation is not None:
services.get_zone_situation_manager().destroy_situation_by_id(
self._celebrity_container_situation_id)
if self._fan_situation_alarm_handle is not None:
alarms.cancel_alarm(self._fan_situation_alarm_handle)
self._fan_situation_alarm_handle = None
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 _create_auto_age_callback(self, delay=1):
if self._auto_age_handle is not None:
alarms.cancel_alarm(self._auto_age_handle)
time_span_until_age_up = create_time_span(days=delay)
if time_span_until_age_up.in_ticks() <= 0:
time_span_until_age_up = create_time_span(minutes=1)
self._auto_age_handle = alarms.add_alarm(self, time_span_until_age_up, self.callback_auto_age, False)
def _remove_alarm_helper(*args):
current_zone = services.current_zone()
if current_zone in _reset_alarm_handles:
alarms.cancel_alarm(_reset_alarm_handles[current_zone])
del _reset_alarm_handles[current_zone]
current_zone.unregister_callback(zone_types.ZoneState.SHUTDOWN_STARTED,
_remove_alarm_helper)
def on_remove_from_client(self):
super().on_remove_from_client()
if self._fade_out_alarm_handle is not None:
alarms.cancel_alarm(self._fade_out_alarm_handle)
self._fade_out_alarm_handle = None
for primitive in tuple(self.primitives):
primitive.detach(self)
def _score_add_callback(self, _):
if self._get_remaining_contest_time().in_minutes() <= 0:
if self._score_alarm is not None:
alarms.cancel_alarm(self._score_alarm)
self._score_alarm = None
return
self._add_fake_score()
def _do_change_when_appropriate(self, from_finalize=False):
if self._change_alarm is not None:
alarms.cancel_alarm(self._change_alarm)
self._change_alarm = None
if self._last_change_start_time is None:
logger.error(
'Attempt to (re)start conditional layer without start time set for {}',
self)
return
if self.delay_from_change is not None:
time_of_change = self._last_change_start_time + self.delay_from_change(
)
else:
time_of_change = self._last_change_start_time
now = services.time_service().sim_now
time_until_change = time_of_change - now
if time_until_change == TimeSpan.ZERO:
self._do_change(from_finalize=from_finalize)
elif time_until_change > TimeSpan.ZERO:
self._change_alarm = alarms.add_alarm(self,
time_until_change,
lambda _: self._do_change(),
cross_zone=True)
elif self.layer.conditional_layer.client_only and self._is_on_active_street(
):
conditional_layer_service = services.conditional_layer_service()
show_layer = self.layer.show_conditional_layer
invert_show = not self.policy.enacted
if invert_show:
show_layer = not show_layer
if show_layer != conditional_layer_service.is_layer_loaded(
self.layer.conditional_layer):
self.layer.change_conditional_layer(invert_show=invert_show)
def _create_adjustment_alarm(self):
if self._adjustment_alarm is not None:
alarms.cancel_alarm(self._adjustment_alarm)
alarm_delay = self.adjustment_interval.random_float()
self._adjustment_alarm = alarms.add_alarm(
self, clock.interval_in_sim_minutes(alarm_delay),
self._adjustment_alarm_callback)
def on_deactivate(self):
if self._interaction is not None:
self._interaction.unregister_on_finishing_callback(self._on_finishing_callback)
self._interaction = None
if self._timeout_handle is not None:
alarms.cancel_alarm(self._timeout_handle)
self._timeout_handle = None
super().on_deactivate()
def start_evaporation(self):
if self._evaporate_alarm_handle is not None:
alarms.cancel_alarm(self._evaporate_alarm_handle)
if self.is_outside:
time = self.outdoor_evaporation_time.random_float()
else:
time = self.indoor_evaporation_time.random_float()
self._evaporate_alarm_handle = alarms.add_alarm(self, date_and_time.create_time_span(minutes=time), self.evaporate)
def reset_helper(self):
current_zone = services.current_zone()
output("Interval elapse")
_apply_baby_chances(couples, _connection)
alarms.cancel_alarm(_reset_alarm_handles[current_zone])
reset_time_span = clock.interval_in_sim_minutes(10)
_reset_alarm_handles[current_zone] = alarms.add_alarm(
simulate_story_progression, reset_time_span, reset_helper)
def post_alert(self):
if self._return_alarm is None:
return
remaining_time = self._return_alarm.get_remaining_time()
alarms.cancel_alarm(self._return_alarm)
remaining_time *= 1 - self.POST_ALERT_EFFECTIVENESS.random_float()
self._add_return_alarm(remaining_time)
self._alert_posted = True
def on_shutdown(self):
super().on_shutdown()
if self._bowling_situation_alarm_handle is not None:
alarms.cancel_alarm(self._bowling_situation_alarm_handle)
self._bowling_situation_alarm_handle = None
if self._moonlight_alarm_handle is not None:
alarms.cancel_alarm(self._moonlight_alarm_handle)
self._moonlight_alarm_handle = None
def cleanup(self, from_service_stop=False):
super().cleanup(from_service_stop=from_service_stop)
if self._duration_alarm is not None:
alarms.cancel_alarm(self._duration_alarm)
self._duration_alarm = None
if self._additional_nodes_processor is not None:
self._additional_nodes_processor.trigger_hard_stop()
self._additional_nodes_processor = None
def _stop_alarm(self):
if self._alarm_handle is not None:
alarms.cancel_alarm(self._alarm_handle)
self._alarm_handle = None
self._total_time_ran += (services.time_service().sim_now -
self._last_started_time) * len(
self._sims_running_interaction)
self._last_started_time = None
def on_deactivate(self):
super().on_deactivate()
if self._count_timer is not None:
alarms.cancel_alarm(self._count_timer)
self._count_timer = None
if self._celebrate_timer is not None:
alarms.cancel_alarm(self._celebrate_timer)
self._celebrate_timer = None
def destroy(self):
self._situation = None
if self._churn_alarm_handle is not None:
alarms.cancel_alarm(self._churn_alarm_handle)
self._churn_alarm_handle = None
if self._shift_change_alarm_handle is not None:
alarms.cancel_alarm(self._shift_change_alarm_handle)
self._shift_change_alarm_handle = None
def deactivate_fire_alarms(self):
if self._fire_alarm_alarm:
alarms.cancel_alarm(self._fire_alarm_alarm)
self._fire_alarm_alarm = None
for fire_alarm in self._fire_alarm_objects:
fire_alarm.set_state(self.FIRE_ALARM_DEACTIVATED_STATE.state, self.FIRE_ALARM_DEACTIVATED_STATE)
self._fire_alarm_objects = set()
self._activated_fire_alarms = set()
def cancel(self):
if self._alarm_handle != None:
cancel_alarm(self._alarm_handle)
self._alarm_handle = None
self._output('SimulateToTime: Stopped')
self._set_speed_on_clock(ClockSpeedMode.PAUSED)
zone = services.current_zone()
zone.ui_dialog_service.set_auto_respond(self._old_auto_respond)
def on_client_disconnect(self, client):
for household in self.get_all():
household.on_client_disconnect()
if self._phone_call_alarm_handle is not None:
alarms.cancel_alarm(self._phone_call_alarm_handle)
self._phone_call_alarm_handle = None
if self._phone_call_element is not None:
self._phone_call_element.trigger_hard_stop()
def _cancel_waiting_alarm(self):
self._waiting_start_time = None
if self._waiting_alarm is not None:
alarms.cancel_alarm(self._waiting_alarm)
self._waiting_alarm = None
if self._go_nearby_interaction is not None:
self._go_nearby_interaction.cancel(FinishingType.SOCIALS, 'Canceled')
self._interactions.discard(self._go_nearby_interaction)
self._go_nearby_interaction = None
def start_evaporation(self):
if self._evaporate_alarm_handle is not None:
alarms.cancel_alarm(self._evaporate_alarm_handle)
if self.is_outside:
time = self.outdoor_evaporation_time.random_float()
else:
time = self.indoor_evaporation_time.random_float()
self._evaporate_alarm_handle = alarms.add_alarm(
self, date_and_time.create_time_span(minutes=time), self.evaporate)
def turn_off(self, global_policy_id):
household_id = services.active_household().id
self.stop_action(household_id)
if self._schedule is not None:
self._schedule.destroy()
if self._stop_schedule_entry is not None:
alarms.cancel_alarm(self._stop_schedule_entry)
services.global_policy_service().remove_utility_effect(
global_policy_id)
def _fire_spread_alarm_callback(self, handle):
if not self.fire_is_active:
alarms.cancel_alarm(handle)
self._fire_spread_alarm = None
return
chance = random.uniform(0, 1)
if chance > self.FIRE_SPREAD_CHANCE:
return
self.spread_fire()
def flowing_puddle_enabled(self, value):
if self._is_active == value:
return
if self._is_active:
alarms.cancel_alarm(self._puddle_alarm_handle)
self._puddle_alarm_handle = None
else:
self.try_create_puddle()
self.create_alarm()
self._is_active = value
def _set_duration_alarm(self, duration_override=None):
if duration_override is not None:
duration = duration_override
else:
duration = self._get_duration()
self.set_end_time(duration)
if duration > 0:
if self._duration_alarm_handle is not None:
alarms.cancel_alarm(self._duration_alarm_handle)
self._duration_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(duration), self._situation_timed_out)
def _end_statistic_gains(self):
for (participant, handle_list) in self._autonomy_modifiers.items():
while participant is not None:
while True:
for handle in handle_list:
participant.remove_statistic_modifier(handle)
if self._alarm_handle is not None:
alarms.cancel_alarm(self._alarm_handle)
self._alarm_handle = None
self._change_helper = None
def stop(self):
if self._alarm_handle is not None:
cancel_alarm(self._alarm_handle)
self._alarm_handle = None
if self._processing_task is not None:
self._processing_task.stop()
self._processing_task = None
object_manager = services.object_manager()
object_manager.unregister_callback(CallbackTypes.ON_OBJECT_LOCATION_CHANGED, self._update_object_cache)
object_manager.unregister_callback(CallbackTypes.ON_OBJECT_ADD, self._update_object_cache)
services.current_zone().wall_contour_update_callbacks.remove(self._update_object_cache)
def try_grow_puddle(self):
if self._puddle_size == PuddleSize.LargePuddle:
return
if self._puddle_size == PuddleSize.MediumPuddle:
puddle = create_puddle(PuddleSize.LargePuddle, puddle_liquid=self._puddle_liquid)
else:
puddle = create_puddle(PuddleSize.MediumPuddle, puddle_liquid=self._puddle_liquid)
if puddle.place_puddle(self, 1, ids_to_ignore=[self.id]):
if self._evaporate_alarm_handle is not None:
alarms.cancel_alarm(self._evaporate_alarm_handle)
self.fade_and_destroy()
return puddle
def on_remove(self):
for alarm_handle in self._sleep_buff_alarms.keys():
alarms.cancel_alarm(alarm_handle)
if self._full_autonomy_request is not None:
self._full_autonomy_request.valid = False
self._full_autonomy_request = None
if self._sleep_buff_reset is not None:
alarms.cancel_alarm(self._sleep_buff_reset)
self.owner.si_state.on_changed.remove(self.invalidate_mixer_interaction_cache)
self.owner.si_state.on_changed.remove(self.reset_multitasking_roll)
self.on_sim_reset(True)
self._role_tracker.shutdown()
def attend_work(self, interaction=None):
if interaction is not None:
self._interaction = weakref.ref(interaction)
if self._attended_work:
return
self._attended_work = True
if self._late_for_work_handle is not None:
alarms.cancel_alarm(self._late_for_work_handle)
self._late_for_work_handle = None
self.send_career_message(self.career_messages.career_daily_start_notification)
self.resend_at_work_info()
self.start_tones()
def _clear_environment_score(self):
for commodity in environment_score_mood_commodities:
while self.commodity_tracker.has_statistic(commodity):
self.commodity_tracker.remove_statistic(commodity)
self._environment_score_commodity = None
if self.commodity_tracker.has_statistic(EnvironmentScoreTuning.NEGATIVE_ENVIRONMENT_SCORING):
self.commodity_tracker.remove_statistic(EnvironmentScoreTuning.NEGATIVE_ENVIRONMENT_SCORING)
if self.commodity_tracker.has_statistic(EnvironmentScoreTuning.POSITIVE_ENVIRONMENT_SCORING):
self.commodity_tracker.remove_statistic(EnvironmentScoreTuning.POSITIVE_ENVIRONMENT_SCORING)
if self._environment_score_alarm_handle is not None:
alarms.cancel_alarm(self._environment_score_alarm_handle)
self._environment_score_alarm_handle = None
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 deactivate_sprinkler_system(self):
self._sprinkler_has_been_activated = False
for sprinkler_system_object in self._sprinkler_system_objects:
sprinkler_system_object.set_state(self.FIRE_SPRINKLER_DEACTIVATED_STATE.state, self.FIRE_SPRINKLER_DEACTIVATED_STATE)
if self._sprinkler_alarm:
alarms.cancel_alarm(self._sprinkler_alarm)
self._sprinkler_alarm = None
for sprinkler in self._sprinkler_objects:
sprinkler.destroy(source=sprinkler, cause='Destroying sprinklers.')
self._sprinkler_system_objects.clear()
self._sprinkler_objects = set()
self._fire_objects_being_suppressed = weakref.WeakSet()
self._unsuppressible_fires = weakref.WeakSet()
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 _fire_alarm_callback(self, handle):
if not self.fire_is_active:
alarms.cancel_alarm(handle)
self._fire_alarm_alarm = None
self.deactivate_fire_alarms()
return
self.alert_all_sims()
deactivated_fire_alarms = self._fire_alarm_objects - self._activated_fire_alarms
for deactivated_fire_alarm in deactivated_fire_alarms:
alarm_position = deactivated_fire_alarm.position
fires_in_range = self.query_quadtree_for_fire_object(sims4.math.Vector2(alarm_position.x, alarm_position.z), radius=self.FIRE_ALARM_ACTIVATION_RADIUS, level=deactivated_fire_alarm.location.level)
while fires_in_range:
deactivated_fire_alarm.set_state(self.FIRE_ALARM_ACTIVE_STATE.state, self.FIRE_ALARM_ACTIVE_STATE)
self._activated_fire_alarms.add(deactivated_fire_alarm)
def _set_venue(self, venue_type):
if venue_type is None:
logger.error('Zone {} has invalid venue type.', services.current_zone().id)
return False
if type(self._venue) is venue_type:
return False
if self._venue is not None:
self._venue.shut_down()
if self._special_event_start_alarm is not None:
alarms.cancel_alarm(self._special_event_start_alarm)
self._special_event_start_alarm = None
new_venue = venue_type()
self._venue = new_venue
return True
def end_career_session(self):
if self._end_work_handle is not None:
alarms.cancel_alarm(self._end_work_handle)
self._end_work_handle = None
if self._late_for_work_handle is not None:
alarms.cancel_alarm(self._late_for_work_handle)
self._late_for_work_handle = None
self._interaction = None
self._reset_performance_statistics()
self.set_career_situation_available(True)
self._current_work_start = None
self._current_work_end = None
self._current_work_duration = None
self._attended_work = False
self.resend_at_work_info()
def _send_notification(self, notification):
if not self.bill_notifications_enabled:
return
client = services.client_manager().get_client_by_household(self._household)
if client is not None:
active_sim = client.active_sim
if active_sim is not None:
remaining_time = max(int(self._shutoff_handle.get_remaining_time().in_hours()), 0)
dialog = notification(active_sim, None)
dialog.show_dialog(additional_tokens=(remaining_time, self._current_payment_owed))
current_time = services.time_service().sim_now
if self._warning_handle is not None and self._warning_handle.finishing_time <= current_time:
alarms.cancel_alarm(self._warning_handle)
self._warning_handle = None
play_tunable_audio(self.AUDIO.delinquency_warning_sfx)
def initialize_alarms(self):
if self._buff_alarm is not None:
alarms.cancel_alarm(self._buff_alarm)
self._buff_alarm = alarms.add_alarm(
self,
create_time_span(minutes=TelemetryTuning.BUFF_ALARM_TIME),
self.buff_telemetry_report,
True)
if self._emotion_relationship_alarm is not None:
alarms.cancel_alarm(self._emotion_relationship_alarm)
self._emotion_relationship_alarm = alarms.add_alarm(
self,
create_time_span(minutes=TelemetryTuning.EMOTION_REL_ALARM_TIME),
self.emotion_relation_telemetry_report,
True)
def _shut_off_utility(self, utility):
if self._current_payment_owed == None:
self._clear_delinquency_status()
logger.error('Household {} is getting a utility shut off without actually owing any money. Resetting delinquency status.', self._household, owner='tastle')
return
shutoff_notification = self.UTILITY_INFO[utility].shutoff_notification
self._send_notification(shutoff_notification)
if self._shutoff_handle is not None:
alarms.cancel_alarm(self._shutoff_handle)
self._shutoff_handle = None
self._utility_delinquency[utility] = True
self._set_next_delinquency_timers()
self._cancel_delinquent_interactions(utility)
if utility == Utilities.POWER:
self._stop_all_power_utilities()
play_tunable_audio(self.AUDIO.delinquency_activation_sfx)
def autonomy_distance_estimates_perform_timed_run(time_to_run_in_seconds:int=180, _connection=None):
global g_distance_estimate_alarm_handle
if g_distance_estimate_alarm_handle is not None:
autonomy_distance_estimates_disable(_connection=_connection)
alarms.cancel_alarm(g_distance_estimate_alarm_handle)
g_distance_estimate_alarm_handle = None
autonomy_distance_estimates_enable(_connection=_connection)
def _finish_test_and_write_file(_):
global g_distance_estimate_alarm_handle
autonomy_distance_estimates_log_file(_connection=_connection)
autonomy_distance_estimates_disable(_connection=_connection)
g_distance_estimate_alarm_handle = None
time_span = date_and_time.create_time_span(minutes=time_to_run_in_seconds)
g_distance_estimate_alarm_handle = alarms.add_alarm_real_time(services.autonomy_service(), time_span, _finish_test_and_write_file)
def clean_up(self):
for goal in self._realized_goals.keys():
while goal is not None:
goal.destroy()
self._realized_goals.clear()
for goal in self._active_whims:
while goal is not None:
goal.destroy()
self._active_whims.clear()
for alarm_handle in self.alarm_handles.values():
alarms.cancel_alarm(alarm_handle)
self.alarm_handles.clear()
for delay_alarm_handle in self.delay_alarm_handles:
alarms.cancel_alarm(delay_alarm_handle)
self.delay_alarm_handles.clear()
self._whimset_objective_map.clear()
self._test_results_map.clear()
