def get_possible_zone_ids_for_situation(cls, host_sim_info=None, guest_ids=None): possible_zones = [] venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) venue_service = services.current_zone().venue_service for venue_tuning in cls.compatible_venues: if venue_tuning.is_residential: if host_sim_info is not None: home_zone_id = host_sim_info.household.home_zone_id home_venue_tuning = venue_manager.get(build_buy.get_current_venue(home_zone_id)) if home_venue_tuning.is_residential: possible_zones.append(home_zone_id) if guest_ids is not None: for guest_id in guest_ids: guest_id = int(guest_id) guest_info = services.sim_info_manager().get(guest_id) if guest_info is not None: guest_zone_id = guest_info.household.home_zone_id if guest_zone_id is not None and guest_zone_id and guest_zone_id not in possible_zones: guest_venue_tuning = venue_manager.get(build_buy.get_current_venue(guest_zone_id)) if guest_venue_tuning.is_residential: possible_zones.append(guest_zone_id) travel_group = guest_info.travel_group if travel_group is not None: travel_group_zone_id = travel_group.zone_id if travel_group_zone_id is not None and travel_group_zone_id and travel_group_zone_id not in possible_zones: possible_zones.append(travel_group_zone_id) else: possible_zones.extend(venue_service.get_zones_for_venue_type_gen(venue_tuning)) else: possible_zones.extend(venue_service.get_zones_for_venue_type_gen(venue_tuning)) return possible_zones
def load(self, zone_data=None): persistence_service = services.get_persistence_service() def _get_current_venue(zone_id): neighborhood_data = persistence_service.get_neighborhood_proto_buf_from_zone_id( zone_id) for lot_data in neighborhood_data.lots: if zone_id == lot_data.zone_instance_id: return lot_data.venue_key current_zone_id = services.current_zone_id() zones = services.get_persistence_service().get_save_game_data_proto( ).zones for zone_data_msg in zones: if zone_data_msg is None: continue if zone_data_msg.zone_id == current_zone_id: active_venue_tuning_id = get_current_venue( zone_data_msg.zone_id) raw_active_venue_tuning_id = get_current_venue( zone_data_msg.zone_id, allow_ineligible=True) else: active_venue_tuning_id = _get_current_venue( zone_data_msg.zone_id) raw_active_venue_tuning_id = active_venue_tuning_id if active_venue_tuning_id is None: self.set_provider(zone_data_msg.zone_id, None) else: active_venue_type = services.venue_manager().get( active_venue_tuning_id) raw_active_venue_type = services.venue_manager().get( raw_active_venue_tuning_id) source_venue_type = VenueService.get_variable_venue_source_venue( raw_active_venue_type) if source_venue_type is None: self.set_provider(zone_data_msg.zone_id, None) elif source_venue_type.variable_venues is None: self.set_provider(zone_data_msg.zone_id, None) else: existing_provider = self.get_provider( zone_data_msg.zone_id) if existing_provider is not None and existing_provider.source_venue_type is source_venue_type: continue provider = source_venue_type.variable_venues.civic_policy( source_venue_type, active_venue_type) if not provider: self.set_provider(zone_data_msg.zone_id, None) else: self.set_provider(zone_data_msg.zone_id, provider) if zone_data_msg.HasField('gameplay_zone_data'): if zone_data_msg.gameplay_zone_data.HasField( 'venue_data'): if zone_data_msg.gameplay_zone_data.venue_data.HasField( 'civic_provider_data'): provider.load( zone_data_msg.gameplay_zone_data. venue_data.civic_provider_data)
def is_zone_valid_for_gathering(self, zone_id): persistence_service = services.get_persistence_service() household_manager = services.household_manager() try: venue_tuning_id = build_buy.get_current_venue(zone_id) except RuntimeError: return False venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_tuning = venue_manager.get(venue_tuning_id) if venue_tuning is None: return False if not venue_tuning.allowed_for_clubs: return False if venue_tuning.is_residential or venue_tuning.is_university_housing: zone_data = persistence_service.get_zone_proto_buff(zone_id) if zone_data is None: return False lot_data = persistence_service.get_lot_data_from_zone_data( zone_data) if lot_data is None: return False household = household_manager.get( lot_data.lot_owner[0].household_id ) if lot_data.lot_owner else None if household is None: return False elif not any(club_member in self.members for club_member in household): return False return True
def is_zone_valid_for_venue_type(self, zone_id, venue_types, compatible_region=None, ignore_region_compatability_tags=False, region_blacklist=[]): if not zone_id: return False venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_type = venue_manager.get(build_buy.get_current_venue(zone_id)) if venue_type not in venue_types: return False if compatible_region is not None: venue_region = get_region_instance_from_zone_id(zone_id) if venue_region is None or not compatible_region.is_region_compatible( venue_region, ignore_tags=ignore_region_compatability_tags): return False elif region_blacklist: venue_region_description_id = get_region_description_id_from_zone_id( zone_id) if venue_region_description_id in region_blacklist: return False elif region_blacklist: venue_region_description_id = get_region_description_id_from_zone_id( zone_id) if venue_region_description_id in region_blacklist: return False return True
def _run(self): zone_id = self._get_zone_id() with telemetry_helper.begin_hook(telemetry_writer, TELEMETRY_HOOK_SITUATION_INVITED, sim_info=self._receiver_sim_info) as hook: hook.write_guid(TELEMETRY_SITUATION_TYPE_ID, self._situation_to_run.guid64) hook.write_int(TELEMETRY_CHOSEN_ZONE, zone_id) additional_tokens = [] if zone_id == 0: logger.error('Drama Node {} trying to be run with zone id of 0. This is probably an issue with getting the zone id from the street.', self) zone_id = services.current_zone_id() venue_tuning_id = build_buy.get_current_venue(zone_id) if venue_tuning_id is not None: venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) venue_tuning = venue_manager.get(venue_tuning_id) if venue_tuning is not None: additional_tokens.append(venue_tuning.display_name) persistence_service = services.get_persistence_service() zone_data = persistence_service.get_zone_proto_buff(zone_id) if zone_data is not None: additional_tokens.append(zone_data.name) self._choose_dialog() dialog = self._chosen_dialog(self._receiver_sim_info, target_sim_id=self._sender_sim_info.id, resolver=self._get_resolver()) if self._chosen_dialog is None: return DramaNodeRunOutcome.FAILURE dialog_zone_id = zone_id if self._show_venue_dialog else None dialog.show_dialog(on_response=self._handle_dialog, zone_id=dialog_zone_id, additional_tokens=additional_tokens) return DramaNodeRunOutcome.SUCCESS_NODE_INCOMPLETE
def generate_lot_info_data(*args, zone_id: int = None, **kwargs): lot_infos = [] current_zone = services.current_zone() lot = current_zone.lot venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) for neighborhood_proto in services.get_persistence_service( ).get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id if zone_id is not None: venue_tuning_id = build_buy.get_current_venue(zone_id) venue_tuning = venue_manager.get(venue_tuning_id) if venue_tuning is not None: is_current_lot = lot_owner_info.zone_instance_id == lot.zone_id cur_info = { 'neighborhood': neighborhood_proto.name, 'region_id': neighborhood_proto.region_id, 'lot_desc_id': lot_owner_info.lot_description_id, 'zone_id': str(hex(zone_id)), 'venue': venue_tuning.__name__, 'lot_name': lot_owner_info.lot_name, 'cur_lot': 'X' if is_current_lot else '' } if is_current_lot: stat_entries = [] for stat in lot.get_all_stats_gen(): stat_entries.append({ 'statistic': stat.stat_type.__name__, 'value': stat.get_value() }) cur_info['statistics'] = stat_entries lot_infos.append(cur_info) return lot_infos
def get_valid_situation_locations(sim_id, situation_type, *guests, _connection=None): sim = get_optional_target(sim_id, _connection) if not sim: sims4.commands.output('Invalid Sim ID: {}'.format(sim_id), _connection) return sim_info = sim.sim_info possible_zones = [] possible_zones.append(sim_info.household.home_zone_id) for guest_id in guests: guest_id = int(guest_id) guest_info = services.sim_info_manager().get(guest_id) while guest_info is not None: guest_zone_id = guest_info.household.home_zone_id if guest_zone_id is not None and guest_zone_id and guest_zone_id not in possible_zones: possible_zones.append(guest_zone_id) venue_service = services.current_zone().venue_service for venue_type in situation_type.venue_types: possible_zones.extend(venue_service.get_zones_for_venue_type(venue_type)) venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) persistence_service = services.get_persistence_service() locations_msg = Situations_pb2.SituationLocations() cas_zones_msg = InteractionOps_pb2.CASAvailableZonesInfo() world_info_msg = cas_zones_msg.zones.add() for zone_id in possible_zones: zone_data = persistence_service.get_zone_proto_buff(zone_id) if zone_data is None: pass neighborhood_data = persistence_service.get_neighborhood_proto_buff(zone_data.neighborhood_id) if neighborhood_data is None: pass lot_data = None for lot_owner_data in neighborhood_data.lots: while zone_id == lot_owner_data.zone_instance_id: lot_data = lot_owner_data break while zone_data is not None and lot_data is not None: location_data = Dialog_pb2.LotInfoItem() location_data.zone_id = zone_data.zone_id location_data.name = zone_data.name location_data.world_id = zone_data.world_id location_data.lot_template_id = zone_data.lot_template_id location_data.lot_description_id = zone_data.lot_description_id venue_type_id = build_buy.get_current_venue(zone_id) venue_instance = venue_manager.get(venue_type_id) if venue_instance is not None: location_data.venue_type_name = venue_instance.display_name if lot_data.lot_owner: household_id = lot_data.lot_owner[0].household_id household = services.household_manager().get(household_id) if household is not None: location_data.household_name = household.name locations_msg.situation_locations.append(location_data) with ProtocolBufferRollback(world_info_msg.zones) as zone_info_msg: zone_info_msg.id = zone_data.zone_id zone_info_msg.name = zone_data.name zone_info_msg.world_id = zone_data.world_id zone_info_msg.lot_template_id = zone_data.lot_template_id zone_info_msg.lot_description_id = zone_data.lot_description_id shared_messages.add_object_message_for_sim_id(sim.id, Consts_pb2.MSG_NS_AVAILABLE_ZONES_INFO, cas_zones_msg) shared_messages.add_object_message_for_sim_id(sim.id, Consts_pb2.MSG_SITUATION_LOCATIONS, locations_msg)
def print_venues(_connection=None): current_zone = services.current_zone() lot = current_zone.lot neighborhood_id = current_zone.neighborhood_id lot_description_id = services.get_lot_description_id(lot.lot_id) world_description_id = services.get_world_description_id( current_zone.world_id) neighborhood_description_id = services.get_persistence_service( ).get_neighborhood_proto_buff(neighborhood_id).region_id def print_line(): sims4.commands.output('-' * 150, _connection) print_line() sims4.commands.output( 'Current Game Stats: \nLot: {}\nWorld/Street: {}\nRegion/Neighborhood: {}' .format(lot_description_id, world_description_id, neighborhood_description_id), _connection) print_line() venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) venues = [] for neighborhood_proto in services.get_persistence_service( ).get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id while zone_id is not None: venue_type_id = build_buy.get_current_venue(zone_id) venue_type = venue_manager.get(venue_type_id) if venue_type is not None: log = PrintVenueLog._make( (neighborhood_proto.name, neighborhood_proto.region_id, lot_owner_info.lot_description_id, zone_id, venue_type.__name__, lot_owner_info.lot_name)) venues.append(log) str_format = '{:20} ({:{center}15}) {:{center}20} {:15} ({:{center}20}) {:20}' def print_columns(): sims4.commands.output( str_format.format('Neighborhood_Name', 'Neighborhood_ID', 'Lot_Description_ID', 'Zone_Instance_ID', 'Venue_Tuning_Name', 'Lot_Name', center='^'), _connection) print_columns() print_line() for venue in sorted(venues): sims4.commands.output( str_format.format(venue.Neighborhood_Name, venue.Neighborhood_ID, venue.Lot_Description_ID, venue.Zone_Instance_ID, venue.Venue_Tuning_Name, venue.Lot_Name, center='^'), _connection) print_line() print_columns()
def on_client_connect(self, client): zone = services.current_zone() venue_type = get_current_venue(zone.id) logger.assert_raise(venue_type is not None, ' Venue Type is None in on_client_connect for zone:{}', zone, owner='sscholl') venue_tuning = self._get_venue_tuning(zone) if venue_tuning is not None: type_changed = self._set_venue(venue_tuning) if type_changed: self._create_automatic_objects(venue_tuning)
def get_current_venue_type() -> VenueTypes: """get_current_venue_type() Retrieve the type of the current venue. :return: The VenueType of the current lot. :rtype: VenueTypes """ return build_buy.get_current_venue(CommonLocationUtils.get_current_lot_id())
def _validate_venue_tuning(self): venue_tuning_id = build_buy.get_current_venue(self._zone_id) venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_tuning = venue_manager.get(venue_tuning_id) if venue_tuning is None: return False elif type(self) not in venue_tuning.drama_node_events: return False return True
def get_zones_for_venue_type(self, venue_type): possible_zones = [] venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id while zone_id is not None: venue_type_id = build_buy.get_current_venue(zone_id) if venue_manager.get(venue_type_id) is venue_type: possible_zones.append(lot_owner_info.zone_instance_id) return possible_zones
def on_client_connect(self, client): zone = services.current_zone() active_venue_key = get_current_venue(zone.id) logger.assert_raise(active_venue_key is not None, ' Venue Type is None for zone id:{}', zone.id, owner='shouse') raw_active_venue_key = get_current_venue(zone.id, allow_ineligible=True) logger.assert_raise(raw_active_venue_key is not None, ' Raw Venue Type is None for zone id:{}', zone.id, owner='shouse') if not active_venue_key is None and not raw_active_venue_key is None: active_venue_type = services.venue_manager().get(active_venue_key) raw_active_venue_type = services.venue_manager().get( raw_active_venue_key) source_venue_type = VenueService.get_variable_venue_source_venue( raw_active_venue_type) self._set_venue(active_venue_type, source_venue_type)
def is_valid_career_location(self): if self._zone_id: venue_manager = services.venue_manager() try: venue_tuning_id = get_current_venue(self._zone_id) except RuntimeError: return False venue_tuning = venue_manager.get(venue_tuning_id) if venue_tuning in self.venues: return True return False
def _collect_residential_zones(self): venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) residential_zone_ids = [] for zone_id in get_zone_ids_from_street(self._street): venue_key = build_buy.get_current_venue(zone_id, allow_ineligible=True) venue_tuning = venue_manager.get(venue_key) if StreetUtilityShutoffEffect._should_have_utility_shut_off( venue_tuning): residential_zone_ids.append(zone_id) return residential_zone_ids
def get_zones_for_venue_type(self, venue_type): possible_zones = [] venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) for neighborhood_proto in services.get_persistence_service( ).get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id while zone_id is not None: venue_type_id = build_buy.get_current_venue(zone_id) if venue_manager.get(venue_type_id) is venue_type: possible_zones.append(lot_owner_info.zone_instance_id) return possible_zones
def on_client_connect(self, client): zone = services.current_zone() venue_type = get_current_venue(zone.id) logger.assert_raise( venue_type is not None, ' Venue Type is None in on_client_connect for zone:{}', zone, owner='sscholl') venue_tuning = self._get_venue_tuning(zone) if venue_tuning is not None: type_changed = self._set_venue(venue_tuning) if type_changed: self._create_automatic_objects(venue_tuning)
def on_zone_load(self): current_zone_id = services.current_zone_id() self._setup_curfew_text_message() self._create_alarm_handles(current_zone_id) venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) 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: current_setting = self._zone_curfew_data.get( current_zone_id, CurfewService.UNSET) self._update_curfew_settings(current_zone_id, current_setting) else: self._update_curfew_settings(current_zone_id, CurfewService.UNSET)
def has_zone_for_venue_type(self, venue_types): venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id while zone_id is not None: venue_type_id = build_buy.get_current_venue(zone_id) venue_type = venue_manager.get(venue_type_id) if venue_type and venue_type in venue_types: return True instance_manager = services.get_instance_manager(sims4.resources.Types.MAXIS_LOT) for lot_instance in instance_manager.types.values(): while lot_instance.supports_any_venue_type(venue_types): return True return False
def __init__(self, zone_data, **kwargs): super().__init__(**kwargs) self.zone_id = zone_data.zone_id self.name = zone_data.name self.world_id = zone_data.world_id self.lot_template_id = zone_data.lot_template_id self.lot_description_id = zone_data.lot_description_id venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) venue_type_id = build_buy.get_current_venue(zone_data.zone_id) if venue_type_id is not None: venue_type = venue_manager.get(venue_type_id) if venue_type is not None: self.venue_type_name = venue_type.display_name householdProto = services.get_persistence_service().get_household_proto_buff(zone_data.household_id) self.household_name = householdProto.name if householdProto is not None else None
def _show_away_notification(self): if self.away_notification is None: return zone_data = services.get_persistence_service().get_zone_proto_buff( self._zone_id) if zone_data is None: return venue_tuning_id = build_buy.get_current_venue(self._zone_id) venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_tuning = venue_manager.get(venue_tuning_id) if venue_tuning is None: return dialog = self.away_notification(services.active_sim_info()) dialog.show_dialog(additional_tokens=(zone_data.name, venue_tuning.display_name))
def __init__(self, zone_data, **kwargs): super().__init__(**kwargs) self.zone_id = zone_data.zone_id self.name = zone_data.name self.world_id = zone_data.world_id self.lot_template_id = zone_data.lot_template_id self.lot_description_id = zone_data.lot_description_id venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_type_id = build_buy.get_current_venue(zone_data.zone_id) if venue_type_id is not None: venue_type = venue_manager.get(venue_type_id) if venue_type is not None: self.venue_type_name = venue_type.display_name householdProto = services.get_persistence_service( ).get_household_proto_buff(zone_data.household_id) self.household_name = householdProto.name if householdProto is not None else None
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 has_zone_for_venue_type(self, venue_types): venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) for neighborhood_proto in services.get_persistence_service( ).get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id while zone_id is not None: venue_type_id = build_buy.get_current_venue(zone_id) venue_type = venue_manager.get(venue_type_id) if venue_type and venue_type in venue_types: return True instance_manager = services.get_instance_manager( sims4.resources.Types.MAXIS_LOT) for lot_instance in instance_manager.types.values(): while lot_instance.supports_any_venue_type(venue_types): return True return False
def generate_lot_info_data(*args, zone_id:int=None, filter=None, **kwargs): lot_infos = [] current_zone = services.current_zone() lot = current_zone.lot neighborhood_id = current_zone.neighborhood_id lot_description_id = services.get_lot_description_id(lot.lot_id) world_description_id = services.get_world_description_id(current_zone.world_id) neighborhood_description_id = services.get_persistence_service().get_neighborhood_proto_buff(neighborhood_id).region_id venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id while zone_id is not None: venue_type_id = build_buy.get_current_venue(zone_id) venue_type = venue_manager.get(venue_type_id) if venue_type is not None: cur_info = {'neighborhood': neighborhood_proto.name, 'region_id': neighborhood_proto.region_id, 'lot_desc_id': lot_owner_info.lot_description_id, 'zone_id': zone_id, 'venue_type': venue_type.__name__, 'lot_name': lot_owner_info.lot_name, 'cur_lot': 'X' if lot_owner_info.zone_instance_id == lot.zone_id else ''} lot_infos.append(cur_info) return lot_infos
def build_msg(self, zone_id=None, **kwargs): msg = super().build_msg(**kwargs) if zone_id is None: return msg persistence_service = services.get_persistence_service() zone_data = persistence_service.get_zone_proto_buff(zone_id) if zone_data is None: return msg venue_tuning_id = build_buy.get_current_venue(zone_id) venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_tuning = venue_manager.get(venue_tuning_id) if venue_tuning is None: return msg msg.lot_title = self.zone_title(venue_tuning.display_name, zone_data.name) build_icon_info_msg( IconInfoData(icon_resource=venue_tuning.venue_icon), venue_tuning.display_name, msg.venue_icon) return msg
def get_possible_zone_ids_for_situation(cls, host_sim_info=None, guest_ids=None): possible_zones = [] venue_manager = services.get_instance_manager( sims4.resources.Types.VENUE) venue_service = services.current_zone().venue_service for venue_tuning in cls.compatible_venues: if venue_tuning.is_residential: if host_sim_info is not None: home_zone_id = host_sim_info.household.home_zone_id home_venue_tuning = venue_manager.get( build_buy.get_current_venue(home_zone_id)) if home_venue_tuning.is_residential: possible_zones.append(home_zone_id) possible_zones.extend( venue_service.get_zones_for_venue_type_gen( venue_tuning)) else: possible_zones.extend( venue_service.get_zones_for_venue_type_gen(venue_tuning)) return possible_zones
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)
def print_venues(_connection=None): current_zone = services.current_zone() lot = current_zone.lot neighborhood_id = current_zone.neighborhood_id lot_description_id = services.get_lot_description_id(lot.lot_id) world_description_id = services.get_world_description_id(current_zone.world_id) neighborhood_description_id = services.get_persistence_service().get_neighborhood_proto_buff(neighborhood_id).region_id def print_line(): sims4.commands.output('-'*150, _connection) print_line() sims4.commands.output('Current Game Stats: \nLot: {}\nWorld/Street: {}\nRegion/Neighborhood: {}'.format(lot_description_id, world_description_id, neighborhood_description_id), _connection) print_line() venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) venues = [] for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id while zone_id is not None: venue_type_id = build_buy.get_current_venue(zone_id) venue_type = venue_manager.get(venue_type_id) if venue_type is not None: log = PrintVenueLog._make((neighborhood_proto.name, neighborhood_proto.region_id, lot_owner_info.lot_description_id, zone_id, venue_type.__name__, lot_owner_info.lot_name)) venues.append(log) str_format = '{:20} ({:{center}15}) {:{center}20} {:15} ({:{center}20}) {:20}' def print_columns(): sims4.commands.output(str_format.format('Neighborhood_Name', 'Neighborhood_ID', 'Lot_Description_ID', 'Zone_Instance_ID', 'Venue_Tuning_Name', 'Lot_Name', center='^'), _connection) print_columns() print_line() for venue in sorted(venues): sims4.commands.output(str_format.format(venue.Neighborhood_Name, venue.Neighborhood_ID, venue.Lot_Description_ID, venue.Zone_Instance_ID, venue.Venue_Tuning_Name, venue.Lot_Name, center='^'), _connection) print_line() print_columns()
def _get_venue_tuning(self, zone): venue_tuning = None venue_type = get_current_venue(zone.id) if venue_type is not None: venue_tuning = services.venue_manager().get(venue_type) return venue_tuning
def get_current_venue_type() -> VenueTypes: """ Retrieve the type of the current venue. """ return build_buy.get_current_venue( CommonLocationUtils.get_current_lot_id())
def get_venue_tuning(self, zone_id): venue_tuning = None venue_type = get_current_venue(zone_id) if venue_type is not None: venue_tuning = services.venue_manager().get(venue_type) return venue_tuning
def _get_token(self, resolver, token_data): if token_data.token_type == self.TOKEN_PARTICIPANT: participants = token_data.objects.get_objects(resolver) return token_data.formatter(participants) if token_data.token_type == self.TOKEN_PARTICIPANT_COUNT: participants = token_data.objects.get_objects(resolver) if not participants: return 0 return len(participants) if token_data.token_type == self.TOKEN_DEFINITION: return token_data.definition elif token_data.token_type == self.TOKEN_MONEY: interaction = getattr(resolver, 'interaction', None) if interaction is not None: from interactions.money_payout import MoneyLiability money_liability = interaction.get_liability( MoneyLiability.LIABILITY_TOKEN) if money_liability is not None: return money_liability.amounts[token_data.participant] return 0 return 0 if token_data.token_type == self.TOKEN_BUCK: participant = resolver.get_participant( participant_type=token_data.participant) tracker = BucksUtils.get_tracker_for_bucks_type( token_data.bucks_type, owner_id=participant.id) if not tracker: return 0 return tracker.get_bucks_amount_for_type(token_data.bucks_type) if token_data.token_type == self.TOKEN_STATISTIC: participant = resolver.get_participant( participant_type=token_data.participant) if participant is not None: tracker = participant.get_tracker(token_data.statistic) if tracker is not None: return tracker.get_value(token_data.statistic) if token_data.token_type == self.TOKEN_OBJECT_PROPERTY: participant = resolver.get_participant(ParticipantType.Object) if participant is None: return return participant.get_object_property(token_data.obj_property) if token_data.token_type == self.TOKEN_INTERACTION_COST: interaction = getattr(resolver, 'interaction', None) if interaction is not None: return interaction.get_simoleon_cost() affordance = getattr(resolver, 'affordance', None) if affordance is not None: return affordance.get_simoleon_cost(target=resolver.target, context=resolver.context) if token_data.token_type == self.TOKEN_INTERACTION_PAYOUT: interaction = getattr(resolver, 'interaction', None) if interaction is not None: return interaction.get_simoleon_payout() affordance = getattr(resolver, 'affordance', None) if affordance is not None: return affordance.get_simoleon_payout(target=resolver.target, context=resolver.context) if token_data.token_type == self.TOKEN_ASSOCIATED_CLUB: if resolver.interaction is not None: club = getattr(resolver.interaction, 'associated_club') else: club = resolver.interaction_parameters.get('associated_club') if club is not None: return club.name if token_data.token_type == self.TOKEN_CAREER_DATA: participant = resolver.get_participant( participant_type=token_data.participant) if participant is not None: if participant.career_tracker is None: return career = participant.career_tracker.get_career_by_uid( token_data.career_type.guid64) if career is not None: if token_data.career_data == self.TOKEN_CAREER_DATA_CURRENT_LEVEL_NAME: current_level = career.current_level_tuning return current_level.get_title(participant) if token_data.career_data == self.TOKEN_CAREER_DATA_CURRENT_LEVEL_SALARY: current_level = career.current_level_tuning return current_level.simoleons_per_hour if token_data.career_data == self.TOKEN_CAREER_DATA_NEXT_LEVEL_NAME: next_level = career.next_level_tuning if next_level is not None: return next_level.get_title(participant) elif token_data.career_data == self.TOKEN_CAREER_DATA_NEXT_LEVEL_SALARY: next_level = career.next_level_tuning if next_level is not None: return next_level.simoleons_per_hour elif token_data.career_data == self.TOKEN_CAREER_DATA_PREVIOUS_LEVEL_NAME: previous_level = career.previous_level_tuning if previous_level is not None: return previous_level.get_title(participant) elif token_data.career_data == self.TOKEN_CAREER_DATA_PREVIOUS_LEVEL_SALARY: previous_level = career.previous_level_tuning if previous_level is not None: return previous_level.simoleons_per_hour if token_data.token_type == self.TOKEN_GAME_COMPONENT: participant = resolver.get_participant( participant_type=token_data.participant) if participant is not None: game = participant.game_component if game is None: return if token_data.game_component_data == self.TOKEN_GAME_COMPONENT_DATA_HIGH_SCORE and game.high_score is not None: return game.high_score if token_data.game_component_data == self.TOKEN_GAME_COMPONENT_DATA_HIGH_SCORE_SIM and game.high_score_sim_ids: high_score_sim_id = game.high_score_sim_ids[0] return services.sim_info_manager().get(high_score_sim_id) if token_data.token_type == self.TOKEN_SCHOLARSHIP_LETTER: participant = resolver.get_participant( participant_type=token_data.participant) if participant is not None: scholarship_letter_component = participant.scholarship_letter_component if scholarship_letter_component is None: return if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_APPLICANT_NAME: return scholarship_letter_component.get_applicant_name() if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_DATA_AMOUNT: return scholarship_letter_component.get_scholarship_amount( ) if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_DATA_NAME: return scholarship_letter_component.get_scholarship_name() if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_DATA_DESCRIPTION: return scholarship_letter_component.get_scholarship_description( ) if token_data.token_type == self.TOKEN_SICKNESS: participant = resolver.get_participant( participant_type=token_data.participant) if participant is None or not participant.is_sim: return current_sickness = participant.current_sickness if current_sickness is None: return return current_sickness.display_name(participant) if token_data.token_type == self.TOKEN_GLOBAL_POLICY: global_policy = services.global_policy_service().get_global_policy( token_data.global_policy, create=False) if global_policy is None: return token_data.global_policy.get_non_active_display( token_data) return global_policy.get_active_policy_display(token_data) if token_data.token_type == self.TOKEN_HOLIDAY: active_household = services.active_household() if active_household.holiday_tracker is None: return holiday_id = active_household.holiday_tracker.get_active_or_upcoming_holiday( ) if holiday_id is None: return return services.holiday_service().get_holiday_display_name( holiday_id) if token_data.token_type == self.TOKEN_CURRENT_TRENDS: trend_service = services.trend_service() if trend_service is None: return return trend_service.get_current_trends_loc_string() if token_data.token_type == self.TOKEN_LIFESTYLE_BRAND: participant = resolver.get_participant( participant_type=token_data.participant) lifestyle_brand_tracker = participant.lifestyle_brand_tracker if lifestyle_brand_tracker is None: return return lifestyle_brand_tracker.brand_name if token_data.token_type == self.TOKEN_PICKED_PART: participant = resolver.get_participant(ParticipantType.Object) if participant is None: return context = getattr(resolver, 'context', None) if context is not None and context.pick is not None: target_objects = participant.get_closest_parts_to_position( context.pick.location, has_name=True) if target_objects: part = target_objects.pop() return part.part_name if token_data.token_type == self.TOKEN_CIVIC_POLICY: if token_data.civic_policy_data == self.TOKEN_CIVIC_POLICY_VOTING_START_TIME: return services.street_service().voting_open_time if token_data.civic_policy_data == self.TOKEN_CIVIC_POLICY_VOTING_END_TIME: return services.street_service().voting_close_time if token_data.token_type == self.TOKEN_STREET: if token_data.street_data == self.TOKEN_STREET_POLICY_NAME_UP_FOR_REPEAL: provider = token_data.street.get_street_provider() if provider is not None: policies = provider.get_up_for_repeal_policies() if policies: return list(policies)[0].display_name() if token_data.street_data == self.TOKEN_STREET_POLICY_NAME_BALLOTED_RANDOM_LOSING: provider = token_data.street.get_street_provider() if provider is None: return policies = list(provider.get_balloted_policies()) if policies and len(policies) > 1: winning_policy = max( policies, key=lambda policy: provider.get_stat_value( policy.vote_count_statistic)) policies.remove(winning_policy) random_losing_policy = random.choice(policies) return random_losing_policy.display_name() if token_data.street_data == self.TOKEN_STREET_POLICY_NAME_BALLOTED_WINNING: provider = token_data.street.get_street_provider() if provider is None: return policies = list(provider.get_balloted_policies()) if policies: winning_policy = max( policies, key=lambda policy: provider.get_stat_value( policy.vote_count_statistic)) return winning_policy.display_name() if token_data.token_type == self.TOKEN_VENUE: if token_data.venue_data == self.TOKEN_VENUE_ACTIVE_VENUE_NAME: raw_active_venue_tuning_id = build_buy.get_current_venue( services.current_zone_id(), allow_ineligible=True) raw_active_venue_tuning = services.venue_manager().get( raw_active_venue_tuning_id) if raw_active_venue_tuning is None: return source_venue_tuning = type( services.venue_service().source_venue) if source_venue_tuning is raw_active_venue_tuning and source_venue_tuning.variable_venues is not None: return raw_active_venue_tuning.variable_venues.variable_venue_display_name( ) return raw_active_venue_tuning.display_name elif token_data.venue_data == self.TOKEN_VENUE_SOURCE_VENUE_NAME: source_venue_tuning = type( services.venue_service().source_venue) if source_venue_tuning is not None: return source_venue_tuning.display_name
def enroll(major: TunableInstanceParam(sims4.resources.Types.UNIVERSITY_MAJOR), university: TunableInstanceParam(sims4.resources.Types.UNIVERSITY), opt_sim: OptionalSimInfoParam = None, classes: int = 3, elective: TunableInstanceParam( sims4.resources.Types.UNIVERSITY_COURSE_DATA) = None, tuition_cost: int = 0, total_scholarship_taken: int = 0, is_using_loan: bool = False, destination_zone_id: int = None, _connection=None): sim_info = get_optional_target(opt_sim, target_type=OptionalSimInfoParam, _connection=_connection) if sim_info is None: sims4.commands.output('No valid target for university.enroll', _connection) return False degree_tracker = sim_info.degree_tracker if degree_tracker is None: sims4.commands.output( 'Sim: {} has no degree tracker in university.enroll'.format( sim_info), _connection) return False electives = () if elective is None else (elective, ) degree_tracker.enroll(major, university, classes, courses=electives) if is_using_loan: LoanTunables.add_debt( sim_info, LoanTunables.get_loan_amount(tuition_cost, LoanType.UNIVERSITY)) else: sim_info.household.funds.try_remove(tuition_cost, Consts_pb2.FUNDS_TUITION_COST, sim_info) UniversityTelemetry.send_university_tuition_telemetry( sim_info, tuition_cost, is_using_loan) degree_tracker.handle_scholarships_after_enrollment( total_scholarship_taken) UniversityTelemetry.send_university_housing_telemetry(destination_zone_id) if destination_zone_id is None: return True home_zone_id = sim_info.household.home_zone_id if home_zone_id == destination_zone_id: degree_tracker.on_enroll_in_same_housing() return True venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) venue = venue_manager.get(build_buy.get_current_venue(home_zone_id)) if venue.is_university_housing: sim_info.degree_tracker.set_kickout_info( destination_zone_id, UniversityHousingKickOutReason.MOVED) return True target_household_id = 0 if destination_zone_id != 0: account = services.client_manager().get(_connection).account target_household_id = get_target_household_id_for_zone( destination_zone_id, account) household_split(sourceHouseholdId=sim_info.household.id, targetHouseholdId=target_household_id, cancelable=False, allow_sim_transfer=False, selected_sim_ids=[sim_info.sim_id], destination_zone_id=destination_zone_id) return True
def get_current_venue_type(): return build_buy.get_current_venue( TurboWorldUtil.Zone.get_current_zone_id())
def get_valid_situation_locations(sim_id, situation_type, *guests, _connection=None): sim = get_optional_target(sim_id, _connection) if not sim: sims4.commands.output('Invalid Sim ID: {}'.format(sim_id), _connection) return sim_info = sim.sim_info possible_zones = [] possible_zones.append(sim_info.household.home_zone_id) for guest_id in guests: guest_id = int(guest_id) guest_info = services.sim_info_manager().get(guest_id) while guest_info is not None: guest_zone_id = guest_info.household.home_zone_id if guest_zone_id is not None and guest_zone_id and guest_zone_id not in possible_zones: possible_zones.append(guest_zone_id) venue_service = services.current_zone().venue_service for venue_type in situation_type.venue_types: possible_zones.extend( venue_service.get_zones_for_venue_type(venue_type)) venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) persistence_service = services.get_persistence_service() locations_msg = Situations_pb2.SituationLocations() cas_zones_msg = InteractionOps_pb2.CASAvailableZonesInfo() world_info_msg = cas_zones_msg.zones.add() for zone_id in possible_zones: zone_data = persistence_service.get_zone_proto_buff(zone_id) if zone_data is None: pass neighborhood_data = persistence_service.get_neighborhood_proto_buff( zone_data.neighborhood_id) if neighborhood_data is None: pass lot_data = None for lot_owner_data in neighborhood_data.lots: while zone_id == lot_owner_data.zone_instance_id: lot_data = lot_owner_data break while zone_data is not None and lot_data is not None: location_data = Dialog_pb2.LotInfoItem() location_data.zone_id = zone_data.zone_id location_data.name = zone_data.name location_data.world_id = zone_data.world_id location_data.lot_template_id = zone_data.lot_template_id location_data.lot_description_id = zone_data.lot_description_id venue_type_id = build_buy.get_current_venue(zone_id) venue_instance = venue_manager.get(venue_type_id) if venue_instance is not None: location_data.venue_type_name = venue_instance.display_name if lot_data.lot_owner: household_id = lot_data.lot_owner[0].household_id household = services.household_manager().get(household_id) if household is not None: location_data.household_name = household.name locations_msg.situation_locations.append(location_data) with ProtocolBufferRollback(world_info_msg.zones) as zone_info_msg: zone_info_msg.id = zone_data.zone_id zone_info_msg.name = zone_data.name zone_info_msg.world_id = zone_data.world_id zone_info_msg.lot_template_id = zone_data.lot_template_id zone_info_msg.lot_description_id = zone_data.lot_description_id shared_messages.add_object_message_for_sim_id( sim.id, Consts_pb2.MSG_NS_AVAILABLE_ZONES_INFO, cas_zones_msg) shared_messages.add_object_message_for_sim_id( sim.id, Consts_pb2.MSG_SITUATION_LOCATIONS, locations_msg)
def _score_and_schedule_drama_nodes_gen(self, timeline, from_zone_spin_up=False): active_household = services.active_household() if active_household is None: return current_time = services.time_service().sim_now current_day = current_time.day() venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE) for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen(): for lot_owner_info in neighborhood_proto.lots: zone_id = lot_owner_info.zone_instance_id if not zone_id: continue venue_tuning = venue_manager.get(build_buy.get_current_venue(zone_id)) if venue_tuning is None: continue if not venue_tuning.drama_node_events: continue if is_scoring_archive_enabled(): gsi_data = GSIDramaScoringData() gsi_data.bucket = 'Venue' else: gsi_data = None yield from self.score_and_schedule_nodes_gen(venue_tuning.drama_node_events, venue_tuning.drama_node_events_to_schedule, timeline=timeline, gsi_data=gsi_data, zone_id=zone_id) if gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) if timeline is not None: yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0))) bucketted_nodes = defaultdict(list) drama_node_manager = services.get_instance_manager(sims4.resources.Types.DRAMA_NODE) for drama_node in drama_node_manager.types.values(): if drama_node.scoring is None: continue bucketted_nodes[drama_node.scoring.bucket].append(drama_node) buckets_to_score = [] if from_zone_spin_up or not self._check_day(current_day, self.VENUE_BUCKET_DAYS) or from_zone_spin_up: buckets = self.STARTUP_BUCKETS - self._startup_buckets_used if current_time < create_date_and_time(days=int(current_time.absolute_days()), hours=self.SCORING_TIME): day_modifier = -1 else: day_modifier = 0 for bucket in buckets: if not bucketted_nodes[bucket]: continue self._startup_buckets_used.add(bucket) rules = self.BUCKET_SCORING_RULES[bucket] smallest_day_modification = None for (day, day_enabled) in rules.days.items(): if not day_enabled: continue potential_modification = current_day + day_modifier - day potential_modification += DAYS_PER_WEEK if not potential_modification < 0 or smallest_day_modification is None or potential_modification < smallest_day_modification: smallest_day_modification = potential_modification if smallest_day_modification is None: time_modification = TimeSpan.ZERO else: time_modification = TimeSpan(current_time.absolute_ticks()) - create_time_span(days=int(current_time.absolute_days()) - smallest_day_modification + day_modifier, hours=self.SCORING_TIME) buckets_to_score.append((bucket, rules, time_modification)) else: for (bucket_type, rules) in self.BUCKET_SCORING_RULES.items(): valid_day = self._check_day(current_day, rules.days) for drama_node in self._scheduled_nodes.values(): if drama_node.scoring is None: continue if drama_node.scoring.bucket == bucket_type: break else: valid_day = True if valid_day or not rules.score_if_no_nodes_are_scheduled or valid_day: buckets_to_score.append((bucket_type, rules, TimeSpan.ZERO)) for (bucket_type, rules, time_modifier) in buckets_to_score: if is_scoring_archive_enabled(): gsi_data = GSIDramaScoringData() gsi_data.bucket = bucket_type else: gsi_data = None if rules.number_to_schedule.option == NodeSelectionOption.BASED_ON_HOUSEHOLD: nodes_to_schedule = 1 + math.floor(len(active_household)/2) elif rules.number_to_schedule.option == NodeSelectionOption.STATIC_AMOUNT: nodes_to_schedule = rules.number_to_schedule.number_of_nodes else: logger.error('Trying to determine how many nodes to run with invalid option {}', rules.number_to_schedule.option) if gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) if nodes_to_schedule == 0: if gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) for node in list(self._scheduled_nodes.values()): if not not node.scoring is not None and node.scoring.bucket == bucket_type: self.cancel_scheduled_node(node.uid) yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data) if not rules.refresh_nodes_on_scheduling or gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) if timeline is not None: yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0))) else: gsi_data.nodes_to_schedule = nodes_to_schedule for node in list(self._scheduled_nodes.values()): if not not node.scoring is not None and node.scoring.bucket == bucket_type: self.cancel_scheduled_node(node.uid) yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data) if not rules.refresh_nodes_on_scheduling or gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) if timeline is not None: yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0))) if nodes_to_schedule == 0: if gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) for node in list(self._scheduled_nodes.values()): if not not node.scoring is not None and node.scoring.bucket == bucket_type: self.cancel_scheduled_node(node.uid) yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data) if not rules.refresh_nodes_on_scheduling or gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) if timeline is not None: yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0))) else: gsi_data.nodes_to_schedule = nodes_to_schedule for node in list(self._scheduled_nodes.values()): if not not node.scoring is not None and node.scoring.bucket == bucket_type: self.cancel_scheduled_node(node.uid) yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data) if not rules.refresh_nodes_on_scheduling or gsi_data is not None: archive_drama_scheduler_scoring(gsi_data) if timeline is not None: yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0)))