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)