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