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 __init__(self, *args, reader=None, **kwargs):
super().__init__(reader=reader, *args, **kwargs)
self._total_time_ran = TimeSpan.ZERO
self._last_started_time = None
self._alarm_handle = None
self._total_duration = interval_in_sim_hours(self._goal_test.duration)
self._test_events = set()
self._test_events.add(
event_testing.test_events.TestEvent.InteractionStart)
self._test_events.add(
event_testing.test_events.TestEvent.InteractionComplete)
services.get_event_manager().register(self, self._test_events)
if reader is not None:
duration_run = reader.read_uint64(self.DURATION_RUN, 0)
self._total_time_ran = TimeSpan(duration_run)
self._sims_running_interaction = set()
if self._situation is None and self._sim_info is not None:
self._sims_running_interaction.add(self._actor_ref().id)
else:
for sim in self._situation.all_sims_in_situation_gen():
while sim.si_state.is_running_affordance(
self._goal_test.affordance):
self._sims_running_interaction.add(sim.id)
if self._sims_running_interaction:
self._start_alarm()
def setup_rented_zone_alarms(self):
if self._end_vacation_alarm is not None:
alarms.cancel_alarm(self._end_vacation_alarm)
time_now = services.time_service().sim_now
self._end_vacation_alarm = alarms.add_alarm(
self,
self.end_timestamp - time_now,
self._travel_group_end_callback,
repeating=False)
if self._days_left_notification_alarm is not None:
alarms.cancel_alarm(self._days_left_notification_alarm)
days_before_vacation_ends = clock.interval_in_sim_days(
TravelGroupTuning.VACATION_ENDING_DAYS_TNS.
days_before_vacation_ends)
days_left_timestamp = self.end_timestamp + -days_before_vacation_ends
if days_left_timestamp > time_now:
self._days_left_notification_alarm = alarms.add_alarm(
self,
days_left_timestamp - time_now,
self._days_left_notification_callback,
repeating=False)
if self._hours_left_notification_alarm is not None:
alarms.cancel_alarm(self._hours_left_notification_alarm)
hours_before_vacation_ends = clock.interval_in_sim_hours(
TravelGroupTuning.VACATION_ENDING_HOURS_TNS.
hours_before_vacation_ends)
hours_left_timestamp = self.end_timestamp + -hours_before_vacation_ends
if hours_left_timestamp > time_now:
self._hours_left_notification_alarm = alarms.add_alarm(
self,
hours_left_timestamp - time_now,
self._hours_left_notification_callback,
repeating=False)
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 get_busy_time_periods(self):
busy_times = []
busy_times.extend(self._work_scheduler.get_schedule_times())
for time_period in self.current_level_tuning.additional_unavailable_times:
start_time = time_period.start_time()
end_time = start_time + clock.interval_in_sim_hours(time_period.period_duration)
busy_times.append((start_time.absolute_ticks(), end_time.absolute_ticks()))
return busy_times
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 _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 _set_expected_time(self, target_hours, target_minutes, days_ahead):
clock = services.game_clock_service()
self._current_date_and_time = clock.now()
clock_days = int(self._current_date_and_time.absolute_days())
time_span = self._current_date_and_time - DateAndTime(interval_in_sim_days(clock_days).in_ticks())
current_date_and_time_minus_days = DateAndTime(time_span.in_ticks())
clock_hours = int(current_date_and_time_minus_days.absolute_hours())
time_span = current_date_and_time_minus_days - DateAndTime(interval_in_sim_hours(clock_hours).in_ticks())
current_date_and_time_minus_hours = DateAndTime(time_span.in_ticks())
clock_minutes = int(current_date_and_time_minus_hours.absolute_minutes())
delta_days = days_ahead
clock_day_minutes = clock_hours*60 + clock_minutes
target_day_minutes = target_hours*60 + target_minutes
delta_day_minutes = target_day_minutes - clock_day_minutes
if delta_day_minutes < 0:
delta_day_minutes += 1440
self._expected_data_and_time = self._current_date_and_time + interval_in_sim_days(delta_days) + interval_in_sim_minutes(delta_day_minutes)
def __init__(self, *args, reader=None, **kwargs):
super().__init__(*args, reader=reader, **kwargs)
self._total_time_ran = TimeSpan.ZERO
self._last_started_time = None
self._alarm_handle = None
self._total_duration = interval_in_sim_hours(self._goal_test.duration)
for custom_key in self._goal_test.custom_keys_gen():
services.get_event_manager().register_with_custom_key(
self, event_testing.test_events.TestEvent.InteractionStart,
custom_key)
services.get_event_manager().register_with_custom_key(
self, event_testing.test_events.TestEvent.InteractionComplete,
custom_key)
if reader is not None:
duration_run = reader.read_uint64(self.DURATION_RUN, 0)
self._total_time_ran = TimeSpan(duration_run)
self._sims_running_interaction = set()
def __init__(self, *args, reader=None, **kwargs):
super().__init__(reader=reader, *args, **kwargs)
self._total_time_ran = TimeSpan.ZERO
self._last_started_time = None
self._alarm_handle = None
self._total_duration = interval_in_sim_hours(self._goal_test.duration)
self._test_events = set()
self._test_events.add(event_testing.test_events.TestEvent.InteractionStart)
self._test_events.add(event_testing.test_events.TestEvent.InteractionComplete)
services.get_event_manager().register(self, self._test_events)
if reader is not None:
duration_run = reader.read_uint64(self.DURATION_RUN, 0)
self._total_time_ran = TimeSpan(duration_run)
self._sims_running_interaction = set()
if self._situation is None and self._sim_info is not None:
self._sims_running_interaction.add(self._actor_ref().id)
else:
for sim in self._situation.all_sims_in_situation_gen():
while sim.si_state.is_running_affordance(self._goal_test.affordance):
self._sims_running_interaction.add(sim.id)
if self._sims_running_interaction:
self._start_alarm()
def _set_up_temporary_perk_timer(self, perk, remaining_ticks=None):
if perk.temporary_perk_information is None:
logger.error(
'Attempting to setup and alarm for a Perk that is not temporary. {}',
perk)
return False
if perk in self._active_perk_timers[perk.associated_bucks_type]:
logger.error(
'Attempting to add a timer for a temporary Perk that arleady has a timer set up. {}',
perk)
return False
if remaining_ticks is None:
time_until_perk_lock = interval_in_sim_hours(
perk.temporary_perk_information.duration)
else:
time_until_perk_lock = clock.TimeSpan(remaining_ticks)
perk_timer_handle = alarms.add_alarm(self,
time_until_perk_lock,
lambda _: self.lock_perk(perk),
cross_zone=True)
self._active_perk_timers[
perk.associated_bucks_type][perk] = perk_timer_handle
return True
def _is_correct_time(cls):
current_time = services.time_service().sim_now
start_time = cls.WALKBY_ALLOWED_START_TIME
end_time = start_time + clock.interval_in_sim_hours(
cls.WALKBY_ALLOWED_DURATION)
return current_time.time_between_day_times(start_time, end_time)
