def start_situation(self):
services.get_persistence_service().lock_save(self)
super().start_situation()
self._change_state(_WaitForRepoPersonState())
if self.auto_clear_debt_event is not None:
services.get_event_manager().register_single_event(
self, self.auto_clear_debt_event)
def _destroy(self):
super()._destroy()
self.clear_current_object()
services.get_persistence_service().unlock_save(self)
if self.auto_clear_debt_event is not None:
services.get_event_manager().unregister_single_event(
self, self.auto_clear_debt_event)
def start_situation(self):
end_situation = True
if self._kick_out_reason in self.start_dialog_map:
sim_info = services.sim_info_manager().get(self._host_sim_id)
map_entry = self.start_dialog_map[self._kick_out_reason]
if sim_info is not None:
if map_entry is not None:
resolver = SingleSimResolver(sim_info)
dialog = map_entry(None, resolver)
dialog.show_dialog()
end_situation = False
if self._kick_out_reason == UniversityHousingKickOutReason.BABY and not self._additional_sim_ids:
logger.error(
'Attempting to kick sim out of university housing for {} without a valid parent',
self._kick_out_reason,
owner='bnguyen')
if end_situation:
self._self_destruct()
services.get_persistence_service().lock_save(self)
super().start_situation()
self._change_state(self.preparation_state())
services.get_event_manager().register(
self, (TestEvent.HouseholdSplitPanelClosed, ))
services.get_event_manager().register(
self, (TestEvent.SimEnrolledInUniversity, ))
def start_situation(self):
services.get_persistence_service().lock_save(self)
super().start_situation()
self._change_state(PrepareForBattleSituationState())
motherplant = self._get_motherplant()
motherplant.set_stat_value(self.player_health_statistic, 0, add=True)
motherplant.set_stat_value(self.motherplant_health_statisic,
self.motherplant_health_statisic.max_value,
add=True)
for state_value in self.states_to_set_on_start:
motherplant.set_state(state_value.state, state_value)
statistic_tracker = motherplant.statistic_tracker
self._statistic_watcher_handle = statistic_tracker.add_watcher(
self._on_statistic_updated)
self._setup_situation_meters()
self._zombie_attack_alarm_handle = alarms.add_alarm(
self,
create_time_span(minutes=self.zombie_fight_interaction_timer),
self._zombie_attack,
repeating=True)
for custom_key in itertools.chain(
self.victory_interaction_of_interest.custom_keys_gen(),
self.retreat_interaction_of_interest.custom_keys_gen()):
custom_key_tuple = (TestEvent.InteractionComplete, custom_key)
self._registered_test_events.add(custom_key_tuple)
services.get_event_manager().register_with_custom_key(
self, TestEvent.InteractionComplete, custom_key)
def _spawn_fire(self, transform, routing_surface, run_placement_tests=True):
if not fire_enabled:
logger.info('Trying to spawn fire when fire is disabled. Please use |fire.toggle_enabled cheat to turn fire on.')
return
if not services.active_lot().is_position_on_lot(transform.translation):
logger.info('Trying to spawn fire on a lot other than the active lot.')
return
if not services.venue_service().venue.allows_fire:
logger.info("Trying to spawn a fire on a venue that doesn't allow fire.")
return
if not (run_placement_tests and self._placement_tests(transform.translation, routing_surface.secondary_id)):
logger.info('Trying to spawn a fire on a lot at a position that is not valid.')
return
fire_object = system.create_object(self.FIRE_OBJECT_DEF)
fire_object.move_to(transform=transform, routing_surface=routing_surface)
first_fire_on_lot = False if self._fire_objects else True
self._fire_objects.add(fire_object)
fire_object.add_state_changed_callback(self._fire_object_state_changed_callback)
self.start_objects_burning(fire_object)
self.add_scorch_mark(fire_object.position, fire_object.location.level)
self._derail_routing_sims_if_necessary(fire_object)
if first_fire_on_lot:
self._start_fire_situations()
self.activate_fire_alarms()
self.activate_sprinkler_system()
self._show_fire_notification()
self._create_or_replace_scorch_cleanup_alarm()
services.get_persistence_service().lock_save(self)
self.register_for_sim_active_lot_status_changed_callback()
if self._fire_spread_alarm is None:
time_span = date_and_time.create_time_span(minutes=self.FIRE_SPREAD_INTIAL_TIME_IN_SIM_MINUTES)
repeating_time_span = date_and_time.create_time_span(minutes=self.FIRE_SPREAD_REPEATING_TIME_IN_SIM_MINUTES)
self._fire_spread_alarm = alarms.add_alarm(self, time_span, self._fire_spread_alarm_callback, repeating=True, repeating_time_span=repeating_time_span)
def _destroy(self):
for sim in services.active_household().instanced_sims_gen():
for si in sim.si_state:
if self.sleep_category_tag in si.affordance.interaction_category_tags:
si.remove_liability(UNCANCELABLE_LIABILITY)
super()._destroy()
services.get_persistence_service().unlock_save(self)
def destroy_travel_group_and_release_zone(self,
travel_group,
last_sim_info=None,
return_objects=False):
if travel_group.played:
if last_sim_info is None:
leader_sim_info = services.active_sim_info()
if leader_sim_info not in travel_group:
leader_sim_info = next(iter(travel_group), None)
else:
leader_sim_info = last_sim_info
with telemetry_helper.begin_hook(travel_group_telemetry_writer,
TELEMETRY_HOOK_TRAVEL_GROUP_END,
sim_info=leader_sim_info) as hook:
hook.write_int(TELEMETRY_TRAVEL_GROUP_ID, travel_group.id)
hook.write_int(TELEMETRY_TRAVEL_GROUP_ZONE_ID,
travel_group.zone_id)
hook.write_int(TELEMETRY_TRAVEL_GROUP_SIZE, len(travel_group))
hook.write_int(
TELEMETRY_TRAVEL_GROUP_DURATION,
int(travel_group.duration_time_span.in_minutes()))
for sim_info in tuple(travel_group):
travel_group.remove_sim_info(sim_info, destroy_on_empty=False)
self.release_zone(travel_group.zone_id)
services.get_persistence_service().del_travel_group_proto_buff(
travel_group.id)
services.travel_group_manager().remove(travel_group)
if return_objects:
self.return_objects_left_in_destination_world()
return True
def force_neighbors_home(_connection=None):
client = services.client_manager().get_first_client()
active_household = client.household
if active_household is not None:
active_household_home_zone_id = active_household.home_zone_id
active_household_home_world_id = services.get_persistence_service(
).get_world_id_from_zone(active_household_home_zone_id)
send_home = active_household_home_zone_id == services.current_zone().id
blacklist_all_jobs_time = services.time_service(
).sim_now + date_and_time.create_time_span(days=7)
for sim_info in services.sim_info_manager().values():
if sim_info.is_selectable:
continue
sim_info_home_zone_id = sim_info.household.home_zone_id
sim_info_home_world_id = services.get_persistence_service(
).get_world_id_from_zone(sim_info_home_zone_id)
if sim_info_home_world_id == active_household_home_world_id:
services.get_zone_situation_manager(
).add_sim_to_auto_fill_blacklist(
sim_info.id,
None,
blacklist_all_jobs_time=blacklist_all_jobs_time)
if send_home:
if sim_info.zone_id != active_household_home_zone_id:
if sim_info.zone_id != sim_info_home_zone_id:
sim_info.inject_into_inactive_zone(
sim_info_home_zone_id)
def prune_distant_relatives(self):
with genealogy_caching():
open_list = []
closed_list = set()
prune_list = set()
active_household_id = services.active_household_id()
for sim_info in self:
while not sim_info.is_dead:
heapq.heappush(open_list,
(-self.ANCESTRY_PURGE_DEPTH, sim_info.id))
def visit(sim_info, depth):
if sim_info not in closed_list:
closed_list.add(sim_info)
heapq.heappush(open_list, (depth, sim_info.id))
if depth > 0:
if sim_info.household_id != active_household_id and not sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
prune_list.add(sim_info)
sim_info_manager = services.sim_info_manager()
while open_list:
(depth, sim_info_id) = heapq.heappop(open_list)
sim_info = sim_info_manager.get(sim_info_id)
while sim_info is not None:
while True:
for relative_id in sim_info.genealogy.get_immediate_family_sim_ids_gen(
):
relative = sim_info_manager.get(relative_id)
while relative is not None:
visit(relative, depth + 1)
for sim_info in prune_list:
sim_info.household.remove_sim_info(sim_info)
sim_info_manager.remove_permanently(sim_info)
services.get_persistence_service().del_sim_proto_buff(sim_info.id)
def _load_household(self, household_id):
household = self.get(household_id)
if household is not None:
for sim_info in household.sim_info_gen():
while sim_info.zone_id != sims4.zone_utils.get_zone_id(False):
householdProto = services.get_persistence_service().get_household_proto_buff(household_id)
if householdProto is None:
logger.error('unable to find household with household id {}'.household_id)
return
found_sim = False
if householdProto.sims.ids:
for sim_id in householdProto.sims.ids:
while sim_id == sim_info.sim_id:
found_sim = True
break
if found_sim:
sim_proto = services.get_persistence_service().get_sim_proto_buff(sim_id)
sim_info.load_sim_info(sim_proto)
return household
logger.info('Starting to load household id = {0}', household_id)
household_proto = services.get_persistence_service().get_household_proto_buff(household_id)
if household_proto is None:
sims4.log.error('Persistence', 'Household proto could not be found id = {0}', household_id)
return
household = self._load_household_from_household_proto(household_proto)
return household
def add_neighbor_bit_if_necessary(self, sim_info):
target_sim_info = self.find_target_sim_info()
if target_sim_info is None:
return
if sim_info.household is None or target_sim_info.household is None:
return
home_zone_id = sim_info.household.home_zone_id
target_home_zone_id = target_sim_info.household.home_zone_id
if home_zone_id == target_home_zone_id:
return
if home_zone_id == 0 or target_home_zone_id == 0:
return
sim_home_zone_proto_buffer = services.get_persistence_service(
).get_zone_proto_buff(home_zone_id)
target_sim_home_zone_proto_buffer = services.get_persistence_service(
).get_zone_proto_buff(target_home_zone_id)
if sim_home_zone_proto_buffer is None or target_sim_home_zone_proto_buffer is None:
logger.error(
'Invalid zone protocol buffer in Relationship.add_neighbor_bit_if_necessary()'
)
return
if sim_home_zone_proto_buffer.world_id != target_sim_home_zone_proto_buffer.world_id:
return
self.add_bit(global_relationship_tuning.RelationshipGlobalTuning.
NEIGHBOR_RELATIONSHIP_BIT,
notify_client=False)
target_relationship = self._tracker._find_relationship(sim_info.id,
create=False)
if target_relationship is not None:
target_relationship.add_bit(
global_relationship_tuning.RelationshipGlobalTuning.
NEIGHBOR_RELATIONSHIP_BIT,
notify_client=False)
def pre_destroy(self):
if not services.get_persistence_service(
).is_save_locked_exclusively_by_holder(self):
self._self_destruct()
return
services.get_persistence_service().unlock_save(self)
sim_info = services.sim_info_manager().get(self._host_sim_id)
if sim_info is not None:
sim_info.degree_tracker.clear_kickout_info()
household = sim_info.household if sim_info is not None else None
if household is None:
self._self_destruct()
return
active_household = services.active_household()
if active_household is None or sim_info not in active_household:
self._self_destruct()
return
self_destruct = True
destination_zone_occupied = is_zone_occupied(
self._university_housing_destination_zone_id)
if len(household) > 1 or destination_zone_occupied:
self._show_household_split_dialog(household.id)
self_destruct = False
else:
self._kickout_single_sim()
services.venue_service().set_university_housing_kick_out_completed()
if self_destruct:
self._self_destruct()
def get_main_career_event_zone_id_and_unlock_save(self):
if self._save_lock is not None:
services.get_persistence_service().unlock_save(self._save_lock)
self._save_lock = None
zone_id = self._main_career_event_zone_id
self._main_career_event_zone_id = None
return zone_id
def _load_household(self, household_id):
household = self.get(household_id)
if household is not None:
for sim_info in household.sim_info_gen():
zone_id = services.current_zone_id()
if sim_info.zone_id != zone_id:
householdProto = services.get_persistence_service().get_household_proto_buff(household_id)
if householdProto is None:
logger.error('unable to find household with household id {}'.household_id)
return
found_sim = False
if householdProto.sims.ids:
for sim_id in householdProto.sims.ids:
if sim_id == sim_info.sim_id:
found_sim = True
break
if found_sim:
sim_proto = services.get_persistence_service().get_sim_proto_buff(sim_id)
sim_info.load_sim_info(sim_proto)
return household
logger.info('Starting to load household id = {0}', household_id)
household_proto = services.get_persistence_service().get_household_proto_buff(household_id)
if household_proto is None:
sims4.log.error('Persistence', 'Household proto could not be found id = {0}', household_id)
return
household = self._load_household_from_household_proto(household_proto)
return household
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 save_data(self):
household_msg = services.get_persistence_service(
).get_household_proto_buff(self.id)
if household_msg is None:
household_msg = services.get_persistence_service(
).add_household_proto_buff()
inventory = serialization.ObjectList()
inventory.CopyFrom(household_msg.inventory)
household_msg.Clear()
household_msg.account_id = self.account.id
household_msg.household_id = self.id
household_msg.name = self.name
household_msg.description = self.description
household_msg.home_zone = self.home_zone_id
household_msg.last_modified_time = self.last_modified_time
household_msg.money = self.funds.money
household_msg.hidden = self.hidden
household_msg.creator_id = self.creator_id
household_msg.creator_name = self.creator_name
if self.creator_uuid is not None:
household_msg.creator_uuid = self.creator_uuid
household_msg.inventory = inventory
household_msg.reward_inventory = self._reward_inventory
household_msg.gameplay_data.build_buy_unlock_list = ResourceKey_pb2.ResourceKeyList(
)
for unlock in self.build_buy_unlocks:
if isinstance(unlock, int):
unlock = sims4.resources.Key(Types.OBJCATALOG, unlock, 0)
key_proto = sims4.resources.get_protobuff_for_key(unlock)
household_msg.gameplay_data.build_buy_unlock_list.resource_keys.append(
key_proto)
household_msg.gameplay_data.situation_scoring_enabled = self._situation_scoring_enabled
if self.sim_in_household(self._last_active_sim_id):
household_msg.last_played = self._last_active_sim_id
household_msg.is_npc = self.is_persistent_npc
household_msg.gameplay_data.billable_household_value = self.household_net_worth(
billable=True)
household_msg.gameplay_data.ClearField(
'highest_earned_situation_medals')
for (situation_id,
medal) in self._highest_earned_situation_medals.items():
with ProtocolBufferRollback(
household_msg.gameplay_data.highest_earned_situation_medals
) as situation_medal:
situation_medal.situation_id = situation_id
situation_medal.medal = medal
self.bills_manager.save_data(household_msg)
self.collection_tracker.save_data(household_msg)
if self._service_npc_record is not None:
for service_record in self._service_npc_record.values():
with ProtocolBufferRollback(household_msg.gameplay_data.
service_npc_records) as record_msg:
service_record.save_npc_record(record_msg)
id_list = serialization.IdList()
for sim_info in self:
id_list.ids.append(sim_info.id)
household_msg.sims = id_list
return True
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 _lock_save_for_aging(_):
nonlocal lock_handle
if is_baby_age_up or not sim_info.is_npc:
class _AgeUpSaveLockHandle:
def get_lock_save_reason(self):
return AgingTuning.AGING_SAVE_LOCK_TOOLTIP(sim_info)
lock_handle = _AgeUpSaveLockHandle()
services.get_persistence_service().lock_save(lock_handle)
def set_main_career_event_zone_id_and_lock_save(self, main_zone_id):
class _SaveLock:
def get_lock_save_reason(self):
return LocalizationHelperTuning.get_raw_text('')
self._save_lock = _SaveLock()
services.get_persistence_service().lock_save(self._save_lock)
self._main_career_event_zone_id = main_zone_id
def prune_household(self, household_id):
household = self.get(household_id)
if household is not None:
if household.get_household_type() != sims.household.HouseholdType.GAME_CREATED:
logger.warn('Trying to prune a non-game created household:{}', household.id, owner='msantander')
return
sim_info_manager = services.sim_info_manager()
for sim_info in tuple(household):
household.remove_sim_info(sim_info, destroy_if_empty_gameplay_household=True)
sim_info_manager.remove_permanently(sim_info)
services.get_persistence_service().del_sim_proto_buff(sim_info.id)
def clear_household_lot_ownership(self, zone_id):
zone_data_proto = services.get_persistence_service(
).get_zone_proto_buff(zone_id)
zone_data_proto.household_id = 0
neighborhood_id = zone_data_proto.neighborhood_id
neighborhood_proto = services.get_persistence_service(
).get_neighborhood_proto_buff(neighborhood_id)
for lot_owner_info in neighborhood_proto.lots:
while lot_owner_info.zone_instance_id == zone_id:
lot_owner_info.ClearField('lot_owner')
break
def on_lod_update(self, old_lod, new_lod):
if new_lod == SimInfoLODLevel.ACTIVE:
sim_msg = services.get_persistence_service().get_sim_proto_buff(
self.owner_sim_info.id)
if sim_msg is not None:
self.load(sim_msg.attributes.event_data_tracker)
else:
sim_msg = services.get_persistence_service().get_sim_proto_buff(
self.owner_sim_info.id)
sim_msg.attributes.event_data_tracker.Clear()
self.save(sim_msg.attributes.event_data_tracker)
self.clear_update_alarm()
def _exited_pipeline(self, *args, **kwargs):
try:
should_die_on_transition_failure = self.should_die_on_transition_failure
super()._exited_pipeline(*args, **kwargs)
finally:
try:
if not should_die_on_transition_failure and self.finishing_type == FinishingType.TRANSITION_FAILURE:
return
while self.outcome_result != OutcomeResult.SUCCESS:
self.run_death_behavior(from_reset=True)
finally:
services.get_persistence_service().unlock_save(self)
def _exited_pipeline(self, *args, **kwargs):
try:
should_die_on_transition_failure = self.should_die_on_transition_failure
super()._exited_pipeline(*args, **kwargs)
finally:
try:
if not should_die_on_transition_failure and self.finishing_type == FinishingType.TRANSITION_FAILURE:
return
while self.outcome_result != OutcomeResult.SUCCESS:
self.run_death_behavior(from_reset=True)
finally:
services.get_persistence_service().unlock_save(self)
def load_travel_groups(self):
delete_group_ids = []
for travel_group_proto in services.get_persistence_service(
).all_travel_group_proto_gen():
travel_group_id = travel_group_proto.travel_group_id
travel_group = self.get(travel_group_id)
if travel_group is None:
travel_group = self.load_travel_group(travel_group_proto)
if travel_group is None:
delete_group_ids.append(travel_group_id)
for travel_group_id in delete_group_ids:
services.get_persistence_service().del_travel_group_proto_buff(
travel_group_id)
def remove_sim_info(self,
sim_info,
destroy_if_empty_gameplay_household=False):
self._sim_infos.remove(sim_info)
sim_info.assign_to_household(None, assign_is_npc=False)
self.notify_dirty()
services.get_event_manager().process_event(
test_events.TestEvent.HouseholdChanged, sim_info=sim_info)
if self._sim_infos or destroy_if_empty_gameplay_household and self.get_household_type(
) == HouseholdType.GAME_CREATED:
services.get_persistence_service().del_household_proto_buff(
self.id)
services.household_manager().remove(self)
def save_zone(self, save_slot_data=None):
zone_data_msg = self._get_zone_proto()
zone_data_msg.ClearField('gameplay_zone_data')
gameplay_zone_data = zone_data_msg.gameplay_zone_data
gameplay_zone_data.lot_owner_household_id_on_save = self.lot.owner_household_id
gameplay_zone_data.venue_type_id_on_save = self.venue_service.venue.guid64 if self.venue_service.venue is not None else 0
gameplay_zone_data.active_household_id_on_save = services.active_household_id(
)
self.lot.save(gameplay_zone_data)
if self.lot.front_door_id:
zone_data_msg.front_door_id = self.lot.front_door_id
num_spawn_points = len(self._spawner_data)
spawn_point_ids = [0] * num_spawn_points
for (spawn_point_id, spawn_point) in self._spawner_data.items():
spawn_point_ids[spawn_point.spawn_point_index] = spawn_point_id
zone_data_msg.ClearField('spawn_point_ids')
zone_data_msg.spawn_point_ids.extend(spawn_point_ids)
zone_objects_message = serialization.ZoneObjectData()
object_list = serialization.ObjectList()
zone_objects_message.zone_id = self.id
persistence_service = services.get_persistence_service()
open_street_data = persistence_service.get_open_street_proto_buff(
self.open_street_id)
if open_street_data is not None:
open_street_data.Clear()
add_proto_to_persistence = False
else:
open_street_data = serialization.OpenStreetsData()
add_proto_to_persistence = True
open_street_data.world_id = self.open_street_id
open_street_data.nbh_id = self.neighborhood_id
open_street_data.sim_time_on_save = services.time_service(
).sim_timeline.now.absolute_ticks()
open_street_data.active_household_id_on_save = services.active_household_id(
)
open_street_data.active_zone_id_on_save = self.id
self.service_manager.save_all_services(
persistence_service,
persistence_error_types.ErrorCodes.ZONE_SERVICES_SAVE_FAILED,
object_list=object_list,
zone_data=zone_data_msg,
open_street_data=open_street_data,
save_slot_data=save_slot_data)
zone_objects_message.objects = object_list
if add_proto_to_persistence:
services.get_persistence_service().add_open_street_proto_buff(
open_street_data)
persistence_module.run_persistence_operation(
persistence_module.PersistenceOpType.kPersistenceOpSaveZoneObjects,
zone_objects_message, 0, None)
def merge(self, merge_with_id):
otherhouse = services.get_persistence_service(
).get_household_proto_buff(merge_with_id)
self._funds.add(otherhouse.money, TELEMETRY_HOUSEHOLD_TRANSFER_GAIN,
None)
self._reward_inventory.reward_parts.extend(
otherhouse.reward_inventory.reward_parts)
for sim_id in otherhouse.sims.ids:
self.refresh_sim_data(sim_id,
assign=True,
spawn=True,
selectable=True)
services.get_persistence_service().del_household_proto_buff(
merge_with_id)
def delete_household(household: Household) -> bool:
"""delete_household(household)
Delete the specified household from the game.
:param household: The Household to delete
:type household: Household
:return: True, if the Household was deleted successfully. False, if not.
:rtype: bool
"""
services.get_persistence_service().del_household_proto_buff(
household.id)
services.household_manager().remove(household)
return True
def clear_lot_ownership(self, zone_id):
zone_data_proto = services.get_persistence_service(
).get_zone_proto_buff(zone_id)
if zone_data_proto is not None:
zone_data_proto.household_id = 0
lot_decoration_service = services.lot_decoration_service()
neighborhood_proto = services.get_persistence_service(
).get_neighborhood_proto_buff(zone_data_proto.neighborhood_id)
for lot_owner_info in neighborhood_proto.lots:
if lot_owner_info.zone_instance_id == zone_id:
lot_owner_info.ClearField('lot_owner')
if lot_decoration_service is not None:
lot_decoration_service.handle_lot_owner_changed(
zone_id, None)
break
def __init__(self, aop, context, **kwargs):
if self.destination_lot is None:
zone_id = context.sim.household.home_zone_id
else:
lot_id = get_lot_id_from_instance_id(self.destination_lot)
zone_id = services.get_persistence_service().resolve_lot_id_into_zone_id(lot_id, ignore_neighborhood_id=True)
super().__init__(aop, context, from_zone_id=context.sim.zone_id, to_zone_id=zone_id, on_complete_callback=None, on_complete_context=None, **kwargs)
def load_zone(self):
zone_data_proto = self._get_zone_proto()
self.neighborhood_id = zone_data_proto.neighborhood_id
self.open_street_id = zone_data_proto.world_id
self.service_manager.load_all_services(zone_data=zone_data_proto)
self._first_visit_to_zone = not protocol_buffer_utils.has_field(
zone_data_proto.gameplay_zone_data, 'venue_type_id_on_save')
open_street_data = services.get_persistence_service(
).get_open_street_proto_buff(self.open_street_id)
if open_street_data is not None:
self._time_of_last_open_street_save = DateAndTime(
open_street_data.sim_time_on_save)
spawn_points = {}
if zone_data_proto.spawn_point_ids:
for (index,
spawn_point_id) in enumerate(zone_data_proto.spawn_point_ids):
spawn_point = self._spawner_data[index]
spawn_point.spawn_point_id = spawn_point_id
spawn_points[spawn_point_id] = spawn_point
else:
for (index, spawn_point) in enumerate(self._spawner_data.values()):
spawn_point_id = id_generator.generate_object_id()
spawn_point.spawn_point_id = spawn_point_id
spawn_points[spawn_point_id] = spawn_point
self._spawner_data = spawn_points
self.lot.load(zone_data_proto.gameplay_zone_data)
for spawn_point in self._spawner_data.values():
while spawn_point.has_tag(
SpawnPoint.
ARRIVAL_SPAWN_POINT_TAG) and spawn_point.lot_id == self.lot.lot_id:
self._active_lot_arrival_spawn_point = spawn_point
return True
def travel_to_venue(self):
if self._zone_id is None:
logger.error('Failed to travel to venue')
return
active_sim_info = services.active_sim_info()
active_sim = active_sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS_EXCEPT_UNINITIALIZED)
if active_sim is None:
return
lot_id = None
zone = services.get_zone_manager().get(self._zone_id)
if zone is None:
lot_id = services.get_persistence_service(
).get_lot_id_from_zone_id(self._zone_id)
else:
lot_id = zone.lot.lot_id
if lot_id is None:
return
pick = PickInfo(pick_type=PickType.PICK_TERRAIN,
lot_id=lot_id,
ignore_neighborhood_id=True)
context = interactions.context.InteractionContext(
active_sim,
interactions.context.InteractionContext.
SOURCE_SCRIPT_WITH_USER_INTENT,
interactions.priority.Priority.High,
insert_strategy=interactions.context.QueueInsertStrategy.NEXT,
pick=pick)
active_sim.push_super_affordance(
VenueEventDramaNode.GO_TO_VENUE_ZONE_INTERACTION, None, context)
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 travel_sims_to_zone(opt_sim_id:OptionalTargetParam, zone_id:int, *traveling_sim_ids, _connection=None):
sim_or_sim_info = get_optional_target(opt_sim_id, _connection)
if sim_or_sim_info is None:
if opt_sim_id:
sim_or_sim_info = services.sim_info_manager().get(opt_sim_id)
if sim_or_sim_info is None:
sims4.commands.output('Invalid Sim id: {} specified for travel.travel_sims_to_zone'.format(opt_sim_id), _connection)
return False
else:
sims4.commands.output('No Sim id specified for travel.travel_sims_to_zone', _connection)
return False
zone_proto_buff = services.get_persistence_service().get_zone_proto_buff(zone_id)
if zone_proto_buff is None:
sims4.commands.output('Invalid Zone Id: {}. Zone does not exist.'.format(zone_id), _connection)
return False
situation_manager = services.get_zone_situation_manager()
situation = situation_manager.DEFAULT_TRAVEL_SITUATION
guest_list = situation.get_predefined_guest_list()
if guest_list is None:
guest_list = SituationGuestList(invite_only=True, host_sim_id=sim_or_sim_info.id)
default_job = situation.default_job()
sim_info_manager = services.sim_info_manager()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
traveling_sim_ids = tuple(itertools.chain(traveling_sim_ids, (sim_info.sim_id for sim_info in roommate_service.get_auto_invite_sim_infos(sim_or_sim_info, situation))))
for sim_id in traveling_sim_ids:
sim_id = int(sim_id)
sim_info = sim_info_manager.get(sim_id)
if sim_info is None:
continue
guest_info = SituationGuestInfo.construct_from_purpose(sim_id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
guest_info = SituationGuestInfo.construct_from_purpose(sim_or_sim_info.id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
situation_manager.create_situation(situation, guest_list=guest_list, user_facing=False, zone_id=zone_id)
def request_client_disconnect_gen(timeline):
try:
zone = services.current_zone()
if zone is not None:
client_manager = zone.client_manager
client = client_manager.get(session_id)
logger.info('Client {0} starting save of zone {1}', session_id,
zone_id)
yield services.get_persistence_service(
).save_to_scratch_slot_gen(timeline)
logger.info('Client {0} save completed for {1}', session_id,
zone_id)
with telemetry_helper.begin_hook(
area_telemetry_writer,
TELEMETRY_HOOK_ZONE_EXIT,
household=client.household) as hook:
(player_sims, npc_sims) = services.sim_info_manager(
).get_player_npc_sim_count()
hook.write_int(TELEMETRY_FIELD_PLAYER_COUNT, player_sims)
hook.write_int(TELEMETRY_FIELD_NPC_COUNT, npc_sims)
zone.on_teardown(client)
if client is None:
logger.error(
'Client {0} not in client manager from zone {1}',
session_id, zone_id)
return callback(zone_id, session_id, NO_CLIENT_ERROR_CODE)
client_manager.remove(client)
return callback(zone_id, session_id, SUCCESS_CODE)
except:
logger.exception('Error disconnecting the client')
return callback(zone_id, session_id, EXCEPTION_ERROR_CODE)
def send_selectable_sims_update(self):
msg = Sims_pb2.UpdateSelectableSims()
for sim_info in self._selectable_sims:
with ProtocolBufferRollback(msg.sims) as new_sim:
new_sim.id = sim_info.sim_id
if sim_info.career_tracker is None:
logger.error(
'CareerTracker is None for selectable Sim {}'.format(
sim_info))
else:
career = sim_info.career_tracker.get_currently_at_work_career(
)
new_sim.at_work = career is not None and not career.is_at_active_event
new_sim.is_selectable = sim_info.is_enabled_in_skewer
(selector_visual_type,
career_category) = self._get_selector_visual_type(sim_info)
new_sim.selector_visual_type = selector_visual_type
if career_category is not None:
new_sim.career_category = career_category
new_sim.can_care_for_toddler_at_home = sim_info.can_care_for_toddler_at_home
if not sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
new_sim.instance_info.zone_id = sim_info.zone_id
new_sim.instance_info.world_id = sim_info.world_id
new_sim.firstname = sim_info.first_name
new_sim.lastname = sim_info.last_name
zone_data_proto = services.get_persistence_service(
).get_zone_proto_buff(sim_info.zone_id)
if zone_data_proto is not None:
new_sim.instance_info.zone_name = zone_data_proto.name
distributor = Distributor.instance()
distributor.add_op_with_no_owner(
GenericProtocolBufferOp(Operation.SELECTABLE_SIMS_UPDATE, msg))
def _on_dialog_accepted(self):
if services.get_persistence_service().is_save_locked():
return
travel_info = InteractionOps_pb2.TravelSimsToZone()
travel_info.zone_id = self._target.household.home_zone_id
travel_info.sim_ids.append(self._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 _load_account_by_id(self, account_id):
if account_id == SimSpawner.SYSTEM_ACCOUNT_ID:
new_account = account.Account(SimSpawner.SYSTEM_ACCOUNT_ID, 'SystemAccount')
return new_account
account_proto = services.get_persistence_service().get_account_proto_buff()
new_account = account.Account(account_proto.nucleus_id, account_proto.persona_name)
new_account.load_account(account_proto)
return new_account
def force_neighbors_home(_connection=None):
client = services.client_manager().get_first_client()
active_household = client.household
if active_household is not None:
active_household_home_zone_id = active_household.home_zone_id
active_household_home_world_id = services.get_persistence_service().get_world_id_from_zone(active_household_home_zone_id)
send_home = active_household_home_zone_id == services.current_zone().id
blacklist_until = services.time_service().sim_now + date_and_time.create_time_span(days=7)
for sim_info in services.sim_info_manager().values():
if sim_info.is_selectable:
pass
sim_info_home_zone_id = sim_info.household.home_zone_id
sim_info_home_world_id = services.get_persistence_service().get_world_id_from_zone(sim_info_home_zone_id)
while sim_info_home_world_id == active_household_home_world_id:
services.get_zone_situation_manager().add_sim_to_auto_fill_blacklist(sim_info.id, blacklist_until=blacklist_until)
if send_home and sim_info.zone_id != active_household_home_zone_id and sim_info.zone_id != sim_info_home_zone_id:
sim_info.inject_into_inactive_zone(sim_info_home_zone_id)
def start_baby_neglect(baby):
baby._started_neglect_moment = True
sim_info = baby.sim_info
dialog = Baby.NEGLECT_NOTIFICATION(sim_info, SingleSimResolver(sim_info))
dialog.show_dialog()
neglect_effect = vfx.PlayEffect(sim_info, 's40_Sims_neglected', sims4.hash_util.hash32('_FX_'))
neglect_effect.start()
camera.focus_on_sim(sim_info, follow=False)
sim_info_manager = services.sim_info_manager()
with genealogy_caching():
for member_id in sim_info.genealogy.get_immediate_family_sim_ids_gen():
member_info = sim_info_manager.get(member_id)
member_info.add_buff_from_op(Baby.NEGLECT_BUFF_IMMEDIATE_FAMILY.buff_type, Baby.NEGLECT_BUFF_IMMEDIATE_FAMILY.buff_reason)
empty_bassinet = _replace_bassinet(sim_info)
empty_bassinet.set_state(Baby.NEGLECT_EMPTY_BASSINET_STATE.state, Baby.NEGLECT_EMPTY_BASSINET_STATE)
services.client_manager().get_first_client().selectable_sims.remove_selectable_sim_info(sim_info)
services.get_persistence_service().del_sim_proto_buff(sim_info.id)
sim_info_manager.remove_permanently(sim_info)
def load_households(self):
for household_proto in services.get_persistence_service().all_household_proto_gen():
household_id = household_proto.household_id
household = self.get(household_id)
while household is None:
self._load_household_from_household_proto(household_proto)
for household_id in self._pending_household_funds.keys():
logger.error('Household {} has pending funds leftover from BB after all households were loaded.', household_id, owner='camilogarcia')
self._pending_household_funds = None
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 c_api_zone_init(zone_id,
world_id,
world_file,
gameplay_zone_data_bytes=None,
save_slot_data_bytes=None):
zone_data_proto = services.get_persistence_service().get_zone_proto_buff(
zone_id)
if zone_data_proto is not None:
gameplay_zone_data = zone_data_proto.gameplay_zone_data
save_slot_data = services.get_persistence_service(
).get_save_slot_proto_buff()
zone = services._zone_manager.create_zone(zone_id, gameplay_zone_data,
save_slot_data)
zone.world_id = world_id
zone_number = sims4.zone_utils.zone_numbers[zone_id]
status.info('Zone {:#08x} (Zone #{}) initialized'.format(zone_id,
zone_number))
zone = services._zone_manager.get(zone_id)
return SUCCESS_CODE
def save_current_houshold(slot_id:int=0, slot_name='Unnamed', _connection=None):
output = sims4.commands.Output(_connection)
try:
sim_info.save_active_household_command_start()
save_slot_data_msg = services.get_persistence_service().get_save_slot_proto_buff()
save_slot_data_msg.slot_id = slot_id
active_household = services.active_household()
if active_household is not None:
save_slot_data_msg.active_household_id = active_household.id
sims4.core_services.service_manager.save_all_services(None, persistence_error_types.ErrorCodes.CORE_SERICES_SAVE_FAILED, save_slot_data=save_slot_data_msg)
save_game_buffer = services.get_persistence_service().get_save_game_data_proto()
persistence_module.run_persistence_operation(persistence_module.PersistenceOpType.kPersistenceOpSaveHousehold, save_game_buffer, 0, None)
except Exception as e:
output('Exception thrown while executing command persistence.save_active_household.\n{}'.format(e))
output('No household file generated. Please address all the exceptions.')
raise
finally:
sim_info.save_active_household_command_stop()
output('Exported active household to T:\\InGame\\Households\\{}.household'.format(active_household.name))
return 1
def on_client_connect(self, client):
if client.account.save_slot_id is not None:
save_slot_data_msg = services.get_persistence_service(
).get_save_slot_proto_buff()
if save_slot_data_msg.HasField('gameplay_data'):
world_game_time = save_slot_data_msg.gameplay_data.world_game_time
current_ticks = self.now().absolute_ticks()
difference = world_game_time - current_ticks
self._add_to_game_time_and_send_update(difference)
self._client_connect_world_time = self.now()
logger.debug('Clock.on_client_connect {}', self.now())
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 _load_options(self):
account_data_msg = services.get_persistence_service().get_account_proto_buff()
options_proto = account_data_msg.gameplay_account_data.gameplay_options
if options_proto is None:
logger.warn('Trying to load options in account.py but options_proto is None.')
return
zone = services.current_zone()
if zone is None:
logger.warn('Trying to load game options but zone is None.')
return
zone.service_manager.load_options(options_proto)
def remove_fire_object(self, fire_object):
if self._burning_objects and fire_object in self._burning_objects:
for obj in self._burning_objects[fire_object]:
self._stop_object_burning(obj, fire_object)
del self._burning_objects[fire_object]
if fire_object in self._fire_objects:
self._fire_objects.remove(fire_object)
fire_object.remove_state_changed_callback(self._fire_object_state_changed_callback)
tracker = fire_object.get_tracker(self.FIRE_BEEN_EXTINGUISHED_COMMODITY)
if tracker is not None:
stat = tracker.get_statistic(self.FIRE_BEEN_EXTINGUISHED_COMMODITY)
if stat is not None and stat.get_value() > 0:
self._remove_fire_from_quadtree(fire_object)
if not self._fire_objects:
self._fire_quadtree = None
self._advance_situations_to_postfire()
self._award_insurance_money()
services.get_persistence_service().unlock_save(self)
self.unregister_for_panic_callback()
self.unregister_for_sim_active_lot_status_changed_callback()
self.deactivate_fire_alarms()
def get_venue_instance_from_pick_location(pick):
if pick is None:
return
lot_id = pick.lot_id
if lot_id is None:
return
persistence_service = services.get_persistence_service()
lot_owner_info = persistence_service.get_lot_proto_buff(lot_id)
if lot_owner_info is not None:
venue_key = lot_owner_info.venue_key
venue_instance = services.get_instance_manager(sims4.resources.Types.VENUE).get(venue_key)
return venue_instance
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))
def add_neighbor_bit_if_necessary(self, sim_info):
target_sim_info = self.find_target_sim_info()
if target_sim_info is None:
return
if sim_info.household is None or target_sim_info.household is None:
return
home_zone_id = sim_info.household.home_zone_id
target_home_zone_id = target_sim_info.household.home_zone_id
if home_zone_id == target_home_zone_id:
return
if home_zone_id == 0 or target_home_zone_id == 0:
return
sim_home_zone_proto_buffer = services.get_persistence_service().get_zone_proto_buff(home_zone_id)
target_sim_home_zone_proto_buffer = services.get_persistence_service().get_zone_proto_buff(target_home_zone_id)
if sim_home_zone_proto_buffer is None or target_sim_home_zone_proto_buffer is None:
logger.error('Invalid zone protocol buffer in Relationship.add_neighbor_bit_if_necessary()')
return
if sim_home_zone_proto_buffer.world_id != target_sim_home_zone_proto_buffer.world_id:
return
self.add_bit(global_relationship_tuning.RelationshipGlobalTuning.NEIGHBOR_RELATIONSHIP_BIT, notify_client=False)
target_relationship = self._tracker._find_relationship(sim_info.id, create=False)
if target_relationship is not None:
target_relationship.add_bit(global_relationship_tuning.RelationshipGlobalTuning.NEIGHBOR_RELATIONSHIP_BIT, notify_client=False)
def _run_interaction_gen(self, timeline):
to_zone_id = get_zone_id_from_pick_location(self.context.pick)
if to_zone_id is None:
logger.error('Could not resolve lot id: {} into a valid zone id when traveling to adjacent lot.', self.context.pick.lot_id, owner='rmccord')
return
if services.get_persistence_service().is_save_locked():
return
travel_info = InteractionOps_pb2.TravelSimsToZone()
travel_info.zone_id = to_zone_id
travel_info.sim_ids.append(self.sim.id)
for traveling_sim_id in self._traveling_sim_ids:
travel_info.sim_ids.append(traveling_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 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 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_household_display_info(lot_id, _connection=None):
persistence_service = services.get_persistence_service()
household_display_info = UI_pb2.HouseholdDisplayInfo()
household_id = persistence_service.get_household_id_from_lot_id(lot_id)
if household_id is None:
household_id = 0
household = services.household_manager().get(household_id)
if household is None:
household_id = 0
else:
household_display_info.at_home_sim_ids.extend(household.get_sims_at_home())
household_display_info.household_id = household_id
household_display_info.lot_id = lot_id
op = shared_messages.create_message_op(household_display_info, Consts_pb2.MSG_UI_HOUSEHOLD_DISPLAY_INFO)
Distributor.instance().add_op_with_no_owner(op)
def __call__(self, target, context):
sim = context.sim
lot_id = context.pick.lot_id
if lot_id is None:
return
persistence_service = services.get_persistence_service()
to_zone_id = persistence_service.resolve_lot_id_into_zone_id(lot_id)
if to_zone_id is None:
return
if sim.household.home_zone_id == to_zone_id:
return self.go_home_name(sim)
household_id = None
lot_owner_info = persistence_service.get_lot_proto_buff(lot_id)
if lot_owner_info is not None:
for household in lot_owner_info.lot_owner:
household_id = household.household_id
break
if household_id:
household = services.household_manager().get(household_id)
else:
household = None
if household is None:
return self.go_here_name(sim)
sim_infos_known = False
sim_infos_known_at_home = []
sim_infos_at_home = False
same_last_name = True
for sim_info in household.sim_info_gen():
if sim_info.relationship_tracker.get_all_bits(sim.id):
sim_infos_known = True
if sim_info.zone_id == to_zone_id:
sim_infos_known_at_home.append(sim_info)
elif sim_info.zone_id == to_zone_id:
sim_infos_at_home = True
while not sim_info.last_name == household.name:
same_last_name = False
if not sim_infos_known:
travel_name = self.ring_doorbell_name(sim)
else:
if len(sim_infos_known_at_home) == 1:
return self.visit_sim_name(sim, sim_infos_known_at_home[0])
if same_last_name:
travel_name = self.visit_the_household_plural_name(sim, household.name)
else:
travel_name = self.visit_household_name(sim, household.name)
if not sim_infos_at_home:
return self.no_one_home_encapsulation(travel_name)
return travel_name
