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