def _schedule_next_alarm(self, schedule_immediate=False, min_duration_remaining=None): now = services.time_service().sim_now (time_span, best_work_data) = self.time_until_next_scheduled_event( now, schedule_immediate=schedule_immediate, min_duration_remaining=min_duration_remaining) if self._min_alarm_time_span is not None and time_span < self._min_alarm_time_span: time_span = self._min_alarm_time_span if time_span == date_and_time.TimeSpan.ZERO and schedule_immediate: time_span = date_and_time.TimeSpan.ONE self._alarm_handle = alarms.add_alarm(self, time_span, self._alarm_callback) self._alarm_data[self._alarm_handle] = best_work_data if time_span is not None and ( self._early_warning_callback is not None and self._early_warning_time_span is not None ) and self._early_warning_time_span > date_and_time.TimeSpan.ZERO: warning_time_span = time_span - self._early_warning_time_span if warning_time_span > date_and_time.TimeSpan.ZERO: logger.assert_log( self._early_warning_alarm_handle is None, 'Scheduler is setting an early warning alarm when the previous one has not fired.', owner='tingyul') self._early_warning_alarm_handle = alarms.add_alarm( self, warning_time_span, self._early_warning_alarm_callback)
def _create_work_session_alarms(self): self._end_work_handle = alarms.add_alarm(self, self.time_until_end_of_work() + TimeSpan.ONE, self._end_work_callback) if not self.attended_work: now = services.time_service().sim_now late_time = self.get_late_time() if now < late_time: self._late_for_work_handle = alarms.add_alarm(self, late_time - now + TimeSpan.ONE, self._late_for_work_callback)
def _set_next_delinquency_timers(self): for utility in self._utility_delinquency: if self._utility_delinquency[utility]: pass warning_notification = self.UTILITY_INFO[utility].warning_notification self._warning_handle = alarms.add_alarm(self, clock.interval_in_sim_hours(self.DELINQUENCY_FREQUENCY - self.DELINQUENCY_WARNING_OFFSET_TIME), lambda _: self._send_notification(warning_notification)) self._shutoff_handle = alarms.add_alarm(self, clock.interval_in_sim_hours(self.DELINQUENCY_FREQUENCY), lambda _: self._shut_off_utility(utility)) break
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 on_activate(self, reader=None): super().on_activate(reader) trying_to_cook_timeout = self.owner.trying_to_cook_timeout if reader is not None: trying_to_cook_timeout = reader.read_float('trying_to_cook_timeout', trying_to_cook_timeout) self._try_to_cook_timeout_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(trying_to_cook_timeout), self._try_and_cook_timeout_callback) self._test_event_register(TestEvent.InteractionStart)
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 _create_sound_alarm(self, *args, **kwargs): track_length = self._get_track_length() if self._sound_alarm is None: self._sound_alarm = alarms.add_alarm(self, track_length, self._sound_alarm_callback) if self._sound is None: self._sound = PlaySound(self._instrument, self._track.music_clip.instance) self._sound.start()
def _update_active_callback(self): if self._suppress_update_active_callbacks: return if not self._callbacks: if self._active_callback is not None or self._alarm_handle: logger.debug('_callback list is empty; destroying alarm & active callback. Last active callback was {}'.format(self._active_callback)) self._destroy_alarm() self._active_callback = None return self._destroy_alarm() while self._callbacks: callback_data = self._callback_queue_head interval = callback_data.calculate_interval() if interval is None: self._active_callback = None break if interval.in_ticks() <= 0: self._trigger_callback(callback_data) self._update_active_callback() else: if self._alarm_handle: self._destroy_alarm() logger.debug('Creating alarm for callback: {}'.format(callback_data)) self._alarm_handle = alarms.add_alarm(self, interval, self._alarm_callback) self._active_callback = callback_data break
def _reset_decay_alarm(self): self._destroy_decay_alarm() if self._should_decay() and self.delay_until_decay_is_applied is not None: logger.debug('Resetting decay alarm for track {} for {}.', self, self.tracker.relationship) delay_time_span = date_and_time.create_time_span(minutes=self.delay_until_decay_is_applied) self._decay_alarm_handle = alarms.add_alarm(self, delay_time_span, self._decay_alarm_callback) self.decay_enabled = False
def on_activate(self, reader=None): super().on_activate(reader) self.owner._set_job_role_state(self.owner.role.situation_job, self.owner.role.do_stuff_role_state) timeout = self.owner.do_stuff_timeout if reader is not None: timeout = reader.read_float(DO_STUFF_TIMEOUT, timeout) self._timeout_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(timeout), lambda _: self.timer_expired())
def _spawn_fire(self, transform, routing_surface, run_placement_tests=True): if not fire_enabled: logger.info('Trying to spawn fire when fire is disabled. Please use |fire.toggle_enabled cheat to turn fire on.') return if not services.active_lot().is_position_on_lot(transform.translation): logger.info('Trying to spawn fire on a lot other than the active lot.') return if not services.venue_service().venue.allows_fire: logger.info("Trying to spawn a fire on a venue that doesn't allow fire.") return if not (run_placement_tests and self._placement_tests(transform.translation, routing_surface.secondary_id)): logger.info('Trying to spawn a fire on a lot at a position that is not valid.') return fire_object = system.create_object(self.FIRE_OBJECT_DEF) fire_object.move_to(transform=transform, routing_surface=routing_surface) first_fire_on_lot = False if self._fire_objects else True self._fire_objects.add(fire_object) fire_object.add_state_changed_callback(self._fire_object_state_changed_callback) self.start_objects_burning(fire_object) self.add_scorch_mark(fire_object.position, fire_object.location.level) self._derail_routing_sims_if_necessary(fire_object) if first_fire_on_lot: self._start_fire_situations() self.activate_fire_alarms() self.activate_sprinkler_system() self._show_fire_notification() self._create_or_replace_scorch_cleanup_alarm() services.get_persistence_service().lock_save(self) self.register_for_sim_active_lot_status_changed_callback() if self._fire_spread_alarm is None: time_span = date_and_time.create_time_span(minutes=self.FIRE_SPREAD_INTIAL_TIME_IN_SIM_MINUTES) repeating_time_span = date_and_time.create_time_span(minutes=self.FIRE_SPREAD_REPEATING_TIME_IN_SIM_MINUTES) self._fire_spread_alarm = alarms.add_alarm(self, time_span, self._fire_spread_alarm_callback, repeating=True, repeating_time_span=repeating_time_span)
def on_activate(self, reader=None): super().on_activate(reader) time_out = self.owner.guests_become_impatient_timeout if reader is not None: time_out = reader.read_float('impatient_timer', time_out) self._impatient_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(time_out), lambda _: self.timer_expired()) self._test_event_register(TestEvent.InteractionStart)
def on_startup(self): super().on_startup() time_of_day = services.time_service().sim_now churn_interval = clock.interval_in_sim_minutes( self.churn_alarm_interval) for situation_shift in self.situation_shifts: alarm_handle = alarms.add_alarm(self, churn_interval, self._shift_churn_alarm_callback, repeating=True) self._shift_alarm_handles[alarm_handle] = situation_shift time_span = situation_shift.shift_curve.get_timespan_to_next_shift_time( time_of_day) if time_span is not None: alarm_handle = alarms.add_alarm( self, time_span, self._shift_change_alarm_callback) self._shift_alarm_handles[alarm_handle] = situation_shift
def on_activate(self, reader=None): super().on_activate(reader) self._test_event_register(TestEvent.InteractionComplete) guest_tuple = self.owner.guest self.owner._set_job_role_state(guest_tuple.situation_job, guest_tuple.guest_ceremony_role_state) self.owner._set_job_role_state(self.owner.betrothed.situation_job, self.owner.betrothed.betrothed_ceremony_role_state) self._guest_sim_infos_to_force_watch = [sim.sim_info for sim in self.owner.all_sims_in_job_gen(guest_tuple.situation_job)] self._alarm_handle = alarms.add_alarm(self, create_time_span(minutes=self.MAKE_GUESTS_WATCH_ALARM_TIME), self._make_guests_watch)
def on_activate(self, reader=None): super().on_activate(reader) time_out = self.owner.guests_start_reception_timeout if reader is not None: time_out = reader.read_float('start_reception_timer', time_out) self._start_reception_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(time_out), lambda _: self.timer_expired()) self._test_event_register(TestEvent.InteractionStart) self.owner._set_job_role_state(self.owner.guest.situation_job, self.owner.guest.guest_gather_impatient_role_state)
def on_activate(self, reader=None): super().on_activate(reader) cooking_timeout = self.owner.cooking_timeout if reader is not None: cooking_timeout = reader.read_float('cooking_timeout', cooking_timeout) self._cooking_timeout_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(cooking_timeout), self._cooking_timeout_callback) self._test_event_register(TestEvent.ItemCrafted) self._test_event_register(TestEvent.InteractionComplete)
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 _create_curfew_callback(self, now, time): if time is not self.UNSET: alarm_time = date_and_time.create_date_and_time(hours=time) curfew_span = now.time_till_next_day_time(alarm_time) if curfew_span.in_ticks() == 0: curfew_span += TimeSpan(date_and_time.sim_ticks_per_day()) self._curfew_started_alarm_handle = alarms.add_alarm( self, curfew_span, self._handle_curfew_callback, False)
def _create_warning_callback(self, now, time): if time is not CurfewService.UNSET: alarm_time = date_and_time.create_date_and_time(hours=time - 1) warning_span = now.time_till_next_day_time(alarm_time) if warning_span.in_ticks() == 0: warning_span += TimeSpan(date_and_time.sim_ticks_per_day()) self._curfew_warning_alarm_handle = alarms.add_alarm( self, warning_span, self._handle_warning_callback, False)
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 on_activate(self, reader): super().on_activate(reader) self.owner._set_job_role_state(self.owner.test_job.situation_job, self.owner.test_job.angry_role_state) timeout = 10 if reader is None else reader.read_float('timer', 10) self._handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(timeout), lambda _: self.timer_expired())
def _add_alarm(self): now = services.time_service().sim_now time_span = now.time_till_next_day_time(Retirement.DAILY_PAY_TIME) self._alarm_handle = alarms.add_alarm(self._sim_info, time_span, self._alarm_callback, repeating=False, use_sleep_time=False)
def on_activate(self, reader=None): super().on_activate(reader) self._update_roles() meal_timeout = self.owner.meal_timeout if reader is not None: meal_timeout = reader.read_float('meal_timeout', meal_timeout) self._meal_timeout_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(meal_timeout), self._meal_timeout_callback) self._test_event_register(TestEvent.InteractionComplete)
def activate_sprinkler_system(self): object_manager = services.object_manager() self._sprinkler_system_objects.update(object_manager.get_objects_with_tag_gen(self.SPRINKLER_BOX_OBJECT_TAG)) if not self._sprinkler_system_objects: return time_span = date_and_time.create_time_span(minutes=self.SPRINKLER_ACTIVATION_TIME) repeating_time_span = date_and_time.create_time_span(minutes=self.SPRINKLER_RUN_TIME) self._sprinkler_alarm = alarms.add_alarm(self, time_span, self._sprinkler_alarm_callback, repeating=True, repeating_time_span=repeating_time_span)
def setup_special_event_alarm(self): special_event_time_span = clock.interval_in_sim_minutes( self.SPECIAL_EVENT_SCHEDULE_DELAY) self._special_event_start_alarm = alarms.add_alarm( self, special_event_time_span, self._schedule_venue_special_events, repeating=False)
def set_update_alarm(self): self.sim_time_on_connect = services.time_service().sim_now self.server_time_on_connect = services.server_clock_service().now() self.sim_time_last_update = self.sim_time_on_connect self.server_time_last_update = self.server_time_on_connect self.update_alarm_handle = alarms.add_alarm( self, TimeSpan(self.TIME_DATA_UPDATE_RATE), self._update_timer_alarm, True)
def deactivate_set(self, whim_set, from_cheat=False, from_cancel=False): if whim_set.timeout_retest is not None and not from_cancel: resolver = event_testing.resolver.SingleSimResolver(self._sim_info) if resolver(whim_set.timeout_retest.objective_test): self.remove_alarm_handle(whim_set) self.alarm_handles[whim_set] = alarms.add_alarm(self, create_time_span(minutes=whim_set.active_timer), lambda _, this_whim_set=whim_set: self.deactivate_set(this_whim_set), False) return if whim_set in self.active_sets: self.active_sets.remove(whim_set) elif whim_set in self.active_chained_sets: self.active_chained_sets.remove(whim_set) self.remove_alarm_handle(whim_set) if whim_set.cooldown_timer == 0: self._sim_info.aspiration_tracker.reset_milestone(whim_set.guid64) elif whim_set not in self.sets_on_cooldown and not from_cheat: self.sets_on_cooldown.append(whim_set) self.alarm_handles[whim_set] = alarms.add_alarm(self, create_time_span(minutes=whim_set.cooldown_timer), lambda _, this_whim_set=whim_set: self.finish_cooldown(this_whim_set), False)
def activate_fire_alarms(self): object_manager = services.object_manager() self._fire_alarm_objects = set(object_manager.get_objects_of_type_gen(self.FIRE_ALARM_OBJECT_DEF)) if not self._fire_alarm_objects: return time_span = date_and_time.create_time_span(minutes=self.FIRE_ALARM_CYCLE_TIME) repeating_time_span = date_and_time.create_time_span(minutes=self.FIRE_ALARM_CYCLE_TIME) self._fire_alarm_alarm = alarms.add_alarm(self, time_span, self._fire_alarm_callback, repeating=True, repeating_time_span=repeating_time_span)
def _start_alarm(self): self._stop_alarm() if not self._sims_running_interaction: return next_hour = interval_in_sim_hours(int(self._total_time_ran.in_hours()) + 1) time_till_completion = (next_hour - self._total_time_ran)/len(self._sims_running_interaction) self._alarm_handle = alarms.add_alarm(self, time_till_completion, self._on_hour_reached) self._last_started_time = services.time_service().sim_now
def run(self): if self._operations and self._alarm_handle is None: time_span = clock.interval_in_sim_minutes( StatisticOperation.STATIC_CHANGE_INTERVAL) self._alarm_handle = alarms.add_alarm(self, time_span, self._do_statistic_gain, repeating=True)
def _start_off_lot_churn_alarm(self): self._off_lot_churn_alarm_handle = alarms.add_alarm( self, create_time_span( hours=BusinessService.HOURS_BETWEEN_OFF_LOT_SIMULATIONS), self._off_lot_churn_callback, repeating=True, use_sleep_time=False)
def on_activate(self, reader=None): logger.debug('Pizza delivery NPC is entering wait state.') super().on_activate(reader) self.owner._service_start_time = services.time_service().sim_now self.owner._set_job_role_state(self.owner.pizza_delivery_job.situation_job, self.owner.pizza_delivery_job.wait_to_deliver_state) timeout = self.owner.wait_for_customer_duration self._timeout_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(timeout), lambda _: self.timer_expired()) self._test_event_register(TestEvent.InteractionComplete)
def create_alarm(self): time_span = date_and_time.create_time_span(minutes=self.spawn_rate) self._puddle_alarm_handle = alarms.add_alarm( self.owner, time_span, self.try_create_puddle, repeating=True, repeating_time_span=time_span)
def _initialize_alarm(self): current_zone = services.current_zone() current_zone.unregister_callback(zone_types.ZoneState.RUNNING, self._initialize_alarm) time_span = clock.interval_in_sim_minutes(self.INTERVAL) self._alarm_handle = alarms.add_alarm(self, time_span, self._process_next_action, repeating=True)
def _create_curfew_ended_callback(self, now, time): if time is not CurfewService.UNSET: alarm_time = date_and_time.create_date_and_time( hours=CurfewService.CURFEW_END_TIME) curfew_span = now.time_till_next_day_time(alarm_time) if curfew_span.in_ticks() == 0: curfew_span += TimeSpan(date_and_time.sim_ticks_per_day()) self._curfew_ended_alarm_handle = alarms.add_alarm( self, curfew_span, self._handle_curfew_ended_callback, False)
def set_up_alarm(timer_data, handle, callback): if timer_data <= 0: return if handle is not None: alarms.cancel_alarm(handle) return alarms.add_alarm(self, clock.TimeSpan(timer_data), callback, use_sleep_time=False)
def _setup_score_add_alarm(self): if self.festival_contest_tuning._score_update_frequency > 0: duration = create_time_span( minutes=(self.festival_contest_tuning._score_update_frequency)) self._score_alarm = alarms.add_alarm(self, duration, self._score_add_callback, True) elif self.festival_contest_tuning._score_update_value_interval.upper_bound > 0: self._add_fake_score()
def on_activate(self, reader=None): super().on_activate(reader) time_out = self.owner.guests_start_reception_timeout if reader is not None: time_out = reader.read_float('start_reception_timer', time_out) self._start_reception_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(time_out), lambda _: self.timer_expired()) for custom_key in self.owner.ceremony.custom_keys_gen(): self._test_event_register(TestEvent.InteractionStart, custom_key) self.owner._set_job_role_state(self.owner.guest.situation_job, self.owner.guest.guest_gather_impatient_role_state)
def activate_chained_set(self, last_whim_set, goal, inherited_target_sim_info): for whim_set in last_whim_set.connected_whim_sets: while whim_set not in self.active_chained_sets and whim_set not in self.sets_on_cooldown: self._whimset_target_map[whim_set] = inherited_target_sim_info self.active_chained_sets.append(whim_set) if whim_set in self.active_sets: self.active_sets.remove(whim_set) self.remove_alarm_handle(whim_set) self.alarm_handles[whim_set] = alarms.add_alarm(self, create_time_span(minutes=whim_set.active_timer), lambda _, this_whim_set=whim_set: self.deactivate_set(this_whim_set), False) if goal in last_whim_set.connected_whims: whim_set = last_whim_set.connected_whims[goal] if whim_set not in self.active_chained_sets and whim_set not in self.sets_on_cooldown: self._whimset_target_map[whim_set] = inherited_target_sim_info self.active_chained_sets.append(whim_set) if whim_set in self.active_sets: self.active_sets.remove(whim_set) self.remove_alarm_handle(whim_set) self.alarm_handles[whim_set] = alarms.add_alarm(self, create_time_span(minutes=whim_set.active_timer), lambda _, this_whim_set=whim_set: self.deactivate_set(this_whim_set), False)
def enable_soak_maid_situation(_connection=None): alarm_handle = alarms.add_alarm(enable_soak_maid_situation, clock.interval_in_sim_minutes( SoakCommandsTuning.SOAK_MAID_COOLDOWN), _create_soak_maid_situation, repeating=True) _soak_alarm_handles.add(alarm_handle) output = sims4.commands.CheatOutput(_connection) output('soak maid enabled.')
def on_startup(self): self._select_next_contestant_alarm = alarms.add_alarm( self, create_time_span(minutes=self.check_contestant_alarm_timer), self._check_for_contestant, repeating=True) super().on_startup() if services.current_zone().is_zone_running: self.create_situations_during_zone_spin_up()
def on_activate(self, reader=None): super().on_activate(reader) time_out = self.owner.guests_become_impatient_timeout if reader is not None: time_out = reader.read_float('impatient_timer', time_out) self._impatient_alarm_handle = alarms.add_alarm( self, clock.interval_in_sim_minutes(time_out), lambda _: self.timer_expired()) self._test_event_register(TestEvent.InteractionStart)
def schedule_duration_alarm(self, callback, cross_zone=False): if self._duration_override is not None: time_span = TimeSpan(self._duration_override) else: time_span = create_time_span(minutes=self.duration) return alarms.add_alarm(self, time_span, callback, cross_zone=cross_zone)
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 _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 on_activate(self, reader=None): super().on_activate(reader) time_out = self.owner.guests_become_impatient_timeout if reader is not None: time_out = reader.read_float('impatient_timer', time_out) self._impatient_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(time_out), lambda _: self.timer_expired()) self._test_event_register(TestEvent.InteractionStart) if reader is not None and reader.read_bool('saved_during_ceremony', False): for (job_type, role_state_type) in self.owner._get_tuned_job_and_default_role_state_tuples(): self.owner._set_job_role_state(job_type, role_state_type)
def _career_situation_callback(self, scheduler, alarm_data, extra_data): if not self._sim_info.is_instanced() or self._sim_info.is_npc: return num_situations = len(self.current_level_tuning.situation_list) if num_situations > 0 and not self.currently_at_work: self._career_situation = self.current_level_tuning.situation_list[random.randint(0, num_situations - 1)] self.send_career_message(self.career_messages.career_situation_start_notification, self._career_situation) self.set_career_situation_available(True) self._career_situation_alarm = alarms.add_alarm(self, create_time_span(hours=self._career_situation.available_time), lambda _: self.set_career_situation_available(False)) self._situation_scheduler.add_cooldown(create_time_span(days=self.current_level_tuning.situation_cooldown))
def _attach_phase_exit_conditions(self, duration_override=None): self._phase_exit_condition_manager.attach_conditions( self, self._phase.exit_conditions_gen(), self._transition_to_next_phase) duration = duration_override if duration_override is not None else self._phase.get_duration( ) if duration != 0: self._phase_duration_alarm_handle = alarms.add_alarm( self, clock.interval_in_sim_minutes(duration), self._transition_to_next_phase)
def start(self): current_time = services.time_service().sim_now initial_time_span = current_time.time_till_next_day_time( self.OPEN_STREET_CLEANUP_TIME) repeating_time_span = date_and_time.create_time_span(days=1) self._alarm_handle = add_alarm(self, initial_time_span, self._on_update, repeating=True, repeating_time_span=repeating_time_span)
def _create_full_autonomy_alarm(self, time_until_trigger): if self._full_autonomy_alarm_handle is not None: self._destroy_full_autonomy_alarm() if time_until_trigger.in_ticks() <= 0: time_until_trigger = TimeSpan(1) self._full_autonomy_alarm_handle = alarms.add_alarm( self, time_until_trigger, self._on_run_full_autonomy_callback, use_sleep_time=False)
def _create_culling_alarm(self): self._destroy_culling_alarm() time_range = date_and_time.create_time_span( minutes=RelationshipGlobalTuning.DELAY_UNTIL_RELATIONSHIP_IS_CULLED ) self._culling_alarm_handle = alarms.add_alarm( self, time_range, self._cull_relationship_callback, cross_zone=True)
def on_activate(self, reader=None): super().on_activate(reader) self.owner._set_job_role_state(self.owner.role.situation_job, self.owner.role.do_stuff_role_state) timeout = self.owner.do_stuff_timeout if reader is not None: timeout = reader.read_float(DO_STUFF_TIMEOUT, timeout) self._timeout_handle = alarms.add_alarm( self, clock.interval_in_sim_minutes(timeout), lambda _: self._timer_expired())
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() most_appropriate_buff = None for sleep_schedule_entry in sorted(self.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 - date_and_time.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, date_and_time.create_time_span(hours=date_and_time.HOURS_PER_DAY)) self._sleep_buff_alarms[alarm_handle] = sleep_schedule_entry.buff if most_appropriate_buff and 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 _add_alarm(self, cur_state, game_clock, state, change): time_to_day = game_clock.time_until_hour_of_day(change.start_time) def change_state(_): self.owner.set_state(state, change.value) self.alarm_handles.append(alarms.add_alarm(self.owner, time_to_day, change_state, repeating=True, repeating_time_span=self.DAILY_REPEAT)) if cur_state is None or time_to_day > cur_state[0]: return (time_to_day, change.value) return cur_state
def run(self, callback): super().run(callback) self._last_update_time = services.time_service().sim_now time_span = clock.interval_in_sim_minutes( Career.CAREER_PERFORMANCE_UPDATE_INTERVAL) self._update_alarm_handle = alarms.add_alarm( self, time_span, lambda alarm_handle: self._update(), repeating=True)
def _set_alarm(self, time): time_span = clock.interval_in_sim_minutes(time) self._alarm_handle = alarms.add_alarm(self, time_span, self._alarm_callback, repeating=False) logger.assert_raise( self._alarm_handle is not None, 'Failed to create timeout alarm for rel bit {}'.format(self.bit)) self._start_time = services.time_service().sim_now
def activate_set(self, whim_set, is_cheat=False): if whim_set in self.sets_on_cooldown: return if whim_set not in self.active_sets and whim_set not in self.active_chained_sets: if __debug__ and not is_cheat: self._whimset_objective_map[whim_set] = self._sim_info.aspiration_tracker.latest_objective self.active_sets.append(whim_set) self.remove_alarm_handle(whim_set) self.alarm_handles[whim_set] = alarms.add_alarm(self, create_time_span(minutes=whim_set.active_timer), lambda _, this_whim_set=whim_set: self.deactivate_set(this_whim_set), False) refresh_delay = whim_set.new_whim_delay.random_int() self.refresh_goals(request_single_goal=True, request_single_delay=refresh_delay)
def _schedule_phone_call_alarm(self): delay = random.randint(HouseholdManager.PHONE_CALL_INFO.minimum_time_between_calls, HouseholdManager.PHONE_CALL_INFO.maximum_time_between_calls) time_delay = interval_in_sim_minutes(delay) current_time = services.time_service().sim_now alarm_end_time = current_time + time_delay if alarm_end_time.time_between_day_times(HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.start_time, HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.end_time): time_till_alarm_end_time = alarm_end_time - current_time self._phone_call_alarm_handle = alarms.add_alarm(self, time_till_alarm_end_time, self._trigger_phone_call_callback) return if current_time.time_between_day_times(HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.start_time, HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.end_time): time_till_next_end_time = current_time.time_till_next_day_time(HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.end_time) else: time_till_next_end_time = TimeSpan.ZERO time_delay -= time_till_next_end_time time_available_per_day = HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.end_time - HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.start_time cycles_left = time_delay.in_ticks()//time_available_per_day.in_ticks() time_till_next_start_time = current_time.time_till_next_day_time(HouseholdManager.PHONE_CALL_INFO.availible_time_of_day.start_time) time_till_alarm_end_time = time_till_next_start_time + interval_in_sim_days(cycles_left) time_delay -= time_available_per_day*cycles_left time_till_alarm_end_time += time_delay self._phone_call_alarm_handle = alarms.add_alarm(self, time_till_alarm_end_time, self._trigger_phone_call_callback)