def picker_rows_gen(cls, inst, target, context, **kwargs): inst_or_cls = inst if inst is not None else cls actor = inst_or_cls.get_participant( sim=context.sim, target=target, participant_type=ParticipantType.Actor, **kwargs) familiar_tracker = actor.sim_info.familiar_tracker if familiar_tracker is not None: rabbit_hole_service = services.get_rabbit_hole_service() current_region = services.current_region() sim_info_manager = services.sim_info_manager() for familiar_info in familiar_tracker: is_enable = True row_tooltip = None if rabbit_hole_service.is_in_rabbit_hole( familiar_info.pet_familiar_id): is_enable = False row_tooltip = inst_or_cls.rabbit_holed_disabled_tooltip else: pet_familiar = sim_info_manager.get( familiar_info.pet_familiar_id) sim_region = region.get_region_instance_from_zone_id( pet_familiar.zone_id) is_enable = False row_tooltip = inst_or_cls.incompatible_region_disabled_tooltip row = BasePickerRow(name=familiar_info.name, icon_info=familiar_info.icon_info, tag=familiar_info.uid, is_enable=is_enable, row_tooltip=row_tooltip) yield row
def fishing_data(self): if self._fishing_data is self.USE_REGION_TUNING: current_region = services.current_region() if current_region is not None: return current_region.fishing_data return return self._fishing_data
def get_hangout_zone_id(self, prefer_current=False): if self.hangout_setting == ClubHangoutSetting.HANGOUT_NONE: return 0 if self.hangout_setting == ClubHangoutSetting.HANGOUT_VENUE: current_region = services.current_region() def is_valid_zone_id(zone_id): if not self.is_zone_valid_for_gathering(zone_id): return False zone_region = get_region_instance_from_zone_id(zone_id) if zone_region is None: return False elif not current_region.is_region_compatible(zone_region): return False return True venue_service = services.venue_service() available_zone_ids = tuple( filter( is_valid_zone_id, venue_service.get_zones_for_venue_type_gen( self.hangout_venue))) for venue in self.hangout_venue.included_venues_for_club_gathering: included_zone_ids = tuple( filter(is_valid_zone_id, venue_service.get_zones_for_venue_type_gen(venue))) available_zone_ids += included_zone_ids if not available_zone_ids: return 0 if prefer_current: current_zone_id = services.current_zone_id() if current_zone_id in available_zone_ids: return current_zone_id return random.choice(available_zone_ids) return self.hangout_zone_id
def is_sun_out(self): region_instance = services.current_region() if region_instance is None or not region_instance.provides_sunlight: return False weather_service = services.weather_service() if weather_service is not None and weather_service.is_shady(): return False return self.is_day_time()
def request_club_invite(club_id: int, _connection=None): sim_info = services.active_sim_info() if sim_info is None: return club_service = services.get_club_service() if club_service is None: return club = club_service.get_club_by_id(club_id) if club is None: return if any(club_member.is_selectable for club_member in club.members): club.show_club_notification( sim_info, ClubTunables.CLUB_GATHERING_DIALOG_REQUEST_INVITE_ACTIVE_SIM) elif club in club_service.clubs_to_gatherings_map: club.show_club_notification( sim_info, ClubTunables.CLUB_GATHERING_DIALOG_REQUEST_INVITE_CURRENT_LOT) else: club_hangout_zone_id = club.get_hangout_zone_id() if club.hangout_setting == ClubHangoutSetting.HANGOUT_LOT: current_region = services.current_region() hangout_region = get_region_instance_from_zone_id( club_hangout_zone_id) if not current_region.is_region_compatible(hangout_region): club.show_club_notification( sim_info, ClubTunables. CLUB_GATHERING_DIALOG_REQUEST_INVITE_UNAVAILABLE, target_sim_id=club.leader.sim_id) return elif not club_hangout_zone_id: if services.active_lot_id() == services.active_household_lot_id(): def on_response(dialog): if dialog.accepted: club_service.start_gathering( club, host_sim_id=sim_info.sim_id, invited_sims=(sim_info, ), ignore_zone_validity=True) club.show_club_notification( sim_info, ClubTunables.CLUB_GATHERING_DIALOG_REQUEST_INVITE_NO_LOT, target_sim_id=club.leader.sim_id, on_response=on_response) else: club.show_club_notification( sim_info, ClubTunables. CLUB_GATHERING_DIALOG_REQUEST_INVITE_NO_LOT_NOT_HOME, target_sim_id=club.leader.sim_id) return club.show_club_gathering_dialog( sim_info, flavor_text=ClubTunables.CLUB_GATHERING_DIALOG_TEXT_REQUEST_INVITE, start_source=ClubGatheringStartSource.APPLY_FOR_INVITE)
def _test(cls, *args, sim_info=None, **kwargs): if sim_info.zone_id == services.current_zone_id(): return TestResult(False, 'Cannot bring a sim to a zone that is already the current zone.') if cls.check_region_compatibility: current_region = services.current_region() sim_region = region.get_region_instance_from_zone_id(sim_info.zone_id) if sim_region is None or not sim_region.is_region_compatible(current_region): return TestResult(False, 'Cannot bring a sim to an incompatible region.') return super()._test(*args, **kwargs)
def _setup_regional_seasonal_changes(self): region = services.current_region() if region is None: return for param_handler in self._regional_seasonal_parameters_handles.values( ): param_handler.trigger_hard_stop() self._regional_seasonal_parameters_handles.clear() for seasonal_parameter in region.seasonal_parameters.keys(): self._process_regional_season_change_update(seasonal_parameter)
def is_day_time(self, time=None): region_instance = services.current_region() if region_instance is None: return False else: if time is None: time = self.sim_now if time.time_between_day_times(region_instance.get_sunrise_time(), region_instance.get_sunset_time()): return True return False
def show_club_gathering_dialog( self, sim_info, *, flavor_text, start_source=ClubGatheringStartSource.DEFAULT, sender_sim_info=DEFAULT): zone_id = self.get_hangout_zone_id() if not zone_id: return False current_region = services.current_region() hangout_region = get_region_instance_from_zone_id(zone_id) if not current_region.is_region_compatible(hangout_region): return False venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_tuning = venue_manager.get(build_buy.get_current_venue(zone_id)) def on_response(dialog): if not dialog.accepted: return persistence_service = services.get_persistence_service() if persistence_service.is_save_locked(): return club_service = services.get_club_service() if club_service is None: return club_service.start_gathering(self, start_source=start_source, host_sim_id=sim_info.sim_id, invited_sims=(sim_info, ), zone_id=zone_id, spawn_sims_during_zone_spin_up=True) zone_data = services.get_persistence_service().get_zone_proto_buff( zone_id) lot_name = zone_data.name sender_sim_info = self.leader if sender_sim_info is DEFAULT else sender_sim_info flavor_text = flavor_text(sim_info, sender_sim_info, self) additional_tokens = (lot_name, venue_tuning.club_gathering_text(), flavor_text) self.show_club_notification(sim_info, ClubTunables.CLUB_GATHERING_DIALOG, target_sim_id=sender_sim_info.sim_id, additional_tokens=additional_tokens, on_response=on_response)
def _start_welcome_wagon(self, _): situation_manager = services.get_zone_situation_manager() if situation_manager.is_user_facing_situation_running(): self._schedule_welcome_wagon() return active_household = services.active_household() for sim_info in active_household.can_live_alone_info_gen(): if sim_info.is_instanced(): break else: self._schedule_welcome_wagon() return resolver = GlobalResolver() if not NPCHostedSituationService.WELCOME_WAGON_TUNING.welcome_wagon_start_tests.run_tests( resolver): active_household.needs_welcome_wagon = False return narrative_service = services.narrative_service() welcome_wagon_situation = narrative_service.get_possible_replacement_situation( NPCHostedSituationService.WELCOME_WAGON_TUNING.situation) if welcome_wagon_situation is NPCHostedSituationService.WELCOME_WAGON_TUNING.situation: region = services.current_region() if region.welcome_wagon_replacement is not None: welcome_wagon_situation = region.welcome_wagon_replacement guest_list = welcome_wagon_situation.get_predefined_guest_list() if guest_list is None: active_household.needs_welcome_wagon = False return game_clock_services = services.game_clock_service() if game_clock_services.clock_speed == ClockSpeedMode.SUPER_SPEED3: game_clock_services.set_clock_speed(ClockSpeedMode.NORMAL) situation_id = situation_manager.create_situation( welcome_wagon_situation, guest_list=guest_list, user_facing=False, scoring_enabled=False) if not (situation_id is None or not welcome_wagon_situation.sets_welcome_wagon_flag): active_household.needs_welcome_wagon = False
def _process_regional_season_change_update(self, seasonal_parameter): region = services.current_region() if region is None: return current_index = self._regional_seasonal_parameters_index.get( seasonal_parameter) start_time = services.time_service().sim_now if current_index is None: (current_value, next_frame, end_time, next_index) = self._get_regional_season_change_values( seasonal_parameter, start_time, region) else: changes = region.seasonal_parameters.get(seasonal_parameter) current_frame = changes[current_index] current_value = current_frame.value next_index = (current_index + 1) % len(changes) next_frame = changes[next_index] current_value = self._get_wrapped_value(seasonal_parameter, current_value, next_frame.value) for (season_type, season_instance) in self.get_seasons_gen(): if season_type == next_frame.season: next_season_to_use = season_instance break end_time = next_season_to_use.get_date_at_season_progress( next_frame.time_in_season) if end_time < start_time: end_time = start_time self._regional_seasonal_parameters_index[ seasonal_parameter] = next_index self._send_regional_season_change_update(seasonal_parameter, current_value, start_time, next_frame.value, end_time) self._regional_seasonal_parameters_handles[ seasonal_parameter] = self._season_timeline.schedule( build_element( (lambda _: self._process_regional_season_change_update( seasonal_parameter), )), end_time)
def travel_player(self): sim = self.sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS) travel_info = InteractionOps_pb2.TravelSimsToZone() travel_info.zone_id = self.to_zone_id travel_info.sim_ids.append(sim.id) self.interaction = None if self.is_attend_career: self._attend_career() travel_group = self.sim_info.travel_group if travel_group is not None and not any(sim_info is not self.sim_info and sim_info in self.sim_info.household for sim_info in travel_group): dest_region = region.get_region_instance_from_zone_id(self.to_zone_id) current_region = services.current_region() if not current_region.is_region_compatible(dest_region): services.travel_group_manager().destroy_travel_group_and_release_zone(travel_group, last_sim_info=self.sim_info) rabbit_hole_service = services.get_rabbit_hole_service() if rabbit_hole_service.is_in_rabbit_hole(sim.sim_id): rabbit_hole_service.set_ignore_travel_cancel_for_sim_id_in_rabbit_hole(sim.sim_id) sim.queue.cancel_all() for sim in self.additional_sims: sim.queue.cancel_all() travel_info.sim_ids.append(sim.sim_id) distributor.system.Distributor.instance().add_event(Consts_pb2.MSG_TRAVEL_SIMS_TO_ZONE, travel_info) services.game_clock_service().set_clock_speed(ClockSpeedMode.PAUSED)
def get_travel_group_ids_in_region(self, region_id=None): region_id = region_id or services.current_region().guid64 return (group.id for group in self.values() if region.get_region_instance_from_zone_id( group.zone_id).guid64 == region_id)
def situation_meets_starting_requirements(cls, **kwargs): if not cls.valid_regions.test_item(services.current_region()): return False if cls.starting_entitlement is None: return True return is_available_pack(cls.starting_entitlement)
def has_venue_location(cls): compatible_region = services.current_region() if cls.venue_region_must_be_compatible else None return services.current_zone().venue_service.has_zone_for_venue_type(cls.compatible_venues, compatible_region=compatible_region)
def set_season(self, season_type, source, interp_time=None): if self._season == season_type: return previous = self._season next_season = season_type if interp_time is None: self._season = season_type natural_progression = source == SeasonSetSource.PROGRESSION self._set_season_start_time( services.time_service().sim_now.start_of_week(), reset_region_params=not natural_progression) self.handle_season_content_updated( setup_regional_params=not natural_progression) self._handle_season_screen_slam(source) else: start_time = services.time_service().sim_now end_time = start_time + create_time_span(minutes=interp_time) new_season_start_time = services.time_service( ).sim_now.start_of_week() elapsed_time_into = start_time - self._season_content.start_time percent_into_start_season = float( elapsed_time_into.in_ticks()) / float( self._season_length_span.in_ticks()) elapsed_time_into = end_time - new_season_start_time percent_into_end_season = float( elapsed_time_into.in_ticks()) / float( self._season_length_span.in_ticks()) op = CrossSeasonInterpolationOp(previous, percent_into_start_season, start_time, next_season, percent_into_end_season, end_time) force_loop = op.is_over_half Distributor.instance().add_op_with_no_owner(op) if services.weather_service().adjust_weather_for_set_season( interp_time): start_time = start_time + create_time_span( minutes=interp_time / 2) param_to_start_value = {} region = services.current_region() if region is not None: for seasonal_parameter in region.seasonal_parameters.keys(): (start_value, _, _, _) = self._get_regional_season_change_values( seasonal_parameter, start_time, region) param_to_start_value[seasonal_parameter] = start_value self._season = season_type self._set_season_start_time(new_season_start_time) self.handle_season_content_updated(delay=True) self._handle_season_screen_slam(source) def _send_update(): sync_end_time = None for seasonal_parameter in SeasonParameters: if seasonal_parameter not in param_to_start_value: continue start_value = param_to_start_value[seasonal_parameter] new_end_time = end_time (end_value, _, _, _) = self._get_regional_season_change_values( seasonal_parameter, end_time, region) if seasonal_parameter == SeasonParameters.FOLIAGE_REDUCTION: (start_value, end_value, new_end_time ) = self._add_secondary_forward_wraparound_interp( seasonal_parameter, start_time, start_value, end_time, end_value, force_loop) if end_time != new_end_time: sync_end_time = new_end_time if seasonal_parameter == SeasonParameters.FOLIAGE_COLORSHIFT: if SeasonParameters.FOLIAGE_REDUCTION in param_to_start_value: (start_value, end_value, new_end_time ) = self._add_secondary_forward_wraparound_interp( seasonal_parameter, start_time, start_value, end_time, end_value, force_loop, sync_end_time=sync_end_time) if end_value != start_value: self._send_regional_season_change_update( seasonal_parameter, start_value, start_time, end_value, new_end_time) if self._season_change_handler is not None and not self._season_change_handler.is_active: self._season_change_handler.trigger_hard_stop() self._season_change_handler = self._season_timeline.schedule( build_element( (lambda _: self._handle_season_content_delayed( trigger_weather=True), )), end_time) self._season_change_handler = self._season_timeline.schedule( build_element((lambda _: _send_update(), )), start_time) self._schedule_season_aware_object_updates() services.get_event_manager().process_event( TestEvent.SeasonChangedNoSim, previous_season=previous, current_season=next_season) services.get_event_manager().process_events_for_household( TestEvent.SeasonChanged, services.active_household(), previous_season=previous, current_season=next_season)
def current_region(_connection=None): current_region = services.current_region() sims4.commands.output(f'Current Region: {current_region}', _connection)
def start_gathering_by_club_id(club_id: int, _connection=None): club_service = _get_club_service(_connection) if club_service is None: sims4.commands.automation_output('ClubGatheringStart; Status:Failed', _connection) return club = club_service.get_club_by_id(club_id) if club is None: sims4.commands.output('No Club exists with this ID.', _connection) sims4.commands.automation_output('ClubGatheringStart; Status:Failed', _connection) return persistence_service = services.get_persistence_service() venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) current_zone_id = services.current_zone_id() def _start_gathering(zone_id=None): start_gathering = functools.partial( club_service.start_gathering, club, invited_sims=(services.active_sim_info(), )) if zone_id is None: current_venue_tuning = venue_manager.get( build_buy.get_current_venue(current_zone_id)) if current_venue_tuning.is_residential or current_venue_tuning.is_university_housing: if not club.is_zone_valid_for_gathering(current_zone_id): club.show_club_notification( services.active_sim_info(), ClubTunables. CLUB_GATHERING_START_RESIDENTIAL_INVALID_DIALOG) return elif not club.is_zone_valid_for_gathering(current_zone_id): club.show_club_notification( services.active_sim_info(), ClubTunables.CLUB_GATHERING_START_INVALID_DIALOG) return start_gathering() else: start_gathering(zone_id=zone_id) zone_id = club.get_hangout_zone_id(prefer_current=True) if zone_id: current_region = services.current_region() hangout_region = get_region_instance_from_zone_id(zone_id) if not current_region.is_region_compatible(hangout_region): zone_id = 0 if not zone_id or zone_id == current_zone_id or persistence_service.is_save_locked( ): _start_gathering() else: def on_response(dialog): if dialog.closed: return if dialog.accepted: _start_gathering(zone_id=zone_id) else: _start_gathering() if club.hangout_setting == ClubHangoutSetting.HANGOUT_VENUE: venue_name = club.hangout_venue.display_name elif club.hangout_setting == ClubHangoutSetting.HANGOUT_LOT: zone_data = persistence_service.get_zone_proto_buff(zone_id) venue_name = zone_data.name if zone_data is not None else '' club.show_club_notification( services.active_sim_info(), ClubTunables.CLUB_GATHERING_START_SELECT_LOCATION_DIALOG, additional_tokens=(venue_name, ), on_response=on_response) sims4.commands.automation_output('ClubGatheringStart; Status:Success', _connection) return True
def is_venue_location_valid(cls, zone_id): compatible_region = services.current_region() if cls.venue_region_must_be_compatible else None return services.current_zone().venue_service.is_zone_valid_for_venue_type(zone_id, cls.compatible_venues, compatible_region=compatible_region)
def get_venue_location(cls): compatible_region = services.current_region() if cls.venue_region_must_be_compatible else None (zone_id, _) = services.current_zone().venue_service.get_zone_and_venue_type_for_venue_types(cls.compatible_venues, compatible_region=compatible_region) return zone_id
def get_filter_terms(self): region = services.current_region() if region in self.region_to_filter_terms: return self.region_to_filter_terms[region] return self.default_filter_terms