def on_enter(self):
super().on_enter()
zone = services.current_zone()
zone.venue_service.build_buy_edit_mode = True
services.household_manager().load_households()
zone.on_households_and_sim_infos_loaded()
client = zone.zone_spin_up_service._client_connect_data.client
club_service = services.get_club_service()
if club_service is not None:
club_service.on_all_households_and_sim_infos_loaded(client)
relationship_service = services.relationship_service()
if relationship_service is not None:
relationship_service.on_all_households_and_sim_infos_loaded(client)
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_service.initialize_editmode_roommates()
situation_manager = services.get_zone_situation_manager()
situation_manager.spin_up_for_edit_mode()
object_manager = services.object_manager()
water_terrain_object_cache = object_manager.water_terrain_object_cache
build_buy.register_build_buy_exit_callback(
water_terrain_object_cache.refresh)
conditional_layer_service = services.conditional_layer_service()
conditional_layer_service.on_zone_load(editmode=True)
for obj in object_manager.values():
footprint_component = obj.get_component(FOOTPRINT_COMPONENT)
if footprint_component is not None:
footprint_component.on_finalize_load()
services.game_clock_service().restore_saved_clock_speed()
return _ZoneSpinUpStateResult.DONE
def _get_census(self):
player_households = sum(1 for household in services.household_manager().get_all() if household.is_player_household)
player_sims = sum(1 for sim_info in services.sim_info_manager().get_all() if sim_info.is_player_sim)
households = len(services.household_manager())
sims = len(services.sim_info_manager())
lod_counts = {lod: services.sim_info_manager().get_num_sim_infos_with_lod(lod) for lod in SimInfoLODLevel}
return (player_households, player_sims, households, sims, lod_counts)
def create_sim_infos(cls, sim_creators, household=None, starting_funds=DEFAULT, tgt_client=None, account=None, generate_deterministic_sim=False, zone_id=None, creation_source:str='Unknown'):
sim_info_list = []
if account is None:
account = cls._get_default_account()
if household is None:
household = sims.household.Household(account, starting_funds=starting_funds)
sim_creation_dictionaries = tuple(sim_creator.build_creation_dictionary() for sim_creator in sim_creators)
new_sim_data = generate_household(sim_creation_dictionaries=sim_creation_dictionaries, household_name=household.name, generate_deterministic_sim=generate_deterministic_sim)
zone = services.current_zone()
world_id = zone.world_id
if zone_id is None:
zone_id = zone.id
language = cls._get_language_for_locale(account)
family_name = cls._get_random_family_name(language)
if household.id == 0:
household.id = new_sim_data['id']
services.household_manager().add(household)
household.name = family_name
for (index, sim_data) in enumerate(new_sim_data['sims']):
sim_proto = serialization.SimData()
sim_proto.ParseFromString(sim_data)
first_name = sim_creators[index].first_name
if not first_name and not sim_creators[index].full_name_key:
first_name = cls._get_random_first_name(language, sim_proto.gender == Gender.FEMALE)
last_name = sim_creators[index].last_name
if not last_name and not sim_creators[index].full_name_key:
last_name = cls._get_family_name_for_gender(language, family_name, sim_proto.gender == Gender.FEMALE)
sim_proto.first_name = first_name
sim_proto.last_name = last_name
sim_proto.full_name_key = sim_creators[index].full_name_key
sim_proto.age = sim_creators[index].age
sim_proto.zone_id = zone_id
sim_proto.world_id = world_id
sim_proto.household_id = household.id
sim_proto.gameplay_data.creation_source = creation_source
sim_info = sims.sim_info.SimInfo(sim_proto.sim_id, account=account)
sim_info.load_sim_info(sim_proto)
if sim_creators[index].resource_key:
sim_info.load_from_resource(sim_creators[index].resource_key)
if not sim_info.first_name:
sim_info.first_name = sim_proto.first_name
if not sim_info.last_name:
sim_info.last_name = sim_proto.last_name
if not sim_info.full_name_key:
sim_info.full_name_key = sim_proto.full_name_key
household.add_sim_info(sim_info)
sim_info.assign_to_household(household)
sim_info.save_sim()
sim_info_list.append(sim_info)
if tgt_client is not None and household is tgt_client.household:
logger.info('Added {} Sims to the current client', len(sim_creators))
tgt_client.set_next_sim()
else:
logger.info('Added {} Sims to household ID {}.', len(sim_creators), household.id)
logger.info('Create Sims, sim_number={}; succeeded', len(sim_creators))
household.save_data()
return (sim_info_list, household)
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 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 get_value(household_id, billable:bool=False, _connection=None):
household = services.household_manager().get(household_id)
if household is not None:
value = household.household_net_worth(billable=billable)
sims4.commands.output('Simoleon value of household {} is {}.'.format(household, value), _connection)
else:
sims4.commands.output('Invalid Household id: {}'.format(household_id), _connection)
def add(self, obj, *args, **kwargs):
super().add(obj, *args, **kwargs)
if obj.objectage_component is None:
services.current_zone().increment_object_count(obj)
household_manager = services.household_manager()
if household_manager is not None:
household_manager.increment_household_object_count(obj.get_household_owner_id())
def _find_households_to_rent_lot(self):
possible_travel_groups = []
household_manager = services.household_manager()
for household in household_manager.values():
if household.hidden:
continue
if household.any_member_in_travel_group():
continue
sim_infos_that_can_lead_travel_group = []
sim_infos_available_for_vacation = []
for sim_info in household:
if sim_info.is_instanced():
continue
resolver = SingleSimResolver(sim_info)
if not _FillRentableLotRequest.CAN_RENT_TESTS.run_tests(
resolver):
continue
if sim_info.is_young_adult_or_older and sim_info.is_human:
sim_infos_that_can_lead_travel_group.append(sim_info)
if not sim_info.is_baby:
sim_infos_available_for_vacation.append(sim_info)
if sim_infos_that_can_lead_travel_group:
possible_travel_groups.append(
(sim_infos_that_can_lead_travel_group,
sim_infos_available_for_vacation))
return possible_travel_groups
def process_action(self, story_progression_flags):
neighborhood_population_service = services.neighborhood_population_service(
)
if neighborhood_population_service is None:
return
households = services.household_manager().values()
num_homeless_households = sum(1 for household in households
if household.home_zone_id == 0)
if num_homeless_households >= self._homeless_households.lower_bound:
self._homeless_household_completed_callback(True)
else:
neighborhood_population_service.add_homeless_household_request(
self._homeless_households.random_int(),
self._homeless_household_completed_callback)
neighborhood_proto_buff = self._get_neighborhood_proto()
if neighborhood_proto_buff is None:
return
if StoryProgressionFlags.ALLOW_INITIAL_POPULATION not in story_progression_flags:
self._zone_population_completed_callback(True)
return
if neighborhood_proto_buff.gameplay_data.npc_population_state != gameplay_neighborhood_data_constants.COMPLETED:
neighborhood_proto_buff.gameplay_data.npc_population_state = gameplay_neighborhood_data_constants.STARTED
desired_population_data = self._region_to_population_density.get(
neighborhood_proto_buff.region_id, None)
if desired_population_data is not None:
self._add_population_request(desired_population_data,
neighborhood_proto_buff, False)
else:
self._zone_population_completed_callback(True)
def check_collection_complete(self, collection_id):
collection_data = ObjectCollectionData.get_collection_data(collection_id)
collection_count = len(collection_data.object_list)
collected_count = sum(1 for collection in self._collections.values() if collection == collection_id)
if not collection_count or not collected_count:
return
client = services.client_manager().get_client_by_household(self._owner)
if client is not None and client.active_sim is not None:
message_owner_info = client.active_sim.sim_info
else:
message_owner_info = None
if collection_data.first_collected_notification is not None and message_owner_info is not None and collected_count == 1:
dialog = collection_data.first_collected_notification(message_owner_info, None)
dialog.show_dialog()
if collection_count == collected_count:
if client is not None:
with telemetry_helper.begin_hook(collection_telemetry_writer, TELEMETRY_HOOK_COLLECTION_COMPLETE, household=client.household) as hook:
hook.write_int(TELEMETRY_COLLECTION_ID, collection_id)
_sting = ObjectCollectionData.COLLECTION_COMPLETED_STING(client.active_sim)
_sting.start()
if message_owner_info is not None:
dialog = collection_data.completed_award_notification(message_owner_info, None)
dialog.show_dialog()
if collection_data.screen_slam is not None:
collection_data.screen_slam.send_screen_slam_message(message_owner_info, collection_data.collection_name)
lot = services.active_lot()
if lot is not None:
lot.create_object_in_hidden_inventory(collection_data.completed_award)
household = services.household_manager().get(self._owner.id)
if household is not None:
household.funds.add(collection_data.completed_award_money, Consts_pb2.TELEMETRY_MONEY_ASPIRATION_REWARD, None)
elif client is not None:
_sting = ObjectCollectionData.COLLECTION_COLLECTED_STING(client.active_sim)
_sting.start()
def create_lod_sim_infos(quantity: int = 1,
lod: SimInfoLODLevel = SimInfoLODLevel.MINIMUM,
_connection=None):
output = sims4.commands.CheatOutput(_connection)
account = services.client_manager().get(_connection).account
for _ in range(quantity):
gender = random.choice(list(Gender))
age = random.choice([Age.TEEN, Age.YOUNGADULT, Age.ADULT, Age.ELDER])
first_name = SimSpawner.get_random_first_name(gender)
last_name = 'CheatFamilyLOD{}'.format(lod)
sc = SimCreator(gender=gender,
age=age,
first_name=first_name,
last_name=last_name)
household = services.household_manager().create_household(account)
(si, _) = SimSpawner.create_sim_infos(
(sc, ),
household=household,
zone_id=0,
creation_source='cheat: LOD SimInfo')
if not si[0].request_lod(lod):
output('Failed to request {} lod for {}'.format(lod, si[0]))
output('Created a SimInfo and requested {} LOD: {}.'.format(
lod, si[0]))
output('Created a total of {} SimInfos at {} LOD'.format(lod, quantity))
def sell_lot_response(dialog):
if not dialog.accepted:
return
business_manager = services.business_service(
).get_business_manager_for_zone()
current_zone = services.current_zone()
lot = current_zone.lot
lot_value = lot.furnished_lot_value
business_manager.modify_funds(lot_value)
business_manager.transfer_balance_to_household()
services.get_zone_manager().clear_lot_ownership(current_zone.id)
business_tracker = services.business_service(
).get_business_tracker_for_household(business_manager.owner_household_id,
business_manager.business_type)
if business_tracker is None:
logger.warn(
'Business tracker is None for household {} for business type {}',
business_manager.owner_household_id,
business_manager.business_type)
return
business_tracker.remove_owner(current_zone.id)
current_zone.disown_household_objects()
with telemetry_helper.begin_hook(
business_telemetry_writer,
TELEMETRY_HOOK_BUSINESS_SOLD,
household=services.household_manager().get(
business_manager.owner_household_id)) as hook:
hook.write_enum(TELEMETRY_HOOK_BUSINESS_TYPE,
business_manager.business_type)
msg = InteractionOps_pb2.SellRetailLot()
msg.retail_zone_id = current_zone.id
distributor.system.Distributor.instance().add_event(
Consts_pb2.MSG_SELL_RETAIL_LOT, msg)
def _close_business(self, play_sound=True):
if not self._is_open:
return
if play_sound:
sound = PlaySound(services.get_active_sim(), self.tuning_data.audio_sting_close.instance)
sound.start()
self._employee_manager.close_business()
self.send_daily_profit_and_cost_update()
self._send_business_closed_telemetry()
if self._owner_household_id is not None:
owner_household = services.household_manager().get(self._owner_household_id)
owner_household.bucks_tracker.deactivate_all_temporary_perk_timers_of_type(self.tuning_data.bucks)
self.modify_funds(-self._employee_manager.final_daily_wages(), from_item_sold=False)
self.on_store_closed()
services.get_event_manager().process_event(TestEvent.BusinessClosed)
self._distribute_business_open_status(False)
if self.business_zone_id == services.current_zone_id():
self.tuning_data.lighting_helper_close.execute_lighting_helper(self)
zone_director = services.venue_service().get_zone_director()
if zone_director is not None:
zone_director.refresh_open_street_director_status()
else:
self.run_off_lot_simulation()
self._last_off_lot_update = None
self._is_open = False
self.show_summary_dialog(is_from_close=True)
self._open_time = None
def _do_behavior(self):
obj = self.interaction.get_participant(self.participant)
if obj is None:
return
sim = self.interaction.sim
if sim is None:
return
stolen_component = obj.get_component(
objects.components.types.STOLEN_COMPONENT)
if stolen_component is None:
logger.error(
"Interaction: {} is attempting to use the ReturnStolenObject basic extra on an object that doesn't have the stolen component.",
self.interaction)
return
obj.remove_from_client(fade_duration=obj.FADE_DURATION)
stolen_from_household_id = stolen_component.stolen_from_household_id
household = services.household_manager().get(stolen_from_household_id)
if household is not None:
obj.set_household_owner_id(household.id)
def on_reservation_change(*_, **__):
if not obj.in_use:
obj.unregister_on_use_list_changed(on_reservation_change)
object_location_type = ObjectOriginLocation.SIM_INVENTORY if obj.is_in_sim_inventory else ObjectOriginLocation.ON_LOT
if not build_buy.move_object_to_household_inventory(
obj, object_location_type=object_location_type):
obj.schedule_destroy_asap()
if obj.in_use:
obj.register_on_use_list_changed(on_reservation_change)
elif not build_buy.move_object_to_household_inventory(obj):
obj.schedule_destroy_asap()
else:
obj.make_transient()
def _save_clean_up_destination_data(self, current_zone,
objects_to_save_for_clean_up,
save_game_protocol_buffer):
household_manager = services.household_manager()
travel_group_manager = services.travel_group_manager()
clean_up_save_data = None
for object_data in sorted(objects_to_save_for_clean_up,
key=lambda x: x.owner_id):
owner_id = object_data.owner_id
if clean_up_save_data is None or clean_up_save_data.household_id != owner_id:
household = household_manager.get(owner_id)
travel_group = None
if household is not None:
travel_group = household.get_travel_group()
for clean_up_save_data in save_game_protocol_buffer.destination_clean_up_data:
if clean_up_save_data.household_id != owner_id:
continue
if travel_group is not None:
if travel_group.id == clean_up_save_data.travel_group_id:
break
if clean_up_save_data.travel_group_id in travel_group_manager:
continue
break
with ProtocolBufferRollback(
clean_up_save_data.object_clean_up_data_list
) as object_clean_up_data:
if object_data.loc_type == ItemLocation.ON_LOT:
object_clean_up_data.zone_id = current_zone.id
else:
object_clean_up_data.world_id = current_zone.open_street_id
object_clean_up_data.object_data = object_data
def send_household_region_telemetry(cls):
household_manager = services.household_manager()
if household_manager is None:
return
persistence_service = services.get_persistence_service()
per_region_data = dict()
for household in household_manager.values():
is_townie_household = household.home_zone_id == 0
region_description_id = 0 if is_townie_household else get_region_description_id_from_zone_id(
household.home_zone_id)
region_data = per_region_data.get(region_description_id, None)
if region_data is None:
region_data = HouseholdRegionTelemetryData(
region_description_id=region_description_id)
per_region_data[region_description_id] = region_data
if household.is_played_household:
region_data.played_household_count += 1
region_data.played_sim_info_count += len(household)
if is_townie_household:
region_data.townie_household_count += 1
region_data.townie_sim_info_count += len(household)
else:
region_data.region_occupied_lot_count += 1
if region_data.region_total_lot_count is None:
neighborhood_proto = persistence_service.get_neighborhood_proto_buf_from_zone_id(
household.home_zone_id)
region_data.region_total_lot_count = len(
neighborhood_proto.lots)
for region_data in per_region_data.values():
region_data._send_telemetry()
def set_num_sim_infos(quantity: int,
allow_player: bool = False,
_connection=None):
output = sims4.commands.CheatOutput(_connection)
sim_info_manager = services.sim_info_manager()
household_manager = services.household_manager()
all_sim_infos = list(sim_info_manager.objects)
count = len(all_sim_infos)
if quantity >= count:
output('Current count {} < target count {}'.format(count, quantity))
return True
num_to_delete = count - quantity
eligible = []
for sim_info in all_sim_infos:
immunity_reasons = set(sim_info.get_culling_immunity_reasons())
if allow_player:
immunity_reasons.discard(CullingReasons.PLAYER)
if not immunity_reasons:
eligible.append(sim_info)
if len(eligible) < num_to_delete:
output('Insufficient eligible Sims; deleting all {}'.format(
len(eligible)))
num_to_delete = len(eligible)
doomed = random.sample(eligible, num_to_delete)
for sim_info in doomed:
household = sim_info.household
sim_info.remove_permanently()
if not len(household):
household_manager.remove(household)
output('Removed {} Sim infos. Current count is {}'.format(
num_to_delete, len(sim_info_manager.objects)))
def set_sims_in_household_to_lod(
household_id: int = None,
lod: SimInfoLODLevel = SimInfoLODLevel.MINIMUM,
_connection=None):
output = sims4.commands.CheatOutput(_connection)
automation_output = sims4.commands.AutomationOutput(_connection)
household = services.household_manager().get(household_id)
if household is None:
output('Household not found.')
automation_output('set_sims_in_household_to_lod; Status:Failed')
return False
for sim_info in household.sim_info_gen():
if sim_info.can_set_to_lod(lod):
if not sim_info.can_change_lod(sim_info.lod):
output(
'Not all sim infos can be set to {} LOD for household: {}'.
format(lod, household))
automation_output(
'set_sims_in_household_to_lod; Status:Failed')
return False
output(
'Not all sim infos can be set to {} LOD for household: {}'.format(
lod, household))
automation_output('set_sims_in_household_to_lod; Status:Failed')
return False
for sim_info in household.sim_info_gen():
if sim_info.request_lod(lod):
output('Sim set to {} LOD. ID:{} Name: {}'.format(
lod, sim_info.id, sim_info.full_name))
else:
output('Sim NOT set to {} LOD. ID:{} Name: {}'.format(
lod, sim_info.id, sim_info.full_name))
if lod == SimInfoLODLevel.MINIMUM:
household.set_to_hidden()
def autopay_bills(enable:bool=None, _connection=None):
households = services.household_manager().get_all()
for household in households:
bills_manager = household.bills_manager
autopay_bills = enable if enable is not None else not bills_manager.autopay_bills
bills_manager.autopay_bills = autopay_bills
sims4.commands.output('Autopay Bills for household {} set to {}.'.format(household, autopay_bills), _connection)
def __call__(self, test_targets=None):
target_household = None
if self.household_to_test.household_source == UtilityTest.ACTIVE_LOT_HOUSEHOLD:
target_household = services.owning_household_of_active_lot()
elif self.household_to_test.household_source == UtilityTest.ACTIVE_HOUSEHOLD:
target_household = services.active_household()
elif self.household_to_test.household_source == UtilityTest.PARTICIPANT_HOUSEHOLD:
target = next(iter(test_targets), None)
if target is not None:
if target.is_sim:
target_household = target.household
else:
target_household = services.household_manager().get(target.get_household_owner_id())
if target_household is not None:
utilities_manager = services.get_utilities_manager_by_household_id(target_household.id)
elif self.household_to_test.household_source == UtilityTest.ACTIVE_LOT_HOUSEHOLD and self.household_to_test.consider_non_household_lot:
utilities_manager = services.get_utilities_manager_by_zone_id(services.current_zone_id())
else:
return TestResult(False, 'UtilitiesTest: Required to check utility, but there is no household. Check participant tuning.', tooltip=self.tooltip)
if utilities_manager is None:
return TestResult(False, 'UtilitiesTest: Required to check utility, but utilities manager is None. Check participant tuning.', tooltip=self.tooltip)
for utility_state in self.utility_states:
if utilities_manager.is_utility_active(utility_state.utility) != utility_state.require_active:
return TestResult(False, 'UtilitiesTest: Utility status for the {} is not correct.', utility_state.utility, tooltip=self.tooltip)
return TestResult.TRUE
def _choose_world_from_candidates(self, candidate_world_ids):
if not candidate_world_ids:
return
population_counts = defaultdict(int)
for household in services.household_manager().values():
if household.home_zone_id != 0:
continue
population_counts[household.get_home_world_id()] += len(household)
target_counts = {}
for world_id in candidate_world_ids:
street = world.street.get_street_instance_from_world_id(world_id)
if street is None or street.townie_demographics.target_population is None:
target_counts[world_id] = 0
else:
target_counts[
world_id] = street.townie_demographics.target_population
worlds_that_met_target = []
worlds_below_target = []
for world_id in candidate_world_ids:
if population_counts[world_id] < target_counts[world_id]:
worlds_below_target.append(world_id)
else:
worlds_that_met_target.append(world_id)
if worlds_that_met_target and (len(worlds_that_met_target)
== len(candidate_world_ids)
or random.randint(0, 1) == 0):
worlds_that_met_target.sort(key=lambda world_id: population_counts[
world_id] - target_counts[world_id])
return worlds_that_met_target[0]
weighted_candidates = tuple(
(target_counts[world_id] - population_counts[world_id], world_id)
for world_id in worlds_below_target)
world_id = sims4.random.weighted_random_item(weighted_candidates)
return world_id
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 player_household_metrics(_connection=None):
output = sims4.commands.CheatOutput(_connection)
(active_sim_count, player_sim_count, played_sim_count) = (0, 0, 0)
(active_household_count, player_household_count,
played_household_count) = (0, 0, 0)
households = services.household_manager().get_all()
for household in households:
if household.is_active_household:
active_household_count += 1
active_sim_count += len(household)
if household.is_player_household:
player_household_count += 1
player_sim_count += len(household)
if household.is_played_household:
played_household_count += 1
played_sim_count += len(household)
for (name, value) in (('#sim_infos', len(services.sim_info_manager())),
('#active sim_infos', active_sim_count),
('#player sim_infos', player_sim_count),
('#played sim_infos',
played_sim_count), ('#households', len(households)),
('#active households', active_household_count),
('#player households',
player_household_count), ('#played households',
played_household_count)):
output('{:50} : {}'.format(name, value))
return True
def process_request_gen(self, timeline):
(household_population_data, neighborhood_proto) = self._get_region_household_population_data_and_neighborhood_proto()
if not (household_population_data or self._try_existing_households):
logger.debug('There is no HouseholdPopulationRegionData for region: {}', neighborhood_proto.region_id)
return
while self._num_to_fill > 0:
while self._available_zone_ids:
zone_id = self._available_zone_ids.pop(random.randint(0, len(self._available_zone_ids) - 1))
templates_and_bed_data = self._get_household_templates_and_bed_data(zone_id, household_population_data)
(household_templates, total_beds, lot_has_double_bed, lot_has_kid_bed) = templates_and_bed_data
if total_beds <= 0:
continue
moved_household_into_zone = False
if self._try_existing_households:
weighted_households = self._get_available_households(total_beds, lot_has_double_bed, lot_has_kid_bed)
if household_templates:
ideal_household_curve = NeighborhoodPopulationService.NUM_BEDS_TO_IDEAL_HOUSEHOLD_CURVE.get(total_beds, None)
if ideal_household_curve is not None:
ideal_household_weight = next(iter(sorted(ideal_household_curve.points, key=operator.itemgetter(1), reverse=True)))
weighted_households.append((ideal_household_weight[1], GENERATE_HOUSEHOLD_ID))
if weighted_households:
household_id = sims4.random.weighted_random_item(weighted_households)
if household_id != GENERATE_HOUSEHOLD_ID:
household = services.household_manager().get(household_id)
if household is not None:
self._move_household_into_zone(household, neighborhood_proto, zone_id)
moved_household_into_zone = True
if not moved_household_into_zone and household_templates:
moved_household_into_zone = self._add_household_template_to_zone(household_templates, total_beds, lot_has_double_bed, lot_has_kid_bed, neighborhood_proto, zone_id)
if moved_household_into_zone:
pass
yield element_utils.run_child(timeline, element_utils.sleep_until_next_tick_element())
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 _owning_sim_in_owning_household(self, sim_id):
owner_household_id = self.owner.get_household_owner_id()
if sim_id is None or owner_household_id is None:
return False
household = services.household_manager().get(owner_household_id)
if household is None:
return False
return household.sim_in_household(sim_id)
def get_target_household_id_for_zone(zone_id, account):
target_household_id = services.get_persistence_service(
).get_household_id_from_zone_id(zone_id)
if target_household_id is None or target_household_id == 0:
household = services.household_manager().create_household(
account, starting_funds=0)
target_household_id = household.id
return target_household_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
"""
try:
services.get_persistence_service().del_household_proto_buff(household.id)
services.household_manager().remove(household)
except Exception as ex:
CommonExceptionHandler.log_exception(ModInfo.get_identity(), 'Failed to delete household \'{}\'.'.format(pformat(household)), exception=ex)
return False
return True
def _owning_sim_in_owning_household(self, sim_id):
owner_household_id = self.owner.get_household_owner_id()
if sim_id is None or owner_household_id is None:
return False
household = services.household_manager().get(owner_household_id)
if household is None:
return False
return household.sim_in_household(sim_id)
def create_empty_household(starting_funds: int=0, as_hidden_household: bool=False) -> Household:
"""create_empty_household(starting_funds=0, as_hidden_household=False)
Create an empty household.
:param starting_funds: The funds the Household will start with.
:type starting_funds: int, optional
:param as_hidden_household: If True, the created household will be hidden.
:type as_hidden_household: bool, optional
:return: The created Household
:rtype: Household
"""
household = Household(SimSpawner._get_default_account(), starting_funds=starting_funds)
if as_hidden_household:
household.set_to_hidden()
services.household_manager().add(household)
return household
def move_object_to_household_inventory(
obj,
failure_flags=0,
object_location_type=ObjectOriginLocation.ON_LOT):
placement_flags = get_object_placement_flags(obj.definition.id)
if PlacementFlags.NON_INVENTORYABLE in placement_flags:
obj.destroy(
cause="Can't add non inventoriable objects to household inventory."
)
return False
else:
household_id = obj.get_household_owner_id()
active_household = services.active_household()
household = services.household_manager().get(household_id)
if household_id is None or household is None:
if failure_flags & HouseholdInventoryFlags.FORCE_OWNERSHIP:
household_id = active_household.id
household = active_household
obj.set_household_owner_id(household_id)
else:
if failure_flags & HouseholdInventoryFlags.DESTROY_OBJECT:
obj.destroy(
cause=
"Can't add unowned objects to household inventory.")
return False
return False
return False
obj.on_hovertip_requested()
obj.new_in_inventory = True
obj.remove_reference_from_parent()
stack_count = obj.stack_count()
obj.set_stack_count(1)
if is_household_inventory_available(household_id):
zone_id = services.current_zone_id()
try:
_buildbuy.add_object_to_household_inventory(
obj.id, household_id, zone_id, household.account.id,
object_location_type, stack_count)
except KeyError as e:
logger.error('Failed to add {} to {} inventory. Exception: {}',
obj,
household,
e,
owner='manus')
return False
else:
household_msg = services.get_persistence_service(
).get_household_proto_buff(household_id)
if household_msg is not None:
for i in range(stack_count):
object_data = obj.save_object(household_msg.inventory.objects)
if object_data is not None:
if i != 0:
object_data.id = id_generator.generate_object_id()
obj.destroy(cause='Add to household inventory')
else:
return False
return True
def c_api_house_inv_obj_added(zone_id, household_id, obj_id, obj_def_id):
with sims4.zone_utils.global_zone_lock(zone_id):
household = services.household_manager().get(household_id)
if household is None:
logger.error('Invalid Household id: {}', household_id)
return
collection_tracker = household.collection_tracker
collection_tracker.check_add_collection_item(household, obj_id,
obj_def_id)
def _send_money_update_internal(self, household_id, vfx_amount, reason=0):
op = distributor.ops.SetMoney(self.money, vfx_amount, reason)
household = services.household_manager().get(household_id)
if household is not None:
distributor.ops.record(household, op)
else:
logger.error('Failed to get household with id: {}',
household_id,
owner='tingyul')
def transfer_balance_to_household(self):
owner_household = services.household_manager().get(self._owner_household_id)
if owner_household is None:
return
sim = next(owner_household.instanced_sims_gen(allow_hidden_flags=ALL_HIDDEN_REASONS))
funds = self._funds.money
if funds > 0:
owner_household._funds.add(funds, Consts_pb2.FUNDS_RETAIL_PROFITS, sim)
self._funds.try_remove(funds, Consts_pb2.FUNDS_RETAIL_PROFITS, sim)
def trigger_invite_over_phone_call(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No sim for households.debug_trigger_invite_over_phone_call.', _connection)
return False
if not services.household_manager().debug_trigger_invite_over_phone_call(sim):
sims4.commands.output('households.debug_trigger_invite_over_phone_call failed to trigger phone call.', _connection)
return False
return True
def autopay_bills(enable: bool = None, _connection=None):
households = services.household_manager().get_all()
for household in households:
bills_manager = household.bills_manager
autopay_bills = enable if enable is not None else not bills_manager.autopay_bills
bills_manager.autopay_bills = autopay_bills
sims4.commands.output(
'Autopay Bills for household {} set to {}.'.format(
household, autopay_bills), _connection)
def c_api_house_inv_obj_added(zone_id, household_id, obj_id, obj_def_id):
with sims4.zone_utils.global_zone_lock(zone_id):
household = services.household_manager().get(household_id)
if household is None:
logger.error('Invalid Household id: {}', household_id)
return
collection_tracker = household.collection_tracker
collection_tracker.check_add_collection_item(household, obj_id,
obj_def_id)
def get_household_type(self):
household_id = self.id
if household_id in services.household_manager():
if not self.is_persistent_npc:
return HouseholdType.USER_CREATED_PLAYABLE
account = self.account
if account is not None:
household_id = self.id
if services.household_manager(
).is_household_stored_in_any_neighborhood_proto(household_id):
return HouseholdType.USER_CREATED_NPC
return HouseholdType.GAME_CREATED
logger.error(
"Tried to get the household type of a household that isn't in the household manager. household name: {} household id: {}",
self.name,
household_id,
owner='yshan')
return HouseholdType.UNKNOWN
def return_lost_objects(self):
returned_objects = defaultdict(list)
current_zone = services.current_zone()
current_zone_id = services.current_zone_id()
current_open_street_id = current_zone.open_street_id
active_household = services.active_household()
for locator in list(self._object_locators):
if locator.zone_id != current_zone_id:
if locator.open_street_id != current_open_street_id:
elapsed_time = services.time_service(
).sim_now - locator.time_stamp
if elapsed_time.in_minutes() < locator.time_before_lost:
continue
if locator.object_data is None:
self.remove_object(locator.object_id)
else:
(obj_returned,
owner) = self._return_lost_object(locator)
if obj_returned is not None:
if owner is not None:
if isinstance(owner, int):
if owner == active_household.id:
returned_objects[owner].append(
obj_returned)
if owner.household is active_household:
returned_objects[owner].append(
obj_returned)
elif owner.household is active_household:
returned_objects[owner].append(
obj_returned)
if not returned_objects:
return
returned_objects_string = None
household_manager = services.household_manager()
for (owner, objects) in returned_objects.items():
if isinstance(owner, int):
household = household_manager.get(owner)
header = ObjectLostAndFoundService.FAMILY_NAME_HEADER(
household.name)
next_string = LocalizationHelperTuning.get_bulleted_list(
header,
*(LocalizationHelperTuning.get_object_name(obj)
for obj in objects))
else:
next_string = LocalizationHelperTuning.get_bulleted_list(
LocalizationHelperTuning.get_sim_name(owner),
*(LocalizationHelperTuning.get_object_name(obj)
for obj in objects))
if returned_objects_string is None:
returned_objects_string = next_string
else:
returned_objects_string = LocalizationHelperTuning.NEW_LINE_LIST_STRUCTURE(
returned_objects_string, next_string)
dialog = ObjectLostAndFoundService.OBJECTS_RETURN_MESSAGE_DIALOG(
services.active_sim_info())
dialog.show_dialog(additional_tokens=(returned_objects_string, ))
def set_death_type(self, death_type):
self._sim_info.inject_into_inactive_zone(self.DEATH_ZONE_ID)
self._sim_info.household.remove_sim_info(self._sim_info, destroy_if_empty_gameplay_household=True)
household = services.household_manager().create_household(self._sim_info.account)
household.hidden = True
household.add_sim_info(self._sim_info)
self._sim_info.assign_to_household(household)
self._death_type = death_type
self._death_time = services.time_service().sim_now.absolute_ticks()
self._sim_info.resend_death_type()
def toggle_bill_notifications(enable:bool=None, _connection=None):
households = services.household_manager().get_all()
for household in households:
bills_manager = household.bills_manager
enable_notifications = enable if enable is not None else not bills_manager.bill_notifications_enabled
if enable_notifications:
bills_manager.bill_notifications_enabled = True
sims4.commands.output('Bill notifications for household {} enabled.'.format(household), _connection)
else:
bills_manager.bill_notifications_enabled = False
sims4.commands.output('Bill notifications for household {} disabled.'.format(household), _connection)
def make_bills_delinquent(_connection=None):
households = services.household_manager().get_all()
for household in households:
bills_manager = household.bills_manager
previous_send_notification = bills_manager.bill_notifications_enabled
bills_manager.bill_notifications_enabled = False
if bills_manager.current_payment_owed is None:
bills_manager._current_payment_owed = bills_manager.get_bill_amount()
for utility in Utilities:
bills_manager._shut_off_utility(utility)
bills_manager.bill_notifications_enabled = previous_send_notification
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._service_npc = None
self._service_start_time = None
reader = self._seed.custom_init_params_reader
self._service_npc_type = services.service_npc_manager().get(reader.read_uint64('service_npc_type_id', 0))
if self._service_npc_type is None:
raise ValueError('Invalid service npc type for situation: {}'.format(self))
self._hiring_household = services.household_manager().get(reader.read_uint64('household_id', 0))
if self._hiring_household is None:
raise ValueError('Invalid household for situation: {}'.format(self))
self._object_definition_to_craft = reader.read_uint64('user_specified_data_id', 0)
self._crafted_object_id = reader.read_uint64('crafted_object_id', 0)
def on_enter(self):
super().on_enter()
services.household_manager().load_households()
zone = services.current_zone()
zone_spin_up_service = zone.zone_spin_up_service
household_id = zone_spin_up_service._client_connect_data.household_id
household = zone.household_manager.get(household_id)
client = zone_spin_up_service._client_connect_data.client
services.account_service().on_load_options(client)
for sim_info in household.sim_info_gen():
client.add_selectable_sim_info(sim_info,
send_relationship_update=False)
zone.on_households_and_sim_infos_loaded()
zone.service_manager.on_all_households_and_sim_infos_loaded(client)
services.ui_dialog_service().send_dialog_options_to_client()
client.clean_and_send_remaining_relationship_info()
services.current_zone().lot.send_lot_display_info()
for obj in itertools.chain(services.object_manager().values(),
services.inventory_manager().values()):
while obj.live_drag_component is not None:
obj.live_drag_component.set_active_household_live_drag_permission(
)
return _ZoneSpinUpStateResult.DONE
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
reader = self._seed.custom_init_params_reader
self._service_npc_type = services.service_npc_manager().get(reader.read_uint64('service_npc_type_id', 0))
if self._service_npc_type is None:
raise ValueError('Invalid service npc type for situation: {}'.format(self))
self._hiring_household = services.household_manager().get(reader.read_uint64('household_id', 0))
if self._hiring_household is None:
raise ValueError('Invalid household for situation: {}'.format(self))
self._is_recurring = reader.read_bool('is_recurring', False)
self._object_definition_to_craft = reader.read_uint64('user_specified_data_id', 0)
self._crafted_object_id = reader.read_uint64('crafted_object_id', 0)
self._service_start_time = services.time_service().sim_now
self._had_preroll_work = True
self._is_leaving = False
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 modify_household_funds(amount, household_id:int=0, reason=None, _connection=None):
if reason is None:
reason = Consts_pb2.TELEMETRY_MONEY_CHEAT
if household_id == 0:
tgt_client = services.client_manager().get(_connection)
household = tgt_client.household
else:
household = services.household_manager().get(household_id)
if household is not None:
if amount > 0:
household.funds.add(amount, reason, None)
else:
household.funds.remove(-amount, reason, None)
else:
sims4.commands.output('Invalid Household id: {}'.format(household_id), _connection)
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
def make_bill_source_delinquent(additional_bill_source_name='Miscellaneous', _connection=None):
try:
additional_bill_source = AdditionalBillSource(additional_bill_source_name)
except:
sims4.commands.output('{0} is not a valid AdditionalBillSource.'.format(additional_bill_source_name), _connection)
return False
if additional_bill_source is not None:
households = services.household_manager().get_all()
for household in households:
bills_manager = household.bills_manager
bills_manager.add_additional_bill_cost(additional_bill_source, 1)
if bills_manager.current_payment_owed is None:
bills_manager._current_payment_owed = bills_manager.get_bill_amount()
previous_send_notification = bills_manager.bill_notifications_enabled
bills_manager.bill_notifications_enabled = False
bills_manager._shut_off_utility(Utilities.POWER)
bills_manager.bill_notifications_enabled = previous_send_notification
def move_object_to_household_inventory(
obj, object_location_type=ObjectOriginLocation.ON_LOT):
household_id = obj.get_household_owner_id()
if household_id is None:
logger.error(
'This object {} is not owned by any household. Request to move to household inventory will be ignored.',
obj,
owner='mduke')
return
household = services.household_manager().get(household_id)
obj.new_in_inventory = True
obj.remove_reference_from_parent()
stack_count = obj.stack_count()
obj.set_stack_count(1)
_buildbuy.add_object_to_household_inventory(
obj.id, household_id, zone_utils.get_zone_id(), household.account.id,
object_location_type, stack_count)
def c_api_modify_household_funds(amount, household_id, reason, zone_id):
with sims4.zone_utils.global_zone_lock(zone_id):
household_manager = services.household_manager()
household = household_manager.get(household_id)
if household is None:
if household_manager.try_add_pending_household_funds(
household_id, amount, reason):
return True
logger.error(
'Invalid Household id {} when attempting to modify household funds.',
household_id)
return False
if amount > 0:
household.funds.add(amount, reason, None, count_as_earnings=False)
elif amount < 0:
household.funds.remove(-amount, reason, None)
return True
def list_households(household_id:int=None, _connection=None):
household_manager = services.household_manager()
output = sims4.commands.Output(_connection)
output('Household report:')
if household_id is not None:
households = (household_manager.get(household_id),)
else:
households = household_manager.get_all()
for household in households:
output('{}, {} Sims'.format(str(household), len(household)))
for sim_info in household.sim_info_gen():
if sim_info.is_instanced(allow_hidden_flags=0):
output(' Instanced: {}'.format(sim_info))
elif sim_info.is_instanced(allow_hidden_flags=ALL_HIDDEN_REASONS):
output(' Hidden: {}'.format(sim_info))
else:
output(' Off lot: {}'.format(sim_info))
def _get_available_households(self, total_beds, lot_has_double_beds, lot_has_kid_beds):
household_manager = services.household_manager()
weighted_households = []
for household in tuple(household_manager.values()):
if not household.is_persistent_npc:
pass
if household.home_zone_id:
pass
num_sims = len(household)
if not num_sims:
pass
nums_sims_to_weight_bonus = NeighborhoodPopulationService.NUM_BEDS_TO_IDEAL_HOUSEHOLD_CURVE.get(total_beds)
if nums_sims_to_weight_bonus is not None:
weight = nums_sims_to_weight_bonus.get(num_sims)
else:
weight = 1
if weight <= 0:
pass
household_has_married_sims = False
household_has_kids = False
total_household_relationship_weight = 0
sim_info_manager = services.sim_info_manager()
for sim_info in household:
if lot_has_double_beds:
spouse_sim_id = sim_info.spouse_sim_id
if not spouse_sim_id and household.get_sim_info_by_id(spouse_sim_id):
household_has_married_sims = True
if lot_has_kid_beds and sim_info.age <= Age.TEEN:
household_has_kids = True
total_sim_info_weight = 0
for relationship in sim_info.relationship_tracker:
target_sim_info = sim_info_manager.get(relationship.target_sim_id)
while target_sim_info is not None and target_sim_info.household is not None and not target_sim_info.household.is_persistent_npc:
total_sim_info_weight = relationship.depth*self.RELATIONSHIP_DEPTH_WEIGHT
total_sim_info_weight += len(relationship.bit_track_tracker)*self.RELATIONSHIP_TRACK_MULTIPLIER
total_household_relationship_weight += total_sim_info_weight
total_household_relationship_weight /= num_sims
if self.RELATIONSHIP_UTILITY_CURVE is not None:
weight *= self.RELATIONSHIP_UTILITY_CURVE.get(total_household_relationship_weight)
if household_has_kids:
weight *= NeighborhoodPopulationService.KID_TO_KID_BED_MULTIPLIER
if household_has_married_sims:
weight *= NeighborhoodPopulationService.SIGNIFICANT_OTHER_MULTIPLIER
weighted_households.append((weight, household.id))
return weighted_households
def __call__(self, sims=None, amount=None, skill_used=None, tags=None):
if amount is None:
return TestResultNumeric(False, 'SimoleonsEarnedTest: amount is none, valid during zone load.', current_value=0, goal_value=self.threshold.value, is_money=True)
if not self.threshold.compare(amount):
return TestResultNumeric(False, 'SimoleonsEarnedTest: not enough Simoleons earned.', current_value=amount, goal_value=self.threshold.value, is_money=True)
if not (self.event_type_to_test is not None and self.event_type_to_test(skill_used, tags)):
return TestResult(False, '\n SimoleonsEarnedTest: the skill used to earn Simoleons does\n not match the desired skill or tuned tags do not match\n object tags.\n ')
if self.household_fund_threshold is not None:
for sim_info in sims:
household = services.household_manager().get_by_sim_id(sim_info.sim_id)
if household is None:
return TestResult(False, "Couldn't find household for sim {}", sim_info)
household_funds = household.funds.money
if self.household_fund_threshold.test_before_earnings:
household_funds -= amount
while not self.household_fund_threshold.threshold.compare(household_funds):
return TestResult(False, 'Threshold test on household funds failed for sim {}', sim_info)
return TestResult.TRUE
def request_service(service_npc_type, household_id=None, _connection=None):
service_npc_tuning = services.service_npc_manager().get(service_npc_type)
if service_npc_tuning is not None:
tgt_client = services.client_manager().get(_connection)
if tgt_client is None:
return False
if household_id is None:
household = tgt_client.household
else:
household_id = int(household_id)
manager = services.household_manager()
household = manager.get(household_id)
if household is None:
household = tgt_client.household
services.current_zone().service_npc_service.request_service(household, service_npc_tuning)
sims4.commands.output('Requesting service {0}'.format(service_npc_type), _connection)
return True
return False
def on_spawn_sims_for_zone_spin_up(self, client):
current_zone = services.current_zone()
for sim_id in tuple(self._sims_traveled_to_zone):
if sim_id == 0:
self._sims_traveled_to_zone.remove(sim_id)
sim_info = self.get(sim_id)
if sim_info is None:
logger.error('sim id {} for traveling did not spawn because sim info does not exist.', sim_id, owner='msantander')
self._spawn_sim(sim_info, startup_location=None)
while sim_info.get_current_outfit()[0] == OutfitCategory.SLEEP:
random_everyday_outfit = sim_info.sim_outfits.get_random_outfit([OutfitCategory.EVERYDAY])
sim_info.set_current_outfit(random_everyday_outfit)
if self._sims_traveled_to_zone:
play_tunable_audio(TravelTuning.TRAVEL_SUCCESS_AUDIO_STING)
else:
play_tunable_audio(TravelTuning.NEW_GAME_AUDIO_STING)
current_zone_owner_household_id = current_zone.lot.owner_household_id
if current_zone_owner_household_id != 0:
zone_owner_household = services.household_manager().get(current_zone_owner_household_id)
if zone_owner_household is not None:
zone_household_is_active_household = client.household.id == zone_owner_household.id
any_members_spawned = self._spawn_lot_owner_household(zone_owner_household, zone_household_is_active_household)
if zone_household_is_active_household and not any_members_spawned:
self._clear_return_sim_to_home_lot_alarm_handles()
while True:
for sim_info in zone_owner_household.sim_info_gen():
while not sim_info.is_dead:
logger.debug('Force spawn household sim:{}', sim_info, owner='sscholl')
self._spawn_sim(sim_info, startup_location=None)
for sim_info in self._sim_infos_saved_in_zone:
result = self._should_spawn_zone_saved_sim(sim_info)
logger.debug('Should spawn zone sim:{} {}', sim_info, bool(result), owner='sscholl')
while result:
self._spawn_sim(sim_info, startup_location=result.startup_location)
for sim_info in self._sim_infos_saved_in_open_street:
result = self._should_spawn_open_street_saved_sim(sim_info)
logger.debug('Should spawn open street sim:{} {}', sim_info, bool(result), owner='sscholl')
while result:
self._spawn_sim(sim_info, startup_location=result.startup_location)
if len(self._sims_traveled_to_zone) > 0 and (client.household is not None and client.household.get_sim_info_by_id(sim_info.sim_id)) and sim_info.sim_id not in self._sims_traveled_to_zone:
self._sim_ids_to_push_go_home.append(sim_info.sim_id)
self._on_spawn_sim_for_zone_spin_up_completed(client)
def _try_to_be_invited_in(self):
owner_household = services.household_manager().get(services.current_zone().lot.owner_household_id)
resolver = self.get_resolver()
if owner_household is None:
dialog = self._nobody_home_failure_notification(self.sim, resolver)
dialog.show_dialog()
return
owner_household_sims = tuple(owner_household.instanced_sims_gen())
if not owner_household_sims:
dialog = self._nobody_home_failure_notification(self.sim, resolver)
dialog.show_dialog()
return
for target_sim in owner_household_sims:
relationship_resolver = DoubleSimResolver(self.sim.sim_info, target_sim.sim_info)
while relationship_resolver(self._relationship_test):
dialog = self._success_notification(self.sim, resolver)
dialog.show_dialog()
services.get_zone_situation_manager().make_waiting_player_greeted(self.sim)
return
dialog = self._bad_relationship_failure_notification(self.sim, resolver)
dialog.show_dialog()
def pay_bills(_connection=None):
households = services.household_manager().get_all()
for household in households:
bills_manager = household.bills_manager
bills_manager.pay_bill()
def open_reward(self, sim_info, _):
household = services.household_manager().get(sim_info.household_id)
if household is not None:
household.funds.add(self._money, Consts_pb2.TELEMETRY_MONEY_ASPIRATION_REWARD, sim_info.get_sim_instance())
