def test(cls, inst, *args, target=DEFAULT, context=None, **kwargs) -> TestResult: # pylint: disable=no-self-argument
try:
inst_or_cls = inst if inst is not None else cls
selection_group = SelectionGroupService.get(services.active_household_id())
Logger.log("testing SimHouseholdNpcOffInteraction, context: {} {}"
.format(args, kwargs))
if target:
info_target = target.sim_info
if context.target_sim_id is not None:
target_id = context.target_sim_id
info_target = services.sim_info_manager().get(target_id)
Logger.log('info_target: {}'.format(info_target))
if not selection_group.is_household_npc(info_target):
return TestResult(False, "sim is not a household npc", inst)
if info_target.household_id != services.active_household_id():
return TestResult(False, "sim is not a member of the active household", inst)
return (super(SimHouseholdNpcOffInteraction, inst_or_cls)
.test(*args, target=target, context=context, **kwargs))
except BaseException:
Logger.log(traceback.format_exc())
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 tn_sim_info_is_npc(_original, self):
if services.active_sim_info() == self:
return False
if services.active_household_id() == self.household_id:
selection_group = SelectionGroupService.get(
services.active_household_id(), True)
if not selection_group:
return False
return selection_group.is_household_npc(self)
return True
def resolve_live_drag_household_permission(self):
owning_household_id = self.owner.get_household_owner_id()
active_household_id = services.active_household_id()
if active_household_id is not None and owning_household_id is not None and owning_household_id != active_household_id:
self.update_permission(LiveDragPermission.HOUSEHOLD, False)
else:
self.update_permission(LiveDragPermission.HOUSEHOLD, True)
def on_enter(self):
super().on_enter()
services.current_zone().lot.publish_shared_inventory_items()
active_household_id = services.active_household_id()
for script_object in services.object_manager().get_all():
script_object.finalize(active_household_id=active_household_id)
return _ZoneSpinUpStateResult.DONE
def get_sims_for_job(session_id, sim_id, situation_type, job_type, *job_assignments, _connection=None):
sim = get_optional_target(sim_id, _connection)
situation_start_time = services.time_service().sim_now
duration = situation_type.duration
if duration > 0:
situation_end_time = situation_start_time + date_and_time.create_time_span(0, 0, duration)
else:
situation_start_time = date_and_time.INVALID_DATE_AND_TIME
situation_end_time = date_and_time.INVALID_DATE_AND_TIME
results = services.sim_filter_service().submit_filter(job_type.filter, None, requesting_sim_info=sim.sim_info, start_time=situation_start_time, end_time=situation_end_time, allow_yielding=False)
if job_type.additional_filter_for_user_selection:
sim_constraints = {result.sim_info.id for result in results}
results = services.sim_filter_service().submit_filter(job_type.additional_filter_for_user_selection, None, requesting_sim_info=sim.sim_info, start_time=situation_start_time, end_time=situation_end_time, sim_constraints=sim_constraints, allow_yielding=False)
msg = Situations_pb2.SituationJobSims()
msg.situation_session_id = session_id
msg.job_resource_id = job_type.guid
msg.requirements = job_type.requirement_text
results.sort(key=lambda x: (x.sim_info.is_npc, x.sim_info.last_name))
for result in results:
msg.sim_ids.append(result.sim_info.id)
with ProtocolBufferRollback(msg.sims) as situation_job_sim:
situation_job_sim.sim_id = result.sim_info.id
if result.sim_info.household.id == services.active_household_id():
situation_job_sim.account_id = result.sim_info.account_id
while result.conflicting_career_track_id:
situation_job_sim.career_track_id = result.conflicting_career_track_id
shared_messages.add_message_if_selectable(services.object_manager().get(sim.id), Consts_pb2.MSG_SITUATION_JOB_SIMS, msg, True)
def _off_lot_churn_callback(self, alarm_handle):
trackers = self.get_business_trackers_for_household(
services.active_household_id())
if not trackers:
return
for tracker in trackers:
tracker.run_off_lot_simulation()
def purchase_to_inventory(inventory_obj,
def_id: str = None,
mailman_purchase: bool = False,
_connection=None):
definition_manager = services.definition_manager()
definition = definition_manager.get(def_id)
if definition is None:
return False
client = services.client_manager().get(_connection)
if client is None:
return False
household = client.household
price = definition.price
if household.funds.money < price:
return False
if mailman_purchase:
obj = services.active_lot().create_object_in_hidden_inventory(
definition)
else:
inventory = inventory_obj.get_target().inventory_component
if inventory is None:
return False
obj = create_object(definition)
if obj is None:
return False
if not inventory.player_try_add_object(obj):
obj.destroy(source=inventory,
cause='Failed to purchase object into inventory')
return False
obj.set_household_owner_id(household.id)
obj.try_post_bb_fixup(force_fixup=True,
active_household_id=services.active_household_id())
household.funds.remove(price, Consts_pb2.TELEMETRY_OBJECT_BUY)
return True
def purchase_to_inventory(inventory_obj, def_id:str=None, mailman_purchase:bool=False, _connection=None):
definition_manager = services.definition_manager()
definition = definition_manager.get(def_id)
if definition is None:
return False
client = services.client_manager().get(_connection)
if client is None:
return False
household = client.household
price = definition.price
if household.funds.money < price:
return False
if mailman_purchase:
obj = services.active_lot().create_object_in_hidden_inventory(definition)
else:
inventory = inventory_obj.get_target().inventory_component
if inventory is None:
return False
obj = create_object(definition)
if obj is None:
return False
if not inventory.player_try_add_object(obj):
obj.destroy(source=inventory, cause='Failed to purchase object into inventory')
return False
obj.set_household_owner_id(household.id)
obj.try_post_bb_fixup(force_fixup=True, active_household_id=services.active_household_id())
household.funds.remove(price, Consts_pb2.TELEMETRY_OBJECT_BUY)
return True
def should_close_after_load(self):
current_zone = services.current_zone()
if current_zone.active_household_changed_between_save_and_load() and services.active_household_id() == self._owner_household_id:
return True
if current_zone.id == self._zone_id:
return self.should_automatically_close() and current_zone.time_has_passed_in_world_since_zone_save()
return self.should_automatically_close()
def on_enter(self):
super().on_enter()
services.current_zone().lot.publish_shared_inventory_items()
active_household_id = services.active_household_id()
for script_object in services.object_manager().get_all():
script_object.finalize(active_household_id=active_household_id)
return _ZoneSpinUpStateResult.DONE
def _get_role_state_overrides(self, sim, job_type, role_state_type,
role_affordance_target):
target = self.owner.get_created_object()
if target is None:
if self._chosen_recipe is not None:
target = DebugCreateCraftableInteraction.create_craftable(
self._chosen_recipe,
sim,
owning_household_id_override=services.active_household_id(
),
place_in_crafter_inventory=True)
if target is None:
raise ValueError(
'No craftable created for {} on {}'.format(
self._chosen_recipe, self))
elif self._chosen_object is not None:
target = self.owner._create_object_for_situation(
sim, self._chosen_object)
if target is None:
raise ValueError('No object created for {} on {}'.format(
self._chosen_object, self))
else:
raise ValueError(
'No valid object to create for {}'.format(self))
self.owner._created_object_id = target.id
if target is not None:
target.transient = True
return (role_state_type, target)
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 _get_role_state_overrides(self, sim, job_type, role_state_type,
role_affordance_target):
if job_type is not self.owner._fruitcake_bearer_situation_job:
return super()._get_role_state_overrides(sim, job_type,
role_state_type,
role_affordance_target)
if self.owner._fruitcake_id is not None:
target = services.current_zone().inventory_manager.get(
self.owner._fruitcake_id)
else:
bearer_recipe = random.choice(self.owner._bearer_recipes)
if bearer_recipe is None:
logger.error(
'No recipes tuned for the fruitcake-bearer. Recipe creation failed for {} situation',
self,
owner='shipark')
return (role_state_type, None)
target = DebugCreateCraftableInteraction.create_craftable(
bearer_recipe,
sim,
owning_household_id_override=services.active_household_id(),
place_in_crafter_inventory=True)
if target is None:
raise ValueError('No craftable created for {} on {}'.format(
self.owner._fruitcake_recipe, self))
self.owner._fruitcake_id = target.id
return (role_state_type, target)
def _should_create_object(self, definition_id):
if self.owner.household.id == services.active_household_id():
return True
elif InventoryItemComponent.should_item_be_removed_from_inventory(
definition_id):
return False
return True
def on_choice_selected(self, choice_tag, **kwargs):
mother = choice_tag
if mother is None:
return
father = self.target
transferable_states = {}
for state in self._combine_data.states_to_combine:
mother_state = mother.get_state(state)
father_state = father.get_state(state)
transferable_states[state] = [mother_state, father_state]
for combine_data in self._combine_data.combination_mapping:
if combine_data.father_state == father_state and combine_data.mother_state == mother_state:
transferable_states[state].append(
combine_data.resulting_state)
if not transferable_states:
logger.error(
'CollectionPickerInteraction: {} and {} collectibles have no transferable states',
mother,
father,
owner='camilogarcia')
return
states_to_transfer = []
for states in transferable_states.values():
states_to_transfer.append(sims4.random.random.choice(states))
target_match = len(states_to_transfer)
possible_outcomes = []
for collectable in self._collectible_data:
match = 0
for target_states in collectable.collectable_item.cls._components.state._tuned_values.states:
if target_states.default_value in states_to_transfer:
match += 1
if match == target_match:
possible_outcomes.append(collectable.collectable_item)
if not possible_outcomes:
logger.error(
'CollectionPickerInteraction: No possible result when combining {} and {}',
mother,
father,
owner='camilogarcia')
return
definition_to_create = sims4.random.random.choice(possible_outcomes)
obj = create_object(definition_to_create)
if obj is None:
logger.error(
'CollectionPickerInteraction: Failed to create object when combining {} and {}',
mother,
father,
owner='camilogarcia')
return
obj.update_ownership(self.sim.sim_info)
if not self.sim.inventory_component.player_try_add_object(obj):
obj.set_household_owner_id(services.active_household_id())
if not build_buy.move_object_to_household_inventory(
obj,
object_location_type=ObjectOriginLocation.SIM_INVENTORY):
logger.error(
'CollectionPickerInteraction: Failed to add object {} to household inventory.',
obj,
owner='rmccord')
self._push_continuation(obj)
def _run_interaction_gen(self, timeline):
Logger.log("running make selectable interaction...")
try:
super()._run_interaction_gen(timeline)
sim_info = self.target.sim_info
if self.context.target_sim_id is not None:
sim_info = (services.sim_info_manager()
.get(self.context.target_sim_id))
Logger.log("got sim info {} {}"
.format(sim_info.first_name, sim_info.last_name))
SelectionGroupService \
.get(services.active_household_id()) \
.make_sim_selectable(sim_info)
Logger.log("sim is now selectable!")
services.get_first_client().set_active_sim_by_id(sim_info.id)
Logger.log("sim is now active!")
return True
except BaseException:
Logger.log(traceback.format_exc())
def set_active_sim(first_name='', last_name='', _connection=None):
output = commands.CheatOutput(_connection)
try:
if _connection is None:
output('SetActiveSim; Status:ParamError')
return False
tgt_client = services.client_manager().get(_connection)
if tgt_client is None:
output('SetActiveSim; Status:ClientError no client')
return False
sim_info = (services.sim_info_manager().get_sim_info_by_name(
first_name, last_name))
if sim_info is None:
output('SetActiveSim; Status:SimError no sim with this name found')
return False
SelectionGroupService \
.get(services.active_household_id()) \
.make_sim_selectable(sim_info)
if tgt_client.set_active_sim_by_id(sim_info.id):
output('SetActiveSim; Status:Success')
return True
output('SetActiveSim; Status:NoChange')
return True
except BaseException as exception:
output('Error: {}'.format(exception))
Logger.log(traceback.format_exc())
def on_exit(self):
active_household_id = services.active_household_id()
sim_info_manager = services.sim_info_manager()
for script_object in sim_info_manager.instanced_sims_gen(
allow_hidden_flags=ALL_HIDDEN_REASONS):
script_object.finalize(active_household_id=active_household_id)
super().on_exit()
def transfer_entire_inventory(source, recipient):
if source is None or recipient is None:
raise ValueError('Attempt to transfer items from {} to {}.'.format(source, recipient))
lot = services.active_lot()
if isinstance(source, InventoryType):
source_inventory = lot.get_object_inventory(source)
else:
source_inventory = source.inventory_component
if source_inventory is None:
raise ValueError('Failed to find inventory component for source of inventory transfer: {}'.format(source))
recipient_is_inventory_type = isinstance(recipient, InventoryType)
if recipient_is_inventory_type:
recipient_inventory = lot.get_object_inventory(recipient)
else:
recipient_inventory = recipient.inventory_component
if recipient_inventory is None:
raise ValueError('Attempt to transfer items to an object that has no inventory component: {}'.format(recipient))
for obj in list(source_inventory):
if not source_inventory.try_remove_object_by_id(obj.id, force_remove_stack=True):
logger.warn('Failed to remove object {} from {} inventory', obj, source)
if recipient_inventory.can_add(obj):
if not recipient_is_inventory_type and recipient.is_sim:
obj.update_ownership(recipient)
recipient_inventory.system_add_object(obj, None if recipient_is_inventory_type else recipient)
else:
obj.set_household_owner_id(services.active_household_id())
build_buy.move_object_to_household_inventory(obj, object_location_type=ObjectOriginLocation.SIM_INVENTORY)
def update_household_objects_ownership(self):
zone_data_proto = self._get_zone_proto()
if zone_data_proto is None:
return
venue_instance = self.venue_service.venue
if venue_instance is None or not venue_instance.venue_requires_front_door:
return
if self.lot.owner_household_id == 0:
self._set_zone_objects_household_owner_id(None)
elif self.lot.owner_household_id == services.active_household_id():
gameplay_zone_data = zone_data_proto.gameplay_zone_data
if not protocol_buffer_utils.has_field(
gameplay_zone_data,
'active_household_id_on_save') or gameplay_zone_data.lot_owner_household_id_on_save != services.active_household_id(
):
self._set_zone_objects_household_owner_id(
services.active_household_id())
def tn_sim_info_is_selected(_original, self):
active_household_id = services.active_household_id()
client = (services.client_manager().get_client_by_household_id(
active_household_id))
if client is not None:
return self is client.active_sim
return False
def _apply_ownership(self, mailbox, household_id):
mailbox.set_household_owner_id(household_id)
for tuning in self.OWNER_STATES:
if mailbox.definition in tuning.definitions:
owner_state_value = tuning.active_state_value if household_id == services.active_household_id(
) else tuning.default_state_value
mailbox.set_state(owner_state_value.state,
owner_state_value,
immediate=True)
def _setup_created_object(self, created_object):
if self.aggregate_object_owner & AggregateObjectOwnership.SAME_AS_TARGET:
if self.target is not None:
created_object.set_household_owner_id(
self.target.get_household_owner_id())
elif self.aggregate_object_owner & AggregateObjectOwnership.ACTIVE_HOUSEHOLD:
active_household_id = services.active_household_id()
if active_household_id is not None:
created_object.set_household_owner_id(active_household_id)
def load_data(self, household_msg):
self._collections.clear()
if self.owner.all_sims_skip_load():
return
msg_type = UI_pb2.CollectibleItemUpdate.TYPE_DISCOVERY
active_household_id = services.active_household_id()
for collection in household_msg.gameplay_data.collection_data:
self._collections[collection.collectible_def_id] = collection.collection_id
while active_household_id == household_msg.household_id:
self.send_collection_msg(msg_type, collection.collection_id, household_msg.household_id, collection.collectible_def_id)
def set_active_household_live_drag_permission(self):
owning_household_id = self.owner.get_household_owner_id()
active_household_id = services.active_household_id()
if active_household_id is not None and owning_household_id is not None and owning_household_id != active_household_id:
self._household_permission = False
else:
self._household_permission = True
if self.can_live_drag and not self._household_permission:
self.set_can_live_drag(False)
return self._household_permission
def print_item_counts(self):
active_sim_info = services.active_sim_info()
self._show_dialog(
"Items in {} {}'s inventory: {}\n"
"Items in household inventory: {}".format(
active_sim_info.first_name, active_sim_info.last_name,
len(services.get_active_sim().inventory_component),
len(
build_buy.get_object_ids_in_household_inventory(
services.active_household_id()))))
def _add_expenditures_and_do_post_bb_fixup(self):
if self.objects_to_fixup_post_bb is not None:
household = self.lot.get_household()
rebate_manager = household.rebate_manager if household is not None else None
active_household_id = services.active_household_id()
for obj in self.objects_to_fixup_post_bb:
if rebate_manager is not None:
rebate_manager.add_rebate_for_object(obj)
obj.try_post_bb_fixup(active_household_id=active_household_id)
self.objects_to_fixup_post_bb = None
def active_household_changed_between_save_and_load(self):
zone_data_proto = self._get_zone_proto()
if zone_data_proto is None:
return False
gameplay_zone_data = zone_data_proto.gameplay_zone_data
if not protocol_buffer_utils.has_field(gameplay_zone_data,
'active_household_id_on_save'):
return False
return gameplay_zone_data.active_household_id_on_save != services.active_household_id(
)
def _on_save_items(self, object_list):
if self._shelved_objects is None:
return
if not self.owner.is_player_sim:
return
if self.owner.household.id == services.active_household_id():
return
logger.info('Merging Inventory {} (size: {}) with saved inventory {}.',
self, len(self), self.get_shelved_object_count())
for shelved_obj in self._shelved_objects.objects:
object_list.objects.append(shelved_obj)
def canys_sim_info_is_enabled_in_skewer(original, self):
try:
selection_group = SelectionGroupService.get(
services.active_household_id(), True)
if selection_group and selection_group.is_household_npc(self):
return False
return original(self)
except BaseException:
Logger.log(traceback.format_exc())
return True
def load_data(self, household_msg):
self._collections.clear()
if self.owner.all_sims_skip_load():
return
msg_type = UI_pb2.CollectibleItemUpdate.TYPE_DISCOVERY
active_household_id = services.active_household_id()
for collection in household_msg.gameplay_data.collection_data:
self._collections[
collection.collectible_def_id] = collection.collection_id
while active_household_id == household_msg.household_id:
self.send_collection_msg(msg_type, collection.collection_id,
household_msg.household_id,
collection.collectible_def_id)
def _fill_and_send_save_game_protobufs_gen(self, timeline, slot_id, slot_name, auto_save_slot_id=None):
self.save_error_code = persistence_error_types.ErrorCodes.SETTING_SAVE_SLOT_DATA_FAILED
save_slot_data_msg = self.get_save_slot_proto_buff()
save_slot_data_msg.slot_id = slot_id
save_slot_data_msg.slot_name = slot_name
if services.active_household_id() is not None:
save_slot_data_msg.active_household_id = services.active_household_id()
sims4.core_services.service_manager.save_all_services(self, persistence_error_types.ErrorCodes.CORE_SERICES_SAVE_FAILED, save_slot_data=save_slot_data_msg)
self.save_error_code = persistence_error_types.ErrorCodes.SAVE_CAMERA_DATA_FAILED
camera.serialize(save_slot_data=save_slot_data_msg)
def on_save_complete(slot_id, success):
wakeable_element.trigger_soft_stop()
self.save_error_code = persistence_error_types.ErrorCodes.SAVE_TO_SLOT_FAILED
wakeable_element = element_utils.soft_sleep_forever()
persistence_module.run_persistence_operation(persistence_module.PersistenceOpType.kPersistenceOpSave, self._save_game_data_proto, slot_id, on_save_complete)
yield element_utils.run_child(timeline, wakeable_element)
if auto_save_slot_id is not None:
self.save_error_code = persistence_error_types.ErrorCodes.AUTOSAVE_TO_SLOT_FAILED
wakeable_element = element_utils.soft_sleep_forever()
persistence_module.run_persistence_operation(persistence_module.PersistenceOpType.kPersistenceOpSave, self._save_game_data_proto, auto_save_slot_id, on_save_complete)
yield element_utils.run_child(timeline, wakeable_element)
self.save_error_code = persistence_error_types.ErrorCodes.NO_ERROR
def get_sims_for_job(session_id,
sim_id,
situation_type,
job_type,
*job_assignments,
_connection=None):
sim = get_optional_target(sim_id, _connection)
situation_start_time = services.time_service().sim_now
duration = situation_type.duration
if duration > 0:
situation_end_time = situation_start_time + date_and_time.create_time_span(
0, 0, duration)
else:
situation_start_time = date_and_time.INVALID_DATE_AND_TIME
situation_end_time = date_and_time.INVALID_DATE_AND_TIME
results = services.sim_filter_service().submit_filter(
job_type.filter,
None,
requesting_sim_info=sim.sim_info,
start_time=situation_start_time,
end_time=situation_end_time,
allow_yielding=False)
if job_type.additional_filter_for_user_selection:
sim_constraints = {result.sim_info.id for result in results}
results = services.sim_filter_service().submit_filter(
job_type.additional_filter_for_user_selection,
None,
requesting_sim_info=sim.sim_info,
start_time=situation_start_time,
end_time=situation_end_time,
sim_constraints=sim_constraints,
allow_yielding=False)
msg = Situations_pb2.SituationJobSims()
msg.situation_session_id = session_id
msg.job_resource_id = job_type.guid
msg.requirements = job_type.requirement_text
results.sort(key=lambda x: (x.sim_info.is_npc, x.sim_info.last_name))
for result in results:
msg.sim_ids.append(result.sim_info.id)
with ProtocolBufferRollback(msg.sims) as situation_job_sim:
situation_job_sim.sim_id = result.sim_info.id
if result.sim_info.household.id == services.active_household_id():
situation_job_sim.account_id = result.sim_info.account_id
while result.conflicting_career_track_id:
situation_job_sim.career_track_id = result.conflicting_career_track_id
shared_messages.add_message_if_selectable(
services.object_manager().get(sim.id),
Consts_pb2.MSG_SITUATION_JOB_SIMS, msg, True)
def tn_zone_director_residential_base_is_any_sim_always_greeted(
original, self):
active_lot_household = services.current_zone(
).get_active_lot_owner_household()
selection_group = SelectionGroupService.get(services.active_household_id())
if active_lot_household is None:
return original(self)
for sim_info in active_lot_household.sim_infos:
if sim_info.id not in selection_group.selectable_sims:
continue
return True
return original(self)
def purchase_picker_response(inventory_target, mailman_purchase:bool=False, *def_ids_and_amounts, _connection=None):
total_price = 0
current_purchased = 0
objects_to_buy = []
definition_manager = services.definition_manager()
for (def_id, amount) in zip(def_ids_and_amounts[::2], def_ids_and_amounts[1::2]):
definition = definition_manager.get(def_id)
if definition is None:
sims4.commands.output('inventory.purchase_picker_response: Definition not found with id {}'.format(def_id), _connection)
return False
purchase_price = definition.price*amount
total_price += purchase_price
objects_to_buy.append((definition, amount))
client = services.client_manager().get(_connection)
if client is None:
sims4.commands.output('inventory.purchase_picker_response: No client found to make purchase.', _connection)
return False
household = client.household
if household.funds.money < total_price:
sims4.commands.output('inventory.purchase_picker_response: Insufficient funds for household to purchase items.', _connection)
return False
if mailman_purchase:
inventory = services.active_lot().get_hidden_inventory()
else:
inventory_owner = inventory_target.get_target()
inventory = inventory_owner.inventory_component
if inventory is None:
sims4.commands.output('inventory.purchase_picker_response: Inventory not found for items to be purchased into.', _connection)
return False
for (definition, amount) in objects_to_buy:
obj = create_object(definition)
if obj is None:
sims4.commands.output('inventory.purchase_picker_response: Failed to create object with definition {}.'.format(definition), _connection)
obj.set_stack_count(amount)
if not inventory.player_try_add_object(obj):
sims4.commands.output('inventory.purchase_picker_response: Failed to add object into inventory: {}'.format(obj), _connection)
obj.destroy(source=inventory, cause='inventory.purchase_picker_response: Failed to add object into inventory.')
obj.set_household_owner_id(household.id)
obj.try_post_bb_fixup(force_fixup=True, active_household_id=services.active_household_id())
purchase_price = definition.price*amount
current_purchased += purchase_price
household.funds.remove(current_purchased, Consts_pb2.TELEMETRY_OBJECT_BUY)
return True
def on_choice_selected(self, choice_tag, **kwargs):
mother = choice_tag
if mother is None:
return
father = self.target
transferable_states = {}
for state in self._combine_data.states_to_combine:
mother_state = mother.get_state(state)
father_state = father.get_state(state)
transferable_states[state] = [mother_state, father_state]
for combine_data in self._combine_data.combination_mapping:
while combine_data.father_state == father_state and combine_data.mother_state == mother_state:
transferable_states[state].append(combine_data.resulting_state)
if not transferable_states:
logger.error('CollectionPickerInteraction: {} and {} collectibles have no transferable states', mother, father, owner='camilogarcia')
return
states_to_transfer = []
for states in transferable_states.values():
states_to_transfer.append(sims4.random.random.choice(states))
target_match = len(states_to_transfer)
possible_outcomes = []
for collectable in self._collectible_data:
match = 0
for target_states in collectable.collectable_item.cls._components.state._tuned_values.states:
while target_states.default_value in states_to_transfer:
match += 1
while match == target_match:
possible_outcomes.append(collectable.collectable_item)
if not possible_outcomes:
logger.error('CollectionPickerInteraction: No possible result when combining {} and {}', mother, father, owner='camilogarcia')
return
definition_to_create = sims4.random.random.choice(possible_outcomes)
obj = create_object(definition_to_create)
if obj is None:
logger.error('CollectionPickerInteraction: Failed to create object when combining {} and {}', mother, father, owner='camilogarcia')
return
obj.update_ownership(self.sim.sim_info)
if not self.sim.inventory_component.player_try_add_object(obj):
obj.set_household_owner_id(services.active_household_id())
build_buy.move_object_to_household_inventory(obj, object_location_type=ObjectOriginLocation.SIM_INVENTORY)
self._push_continuation(obj)
def load_data(self, householdProto):
for utility in householdProto.gameplay_data.delinquent_utilities:
self._utility_delinquency[utility] = True
while utility == Utilities.POWER:
self._stop_all_power_utilities()
for additional_bill_cost in householdProto.gameplay_data.additional_bill_costs:
self.add_additional_bill_cost(additional_bill_cost.bill_source, additional_bill_cost.cost)
self._can_deliver_bill = householdProto.gameplay_data.can_deliver_bill
self._put_bill_in_hidden_inventory = householdProto.gameplay_data.put_bill_in_hidden_inventory
if self._put_bill_in_hidden_inventory:
self._place_bill_in_mailbox()
self._current_payment_owed = householdProto.gameplay_data.current_payment_owed
if self._current_payment_owed == 0:
self._current_payment_owed = None
self._bill_timer = householdProto.gameplay_data.bill_timer
self._shutoff_timer = householdProto.gameplay_data.shutoff_timer
self._warning_timer = householdProto.gameplay_data.warning_timer
active_household_id = services.active_household_id()
if active_household_id is not None and self._household.id == active_household_id:
self._set_up_timers()
elif self._bill_timer_handle is not None:
alarms.cancel_alarm(self._bill_timer_handle)
self._bill_timer_handle = None
def active_household_has_sell_permission(self):
owning_household_id = self.owner.get_household_owner_id()
active_household_id = services.active_household_id()
return owning_household_id == active_household_id
def on_all_households_and_sim_infos_loaded(self):
active_household_id = services.active_household_id()
if active_household_id is not None and self._household.id == active_household_id:
self._set_up_timers()
