def begin_walkbys(self):
self._sources.append(
_AmbientSourceStreet(_AmbientSource.DEFAULT_PRIORITY_MULTIPLIER))
self._sources.append(
_AmbientSourceGhost(_AmbientSource.DEFAULT_PRIORITY_MULTIPLIER))
for source in self._sources:
source.begin_scheduled_walkbys()
open_street_id = services.current_zone().open_street_id
open_street_data = services.get_persistence_service(
).get_open_street_proto_buff(open_street_id)
if open_street_data is not None:
for source_data in open_street_data.ambient_service.sources:
for source in self._sources:
if source.source_type == source_data.source_type:
source.load(source_data)
break
self._update_alarm_handle = alarms.add_alarm(
self,
clock.interval_in_sim_minutes(5),
self._update_alarm_callback,
repeating=True,
use_sleep_time=False)
self._flavor_alarm_handle = alarms.add_alarm(
self,
clock.interval_in_sim_minutes(1),
self._flavor_alarm_callback,
repeating=True,
use_sleep_time=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._walker = None
self._flavor_cooldown_until = services.time_service().sim_now + clock.interval_in_sim_minutes(10)
self._social_cooldown_until = services.time_service().sim_now + clock.interval_in_sim_minutes(10)
self._other_social_situation = None
self._social_interaction = None
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._walker = None
self._flavor_cooldown_until = services.time_service(
).sim_now + clock.interval_in_sim_minutes(10)
self._social_cooldown_until = services.time_service(
).sim_now + clock.interval_in_sim_minutes(10)
self._other_social_situation = None
self._social_interaction = None
def on_activate(self, reader):
super().on_activate(reader)
self._handle = alarms.add_alarm(
self,
clock.interval_in_sim_minutes(
self.owner.VERIFY_INTERACTION_INTERVAL),
lambda _: self.timer_expired(),
repeating=True,
repeating_time_span=clock.interval_in_sim_minutes(
self.owner.VERIFY_INTERACTION_INTERVAL))
def start(self, *_, **__):
for periodic_loot_data in self.periodic_loots:
alarm_handle = alarms.add_alarm(
self._owner,
clock.interval_in_sim_minutes(
periodic_loot_data.initial_delay),
lambda _, loots=periodic_loot_data.loots_to_apply: self.
_apply_loots(loots),
repeating=True,
repeating_time_span=clock.interval_in_sim_minutes(
periodic_loot_data.frequency_interval))
self._alarm_handles.append(alarm_handle)
def record_python_memory_start(start_time:int=150, frequency:int=120, _connection=None):
global g_log_python_memory_alarm
record_python_memory_stop(_connection=_connection)
output = sims4.commands.CheatOutput(_connection)
repeating_time_span = clock.interval_in_sim_minutes(frequency)
def record_callback(_):
sims4.commands.client_cheat('|memory_dump', _connection)
sims4.commands.client_cheat('|py.heapcheckpoint', _connection)
output('Recording python memory. Next attempt in {}.'.format(repeating_time_span))
time_span = clock.interval_in_sim_minutes(start_time)
g_log_python_memory_alarm = alarms.add_alarm(record_python_memory_start, time_span, record_callback, repeating=True, repeating_time_span=repeating_time_span)
output('Recording python memory. First record will occur in {}.'.format(time_span))
def begin_walkbys(self):
self._sources.append(_AmbientSourceStreet(2.1))
self._update_alarm_handle = alarms.add_alarm(
self,
clock.interval_in_sim_minutes(5),
self._update_alarm_callback,
repeating=True,
use_sleep_time=False)
self._flavor_alarm_handle = alarms.add_alarm(
self,
clock.interval_in_sim_minutes(1),
self._flavor_alarm_callback,
repeating=True,
use_sleep_time=False)
def record_python_memory_start(start_time:int=150, frequency:int=120, _connection=None):
global g_log_python_memory_alarm
record_python_memory_stop(_connection=_connection)
output = sims4.commands.CheatOutput(_connection)
repeating_time_span = clock.interval_in_sim_minutes(frequency)
def record_callback(_):
sims4.commands.client_cheat('|memory_dump', _connection)
sims4.commands.client_cheat('|py.heapcheckpoint', _connection)
output('Recording python memory. Next attempt in {}.'.format(repeating_time_span))
time_span = clock.interval_in_sim_minutes(start_time)
g_log_python_memory_alarm = alarms.add_alarm(record_python_memory_start, time_span, record_callback, repeating=True, repeating_time_span=repeating_time_span)
output('Recording python memory. First record will occur in {}.'.format(time_span))
def reset_relevancy(self):
relevancy = self.relevancy_value.random_int()
if self.is_timed_relevancy:
self.current_relevancy = services.time_service(
).sim_now + clock.interval_in_sim_minutes(relevancy)
else:
self.current_relevancy = relevancy
def _schedule_welcome_wagon(self):
parser = argparse.ArgumentParser()
parser.add_argument('--no_welcome_wagon',
default=False,
action='store_true')
(args, unused_args) = parser.parse_known_args()
if args.no_welcome_wagon:
return
active_household = services.active_household()
if not active_household.needs_welcome_wagon:
return
if services.current_zone_id() != active_household.home_zone_id:
return
venue = services.get_current_venue()
if not venue.supports_welcome_wagon:
return
minimum_time = interval_in_sim_minutes(
NPCHostedSituationService.WELCOME_WAGON_TUNING.
minimum_time_to_start_situation)
now = services.time_service().sim_now
possible_time = now + minimum_time
if possible_time.time_between_day_times(
NPCHostedSituationService.WELCOME_WAGON_TUNING.
available_time_of_day.start_time, NPCHostedSituationService.
WELCOME_WAGON_TUNING.available_time_of_day.end_time):
time_till_welcome_wagon = minimum_time
else:
time_till_welcome_wagon = now.time_till_next_day_time(
NPCHostedSituationService.WELCOME_WAGON_TUNING.
available_time_of_day.start_time)
self._welcome_wagon_alarm = alarms.add_alarm(self,
time_till_welcome_wagon,
self._start_welcome_wagon)
def is_on_cooldown(self):
if self._completed_time is None:
return False
time_since_last_completion = services.time_service(
).sim_now - self._completed_time
return time_since_last_completion < interval_in_sim_minutes(
self._cooldown)
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 _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_activate(self, reader=None):
super().on_activate(reader)
now = services.game_clock_service().now()
time_till_first_count = now.time_till_next_day_time(
self.time_to_start_count)
time_till_celebration = now.time_till_next_day_time(
self.celebrate_time)
repeat_time_span = clock.interval_in_sim_minutes(
self.interval_between_counts)
if time_till_first_count > time_till_celebration:
time_of_first_count = now + time_till_first_count + clock.interval_in_sim_days(
-1)
time_since_first_count = now - time_of_first_count
time_of_next_count = time_of_first_count + repeat_time_span * (
int(time_since_first_count.in_ticks() /
repeat_time_span.in_ticks()) + 1)
time_till_first_count = time_of_next_count - now
self._count_timer = alarms.add_alarm(
self,
time_till_first_count,
self._count_callback,
repeating=True,
repeating_time_span=repeat_time_span)
self._celebrate_timer = alarms.add_alarm(self, time_till_celebration,
self._celebrate_callback)
def _move_objects(self):
objects_to_move = services.object_manager().get_objects_matching_tags(self.object_tags, match_any=True)
if not objects_to_move:
return
resolver = self._get_placement_resolver()
choices = [(location.weight.get_multiplier(resolver), location.placement_strategy) for location in self.placement_strategy_locations]
chosen_strategy = random.weighted_random_item(choices)
do_fade = self.fade is not None
out_sequence = []
moves = []
in_sequence = []
for object_to_move in objects_to_move:
object_to_move.cancel_interactions_running_on_object(FinishingType.OBJECT_CHANGED, cancel_reason_msg='Object changing location.')
if self.vfx_on_move is not None:
out_sequence.append(lambda _, object_to_move=object_to_move: self.vfx_on_move(object_to_move).start_one_shot())
if do_fade:
out_sequence.append(lambda _, object_to_move=object_to_move: object_to_move.fade_out(self.fade.out_time))
moves.append(lambda _, object_to_move=object_to_move: chosen_strategy.try_place_object(object_to_move, resolver))
if do_fade:
in_sequence.append(lambda _, object_to_move=object_to_move: object_to_move.fade_in(self.fade.in_time))
sequence = []
if out_sequence:
sequence.append(out_sequence)
sequence.append(SoftSleepElement(clock.interval_in_sim_minutes(self.fade.out_time)))
sequence.append(moves)
if in_sequence:
sequence.append(in_sequence)
element = build_element(sequence, critical=CleanupType.RunAll)
services.time_service().sim_timeline.schedule(element)
def _on_social_finished(self):
self._other_social_situation = None
self._social_interaction = None
self._social_cooldown_until = services.time_service(
).sim_now + clock.interval_in_sim_minutes(
services.current_zone().ambient_service.SOCIAL_COOLDOWN)
self._change_state(_LeaveState())
def run(self, callback):
super().run(callback)
self._last_performance_change_time = services.time_service().sim_now
time_span = clock.interval_in_sim_minutes(
Career.CAREER_PERFORMANCE_UPDATE_INTERVAL)
self._performance_change_alarm_handle = alarms.add_alarm(
self, time_span, self._do_performance_change, repeating=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 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_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 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 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 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 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 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 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 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 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 reset_trigger_time(self, new_trigger_interval: float):
if new_trigger_interval is not None and new_trigger_interval > 0:
now = services.time_service().sim_now
self._trigger_time = now + clock.interval_in_sim_minutes(
new_trigger_interval)
else:
self._trigger_time = None
if self._on_callback_alarm_reset is not None:
self._on_callback_alarm_reset(self._stat, self._trigger_time)
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 _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 __call__(self, data_object=None, objective_guid64=None):
total_time_elapsed = data_object.get_total_tag_interaction_time_elapsed(self.tag_to_test)
relative_start_value = data_object.get_starting_values(objective_guid64)
if relative_start_value is not None:
time = 0
total_time_elapsed -= interval_in_sim_minutes(relative_start_value[time])
if total_time_elapsed >= self.length_of_time:
return TestResult.TRUE
return TestResultNumeric(False, 'TotalTimeElapsedByTagTest: Not enough time elapsed on tag{}.', self.tag_to_test, current_value=total_time_elapsed.in_hours(), goal_value=self.length_of_time.in_hours(), is_money=False)
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_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 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 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 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 reserve_waiting_sim(self, reserved_sim_id, reserver_id):
for situation_id in self._waiting_situations:
if reserved_sim_id in self._waiting_situations[situation_id]:
self._reservations[situation_id] = {
'expiration':
services.time_service().sim_now +
interval_in_sim_minutes(30),
'reserver_id':
reserver_id
}
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 _check_target_status(self, *args, **kwargs):
if self.pipeline_progress > PipelineProgress.QUEUED:
self._cancel_waiting_alarm()
return
now = services.time_service().sim_now
maximum_wait_time = LOSAndSocialConstraintTuning.incompatible_target_sim_maximum_time_to_wait
if now - self._waiting_start_time > clock.interval_in_sim_minutes(maximum_wait_time):
self.cancel(FinishingType.INTERACTION_INCOMPATIBILITY, 'Timeout due to incompatibility.')
self._cancel_waiting_alarm()
self._get_close_to_target()
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 _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 _get_absolute_timeout_time(self, commodity_instance, threshold):
rate_multiplier = commodity_instance.get_decay_rate_modifier()
if rate_multiplier < 1:
time = commodity_instance.get_decay_time(threshold)
rate_multiplier = 1
else:
time = commodity_instance.get_decay_time(threshold, use_decay_modifier=False)
if time is not None and time != 0:
time_now = services.time_service().sim_now
time_stamp = time_now + interval_in_sim_minutes(time)
return (time_stamp.absolute_ticks(), rate_multiplier)
return NO_TIMEOUT
def reset_trigger_time(self, new_trigger_interval):
old_trigger_time = self._trigger_time
now = services.time_service().sim_now
if new_trigger_interval is not None and new_trigger_interval > 0:
self._trigger_time = now + clock.interval_in_sim_minutes(new_trigger_interval)
else:
self._trigger_time = None
logger.debug('Resetting trigger time for stat {} at threshold {}; old time: {}, new time: {}', self._stat, self._threshold, old_trigger_time, self._trigger_time)
if self._trigger_time is None:
return
if self._on_callback_alarm_reset is not None:
self._on_callback_alarm_reset(self._stat, self._trigger_time)
def queue_adventure_moment(self, adventure_moment_key):
if self._maximum_triggers and self._adventure_moment_count >= self._maximum_triggers:
return
time_span = clock.interval_in_sim_minutes(self._trigger_interval.random_float())
def callback(alarm_handle):
self._alarm_handle = None
if not self._canceled:
self.tracker.remove_adventure_moment(self.interaction)
self._run_adventure_moment(adventure_moment_key)
self.tracker.set_adventure_moment(self.interaction, adventure_moment_key)
self._alarm_handle = add_alarm(self, time_span, callback)
def __init__(self, interaction, *, timeout, timeout_affordance):
def on_alarm(*_, **__):
if interaction.running:
return
if interaction.transition is not None and interaction.transition.running:
return
if timeout_affordance is not None:
context = interaction.context.clone_for_continuation(interaction)
interaction.sim.push_super_affordance(timeout_affordance, interaction.target, context)
interaction.cancel(FinishingType.LIABILITY, cancel_reason_msg='Timeout after {} sim minutes.'.format(timeout))
time_span = clock.interval_in_sim_minutes(timeout)
self._handle = alarms.add_alarm(self, time_span, on_alarm)
def __init__(self, participant, affordances, interaction_outcome, running_time, target_filters, tags, test_event, consider_cancelled_as_failure, **kwargs):
super().__init__(**kwargs)
self.participant_type = participant
self.affordances = affordances
self.interaction_outcome = interaction_outcome
if running_time is not None:
self.running_time = interval_in_sim_minutes(running_time)
else:
self.running_time = None
self.tags = tags
self.object_tags = target_filters.object_tags
if test_event == InteractionTestEvents.InteractionUpdate:
self.test_events = (test_event, InteractionTestEvents.InteractionComplete)
else:
self.test_events = (test_event,)
self.consider_cancelled_as_failure = consider_cancelled_as_failure
def _run(self, timeline):
if self.timing == self.AT_BEGINNING:
if self.offset_time is None:
sequence = [self._behavior_element, self.sequence]
else:
delayed_sequence = build_element([elements.SleepElement(clock.interval_in_sim_minutes(self.offset_time)), self._behavior_element])
if self.sequence:
sequence = elements.AllElement([delayed_sequence, self.sequence])
else:
sequence = delayed_sequence
elif self.timing == self.AT_END:
sequence = [self.sequence, self._behavior_element]
elif self.timing == self.ON_XEVT:
sequence = [build_critical_section(self._register_event_handler, self.sequence, self._release_event_handler), self._behavior_element]
child_element = build_element(sequence, critical=self.criticality)
child_element = self._build_outer_elements(child_element)
return timeline.run_child(child_element)
def add_lockout(self, obj, duration_in_sim_minutes):
if self is obj:
return
interval = clock.interval_in_sim_minutes(duration_in_sim_minutes)
end_time = services.time_service().sim_now + interval
lockout = self._lockouts.get(obj, None)
if lockout is None or lockout < end_time:
self._lockouts[obj] = end_time
crafting_lockout = self._crafting_lockouts.get(obj, None)
if crafting_lockout is None:
crafting_lockout_data = None
for super_affordance in obj.super_affordances():
while hasattr(super_affordance, 'crafting_type_requirement') and super_affordance.crafting_type_requirement is not None:
if crafting_lockout_data is None:
crafting_lockout_data = _CraftingLockoutData()
crafting_lockout_data.add_lockout(super_affordance.crafting_type_requirement)
if crafting_lockout_data is not None:
self._crafting_lockouts[obj] = crafting_lockout_data
def request_service(self, household, service_npc_tuning, from_load=False, user_specified_data_id=None, is_recurring=False):
if self._is_service_already_in_request_list(household, service_npc_tuning):
return
service_record = household.get_service_npc_record(service_npc_tuning.guid64)
if service_record.hired and not from_load:
return
service_record.hired = True
service_record.recurring = is_recurring
service_record.user_specified_data_id = user_specified_data_id
if from_load:
min_alarm_time_span = None
else:
min_alarm_time_span = clock.interval_in_sim_minutes(service_npc_tuning.request_offset)
min_duration_remaining = service_npc_tuning.min_duration_left_for_arrival_on_lot()
situation_creation_params = ServiceNpcSituationCreationParams(household, service_npc_tuning, user_specified_data_id, is_recurring)
service_npc_request = service_npc_tuning.work_hours(start_callback=self._send_service_npc, min_alarm_time_span=min_alarm_time_span, min_duration_remaining=min_duration_remaining, extra_data=situation_creation_params)
self._service_npc_requests.append(service_npc_request)
request_trigger_time = service_npc_request.get_alarm_finishing_time()
return request_trigger_time
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)
def soak_and_save(frequency:int=60, _connection=None):
global g_soak_and_save_alarm
output = sims4.commands.CheatOutput(_connection)
time_span = clock.interval_in_sim_minutes(frequency)
def save_once(_):
global g_soak_save_counter
if services.get_persistence_service().is_save_locked():
output('Saving the game skipped since saving is locked. Next attempt in {}.'.format(time_span))
return
save_name = 'SoakSave{}'.format(g_soak_save_counter)
slot_id = g_soak_save_slot_start + g_soak_save_counter
if g_soak_save_counter < g_maximum_soak_save_slots:
save_to_new_slot(slot_id=slot_id, slot_name=save_name, _connection=_connection)
else:
override_save_slot(slot_id=slot_id, slot_name=save_name, _connection=_connection)
g_soak_save_counter = (g_soak_save_counter + 1) % g_maximum_soak_save_slots
output('Game saved {} at slot {}. Next attempt in {}.'.format(save_name, slot_id, time_span))
if g_soak_and_save_alarm is not None:
alarms.cancel_alarm(g_soak_and_save_alarm)
g_soak_and_save_alarm = alarms.add_alarm(soak_and_save, time_span, save_once, repeating=True)
output('Saving the game every {}.'.format(time_span))
def _start_statistic_gains(self):
self._end_statistic_gains()
periodic_mods_by_participant = {}
exclusive_mods_by_participant = {}
interaction_resolver = self._interaction.get_resolver()
if self._basic_content_operations:
for stat_op in self._basic_content_operations:
self._add_operation_if_valid(interaction_resolver, stat_op, periodic_mods_by_participant, exclusive_mods_by_participant)
if self._loot_operations:
for loot in self._loot_operations:
for (loot_op, test_ran) in loot.get_loot_ops_gen(resolver=interaction_resolver):
self._add_operation_if_valid(interaction_resolver, loot_op, periodic_mods_by_participant, exclusive_mods_by_participant, skip_test=test_ran)
self._create_and_add_autonomy_modifier(periodic_mods_by_participant)
si = self._interaction if self._interaction.is_super else self._interaction.super_interaction
self._create_and_add_autonomy_modifier(exclusive_mods_by_participant, si)
self._change_helper = StatisticChangeHelper(self._interaction, self._operations_on_alarm, self)
result = False
if self._change_helper is not None:
time_span = clock.interval_in_sim_minutes(self._alarm_interval)
self._alarm_handle = alarms.add_alarm(self, time_span, self._do_gain, repeating=True)
if self._trigger_gain_on_start:
self._apply_all_valid_ops(interaction_resolver)
result = True
return result
def on_activate(self, reader=None):
super().on_activate(reader)
self._handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(5), lambda _: self.timer_expired(), repeating=True, repeating_time_span=clock.interval_in_sim_minutes(5))
def __init__(self, tag_to_test, length_of_time, **kwargs):
super().__init__(**kwargs)
self.tag_to_test = tag_to_test
self.length_of_time = interval_in_sim_minutes(length_of_time)
def __init__(self, buff_to_check, length_of_time, buff_test_type, **kwargs):
super().__init__(**kwargs)
self.buffs_to_check = buff_to_check
self.length_of_time = interval_in_sim_minutes(length_of_time)
self.buff_test_type = buff_test_type
def get_valid_first_work_day_time(self):
if self._join_time is None:
return DATE_AND_TIME_ZERO
return self._join_time + clock.interval_in_sim_minutes(self.JOB_START_DELAY)
def enable_soak_handyman_situation(_connection=None):
alarm_handle = alarms.add_alarm(enable_soak_handyman_situation, clock.interval_in_sim_minutes(SoakCommandsTuning.SOAK_HANDYMAN_COOLDOWN), _create_soak_handyman_situation, repeating=True)
_soak_alarm_handles.add(alarm_handle)
output = sims4.commands.CheatOutput(_connection)
output('soak handyman enabled.')
def begin_walkbys(self):
self._sources.append(_AmbientSourceStreet(2.1))
self._update_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(5), self._update_alarm_callback, repeating=True, use_sleep_time=False)
self._flavor_alarm_handle = alarms.add_alarm(self, clock.interval_in_sim_minutes(1), self._flavor_alarm_callback, repeating=True, use_sleep_time=False)
