def c_api_add_sims(session_id, zone_id, sim_ids, callback, add_to_skewer):
zone = services._zone_manager.get(zone_id)
if zone is None:
return LOADSIMS_FAILED_ERROR_CODE
client = zone.client_manager.get(session_id)
load_sims_on_client_connect = True
if client is None and load_sims_on_client_connect:
services.sim_info_manager().add_sims_to_zone(sim_ids)
else:
object_manager = services.object_manager()
for sim_id in sim_ids:
if sim_id in object_manager:
logger.error(
'Attempt to add a sim who is already in the zone. Native likely has a logic error.',
owner='mduke')
ret = sims.sim_spawner.SimSpawner.load_sim(sim_id)
while not ret:
logger.error(
'Sim failed to load while spinning up sim_id: {}.',
sim_id,
owner='mduke')
return LOADSIMS_FAILED_ERROR_CODE
if add_to_skewer:
for sim_id in sim_ids:
sim_info = services.sim_info_manager(zone_id).get(sim_id)
while sim_info is not None:
if client.household_id == sim_info.household_id:
client.add_selectable_sim_info(sim_info)
return SUCCESS_CODE
def load_from_seedling(self, tracker_seedling):
if self._has_offered_goals:
raise AssertionError('Attempting to load goals for situation: {} but goals have already been offered.'.format(self))
self._has_offered_goals = tracker_seedling.has_offered_goals
if tracker_seedling.inherited_target_id != 0:
self._inherited_target_sim_info = services.sim_info_manager().get(tracker_seedling.inherited_target_id)
self._goal_chains = []
for chain_seedling in tracker_seedling.chains:
self._goal_chains.append(_GoalSetChain(chain_seedling.starting_goal_set_type, chain_seedling.chosen_goal_set_type, chain_seedling.chain_id))
if tracker_seedling.main_goal:
goal_seedling = tracker_seedling.main_goal
sim_info = services.sim_info_manager().get(goal_seedling.actor_id)
self._realized_main_goal = goal_seedling.goal_type(sim_info=sim_info, situation=self._situation, goal_id=self._goal_id_generator(), count=goal_seedling.count, reader=goal_seedling.reader)
if goal_seedling.completed:
self._main_goal_completed = True
else:
self._realized_main_goal.register_for_on_goal_completed_callback(self._on_goal_completed)
for goal_seedling in tracker_seedling.minor_goals:
sim_info = services.sim_info_manager().get(goal_seedling.actor_id)
while True:
for chain in self._goal_chains:
while chain.chain_id == goal_seedling.chain_id:
break
logger.error('Unable to find chain with chain_id: {} during load of situation: {}', goal_seedling.chain_id, self)
goal = goal_seedling.goal_type(sim_info=sim_info, situation=self._situation, goal_id=self._goal_id_generator(), count=goal_seedling.count, reader=goal_seedling.reader)
self._realized_minor_goals[goal] = chain
goal.register_for_on_goal_completed_callback(self._on_goal_completed)
self._situation._send_goal_update_to_client()
def _run_interaction_gen(self, timeline):
services.sim_info_manager()._set_default_genealogy()
resolver = DataResolver(self.sim.sim_info)
if not resolver(self.situation_blacklist):
return True
if not self.target.is_sim:
return True
if self.sim.household_id == self.target.household_id:
return True
def on_response(dialog):
if not dialog.accepted:
self.cancel_user(cancel_reason_msg='Move-In. Player canceled, or move in together dialog timed out from client.')
return
actor = self.get_participant(ParticipantType.Actor)
src_household_id = actor.sim_info.household.id
target = self.target
tgt_household_id = target.sim_info.household.id
client_manager = services.client_manager()
if client_manager is not None:
client = client_manager.get_first_client()
if client is not None:
active_sim_id = client.active_sim.id
if src_household_id is not None and tgt_household_id is not None and active_sim_id is not None:
transfer_info = InteractionOps_pb2.SimTransferRequest()
transfer_info.source_household_id = src_household_id
transfer_info.target_household_id = tgt_household_id
transfer_info.active_sim_id = active_sim_id
system_distributor = distributor.system.Distributor.instance()
generic_pb_op = GenericProtocolBufferOp(DistributorOps_pb2.Operation.SIM_TRANSFER_REQUEST, transfer_info)
system_distributor.add_op_with_no_owner(generic_pb_op)
dialog = self.dialog(self.sim, self.get_resolver())
dialog.show_dialog(on_response=on_response)
return True
def get_family_relationship_bit(self, sim_id, output=None):
sim_x = services.sim_info_manager().get(self._owner_id)
sim_y = services.sim_info_manager().get(sim_id)
if sim_y is None:
if output is not None:
output('Could not find sim_info for {}.'.format(sim_id))
return
def get_index():
for (pair_x, pair_y) in itertools.product(ancestry_x, ancestry_y):
while pair_x.sim_id == pair_y.sim_id:
return (pair_x.depth, pair_y.depth)
return (None, None)
ancestry_x = self.get_ancestor_family_tree()
ancestry_y = sim_y.genealogy.get_ancestor_family_tree()
(depth_x, depth_y) = get_index()
if depth_x is None or depth_y is None:
if sim_x.spouse_sim_id is not None and sim_x.spouse_sim_id == sim_y.sim_id:
return FamilyRelationshipTuning.MATRIX[0][0]
if output is not None:
output('Sims {} and {} are not related.'.format(sim_x.full_name, sim_y.full_name))
return
bit = None
if FamilyRelationshipTuning.MATRIX is not None:
bit = FamilyRelationshipTuning.MATRIX[depth_x][depth_y]
if bit is not None and output is not None:
output('Sim {} is {} of Sim {}'.format(sim_x.full_name, bit, sim_y.full_name))
return bit
def _name_and_create_adoptee_gen(self, timeline):
adopted_sim_info = self.get_participant(ParticipantType.PickedSim)
last_name = SimSpawner.get_family_name_for_gender(self.sim.account, self.sim.last_name, adopted_sim_info.is_female)
result = yield self._do_renames_gen(timeline, (adopted_sim_info,), additional_tokens=(last_name,))
if not result:
return result
adopted_sim_info = self.get_participant(ParticipantType.PickedSim)
parent_a = self.sim.sim_info
parent_b = services.sim_info_manager().get(parent_a.spouse_sim_id)
adopted_sim_info.relationship_tracker._clear_relationships()
for relation in FamilyRelationshipIndex:
relation_id = adopted_sim_info.get_relation(relation)
relation_info = services.sim_info_manager().get(relation_id)
if relation_info is not None:
adopted_sim_info.genealogy.remove_family_link(relation)
family_relation = relation_info.genealogy.get_family_relationship_bit(adopted_sim_info.sim_id)
relation_info.genealogy.clear_family_relation(family_relation)
relation_info.relationship_tracker.destroy_relationship(adopted_sim_info.sim_id)
adopted_sim_info.genealogy.clear_family_relation(relation)
if adopted_sim_info.household is not parent_a.household:
adopted_sim_info.household.remove_sim_info(adopted_sim_info)
PregnancyTracker.initialize_sim_info(adopted_sim_info, parent_a, parent_b)
adopted_sim_info.trait_tracker.remove_trait(self.adoption_trait)
if adopted_sim_info.age == Age.BABY:
adopted_sim_info.set_zone_on_spawn()
create_and_place_baby(adopted_sim_info, ignore_daycare=True)
else:
SimSpawner.spawn_sim(adopted_sim_info, sim_position=self.sim.position)
return True
def __init__(self, *args, inherited_target_sim_info=None, reader=None, **kwargs):
super().__init__(inherited_target_sim_info=inherited_target_sim_info, reader=reader, *args, **kwargs)
self._required_target_sim_info = None
self._actual_target_sim_info = None
if reader is not None:
required_sim_id = reader.read_uint64(self.REQUIRED_SIM_ID, 0)
self._required_target_sim_info = services.sim_info_manager().get(required_sim_id)
actual_sim_id = reader.read_uint64(self.ACTUAL_SIM_ID, 0)
self._actual_target_sim_info = services.sim_info_manager().get(actual_sim_id)
if self._required_target_sim_info is not None:
return
if self._target_option == SituationGoalSimTargetingOptions.PlayerChoice:
return
if self._target_option == SituationGoalSimTargetingOptions.Inherited:
self._required_target_sim_info = inherited_target_sim_info
return
if self._target_option == SituationGoalSimTargetingOptions.DebugChoice:
self._required_target_sim_info = inherited_target_sim_info
return
possible_sim_infos = []
if self._situation is None or self._select_sims_outside_of_situation:
for sim_info in services.sim_info_manager().instanced_sim_info_including_baby_gen():
while self._can_sim_pass_test(sim_info, self._sim_info, inherited_target_sim_info):
possible_sim_infos.append(sim_info)
else:
for sim in self._situation.all_sims_in_situation_gen():
while self._can_sim_pass_test(sim.sim_info, self._sim_info, inherited_target_sim_info):
possible_sim_infos.append(sim.sim_info)
self._required_target_sim_info = random.choice(possible_sim_infos)
def modify_relationship(first_name1='', last_name1='', first_name2='', last_name2='', amount:float=0, track_type:TunableInstanceParam(sims4.resources.Types.STATISTIC)=None, _connection=None):
info1 = services.sim_info_manager().get_sim_info_by_name(first_name1, last_name1)
info2 = services.sim_info_manager().get_sim_info_by_name(first_name2, last_name2)
if info1 is not None and info2 is not None:
info1.relationship_tracker.add_relationship_score(info2.id, amount, track_type)
return True
return False
def get_participants(self, participant_type, event_key=None):
result = self._get_participants_base(participant_type, event_key=event_key)
if result:
return result
if participant_type == event_testing.test_events.SIM_INSTANCE:
return (self.sim_info,)
if participant_type == event_testing.test_events.FROM_DATA_OBJECT:
return (self.data_object,)
if participant_type == event_testing.test_events.OBJECTIVE_GUID64:
return (self.objective_guid64,)
if participant_type == event_testing.test_events.FROM_EVENT_DATA:
if not self.event_kwargs:
return ()
return (self.event_kwargs.get(event_key),)
if self._interaction is not None:
return tuple(getattr(participant, 'sim_info', participant) for participant in self._interaction.get_participants(participant_type))
if participant_type == ParticipantType.Actor:
return (self.sim_info,)
if participant_type == ParticipantType.AllRelationships:
sim_mgr = services.sim_info_manager()
relations = set(sim_mgr.get(relations.relationship_id) for relations in self.sim_info.relationship_tracker)
return tuple(relations)
if participant_type == ParticipantType.TargetSim:
if not self.event_kwargs:
return ()
target_sim_id = self.event_kwargs.get(event_testing.test_events.TARGET_SIM_ID)
if target_sim_id is None:
return ()
return (services.sim_info_manager().get(target_sim_id),)
if self.on_zone_load:
return ()
raise ValueError('Trying to use DataResolver with type that is not supported by DataResolver: {}'.format(participant_type))
def on_loading_screen_animation_finished(self):
logger.debug('on_loading_screen_animation_finished')
services.game_clock_service().restore_saved_clock_speed()
services.sim_info_manager().on_loading_screen_animation_finished()
services.get_event_manager().process_events_for_household(
test_events.TestEvent.SimTravel,
services.active_household(),
zone_id=self.id)
def advance_game_time(hours:int=0, minutes:int=0, seconds:int=0, _connection=None):
previous_time = services.time_service().sim_now
services.game_clock_service().advance_game_time(hours=hours, minutes=minutes, seconds=seconds)
new_time = services.time_service().sim_now
services.sim_info_manager().auto_satisfy_sim_motives()
output = sims4.commands.Output(_connection)
output('previous time = {}'.format(previous_time))
output('new time = {}'.format(new_time))
def on_enter(self):
super().on_enter()
caches.skip_cache = False
first_visit_to_zone = services.current_zone().is_first_visit_to_zone
if services.game_clock_service(
).time_has_passed_in_world_since_zone_save() or first_visit_to_zone:
services.sim_info_manager().run_preroll_autonomy(
first_time_load_zone=first_visit_to_zone)
return _ZoneSpinUpStateResult.DONE
def initialize_sim_info(sim_info, parent_a, parent_b):
sim_info.add_parent_relations(parent_a, parent_b)
if sim_info.household is not parent_a.household:
parent_a.household.add_sim_info_to_household(sim_info)
services.sim_info_manager()._set_default_genealogy()
sim_info.set_default_relationships(reciprocal=True)
client = services.client_manager().get_client_by_household_id(sim_info.household_id)
if client is not None:
client.selectable_sims.add_selectable_sim_info(sim_info)
def on_enter(self):
super().on_enter()
zone = services.current_zone()
if not zone.should_restore_sis():
logger.debug('NOT restoring interactions in zone spin up',
owner='sscholl')
return _ZoneSpinUpStateResult.DONE
logger.debug('Restoring interactions in zone spin up', owner='sscholl')
services.sim_info_manager().restore_sim_si_state()
return _ZoneSpinUpStateResult.DONE
def set_score(source_sim_id, target_sim_id, score, track_type, bidirectional:bool=True, _connection=None):
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
sims4.commands.output("Source sim info doesn't exist in relationship.set_score", _connection)
return False
source_sim_info.relationship_tracker.set_relationship_score(target_sim_id, score, track_type)
if bidirectional:
target_sim_info = services.sim_info_manager().get(target_sim_id)
if target_sim_info is None:
sims4.commands.output("Target sim info doesn't exist in relationship.set_score", _connection)
return False
target_sim_info.relationship_tracker.set_relationship_score(source_sim_id, score, track_type)
return True
def create_relationship(source_sim_id, *sim_id_list, _connection=None):
if not source_sim_id:
return False
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
sim_id_list = _get_sim_ids_from_string_list(sim_id_list, _connection)
if sim_id_list is None:
return False
sim_info_set = {services.sim_info_manager().get(sim_id) for sim_id in sim_id_list}
for sim_info in sim_info_set:
source_sim_info.relationship_tracker.create_relationship(sim_info.sim_id)
sim_info.relationship_tracker.create_relationship(source_sim_info.sim_id)
return True
def generate_autonomy_timer_view_data(sim_id:int=None):
autonomy_timer_data = []
sim = None
sim_info_manager = services.sim_info_manager()
if sim_info_manager is None:
return autonomy_timer_data
for sim_info in services.sim_info_manager().objects:
while sim_id == sim_info.sim_id:
sim = sim_info.get_sim_instance()
break
if sim is not None:
for timer in sim.debug_get_autonomy_timers_gen():
entry = {'timer_name': timer[0], 'timer_value': timer[1]}
autonomy_timer_data.append(entry)
return autonomy_timer_data
def _get_source_and_target(source_sim_id, target_sim_id, output):
source_sim_info = None
target_sim_info = None
if source_sim_id is None or target_sim_id is None:
output('Please pick source and target sim.')
return (source_sim_info, target_sim_info)
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
output('Invalid source sim info.')
return (source_sim_info, target_sim_info)
target_sim_info = services.sim_info_manager().get(target_sim_id)
if target_sim_info is None:
output('Invalid target sim info.')
return (source_sim_info, target_sim_info)
return (source_sim_info, target_sim_info)
def enact(self):
if self.enact_loot is None:
return
for sim in services.sim_info_manager().instanced_sims_gen():
self._enact_for_sim_info(sim.sim_info)
self._register_callbacks()
self._start_schedule()
def get_participants(self, participant_type, **kwargs):
result = self._get_participants_base(participant_type, **kwargs)
if result is not None:
return result
if participant_type == ParticipantType.Actor or participant_type == ParticipantType.CustomSim or participant_type == event_testing.test_constants.SIM_INSTANCE:
return (self._sim_info, )
if participant_type == ParticipantType.Object:
return (self._obj, )
elif participant_type == ParticipantType.ObjectIngredients:
if self._obj.crafting_component:
crafting_process = self._obj.get_crafting_process()
if crafting_process is not None:
return tuple(
crafting_process.get_ingredients_object_definitions())
return ()
return ()
if participant_type == ParticipantType.ObjectParent:
if self._obj is None or self._obj.parent is None:
return ()
return (self._obj.parent, )
if participant_type == ParticipantType.StoredSim:
stored_sim_info = self._obj.get_stored_sim_info()
return (stored_sim_info, )
if participant_type == ParticipantType.OwnerSim:
owner_sim_info_id = self._obj.get_sim_owner_id()
owner_sim_info = services.sim_info_manager().get(owner_sim_info_id)
return (owner_sim_info, )
if participant_type == ParticipantType.Affordance or participant_type == ParticipantType.InteractionContext or participant_type == event_testing.test_constants.FROM_EVENT_DATA:
return ()
raise ValueError(
'Trying to use SingleActorAndObjectResolver with something that is not supported: {}'
.format(participant_type))
def _start_schedule(self):
if self.scheduled_loot is not None:
self.scheduled_loot.set_resolver_gen(lambda: [
SingleSimResolver(sim.sim_info)
for sim in services.sim_info_manager().instanced_sims_gen()
])
self.scheduled_loot.start_loot_schedule()
def generate_aspiration_view_data(sim_id:int=None):
sim_info = services.sim_info_manager().get(sim_id)
aspiration_manager = services.get_instance_manager(sims4.resources.Types.ASPIRATION)
all_aspirations = []
for aspiration_id in aspiration_manager.types:
aspiration = aspiration_manager.get(aspiration_id)
aspiration_data = {}
aspiration_data['aspiration'] = str(aspiration)
aspiration_data['aspiration_uid'] = int(aspiration.guid64)
if issubclass(aspiration, Aspiration):
aspiration_data['display_name'] = str(hex(aspiration.display_name.hash))
aspiration_data['description'] = str(hex(aspiration.descriptive_text.hash))
aspiration_data['auto_select'] = str(aspiration)
aspiration_data['aspiration_complete'] = False
aspiration_data['objectives'] = []
aspiration_data['simId'] = str(sim_id)
if not sim_info.aspiration_tracker.milestone_completed(aspiration.guid64):
for objective in aspiration.objectives:
objective_data = {}
objective_data['objective'] = str(objective)
if sim_info.aspiration_tracker.objective_completed(objective.guid64):
objective_data['objective_complete'] = True
else:
objective_data['objective_complete'] = False
aspiration_data['objectives'].append(objective_data)
else:
aspiration_data['aspiration_complete'] = True
for objective in aspiration.objectives:
objective_data = {}
objective_data['objective'] = str(objective)
objective_data['objective_complete'] = True
aspiration_data['objectives'].append(objective_data)
all_aspirations.append(aspiration_data)
return all_aspirations
def get_prepopulated_job_for_sims(cls, sim, target_sim_id=None):
if target_sim_id and cls.targeted_situation is not None:
sim_info = services.sim_info_manager().get(target_sim_id)
if sim_info is None:
return
prepopulated = [(sim.id, cls.targeted_situation.actor_job.guid64), (target_sim_id, cls.targeted_situation.target_job.guid64)]
return prepopulated
def get_resurrect_data(first_name='', last_name='', _connection=None):
info = services.sim_info_manager().get_sim_info_by_name(
first_name, last_name)
output = sims4.commands.CheatOutput(_connection)
if info is not None:
output('Start')
output('1')
info.trait_tracker.remove_traits_of_type(traits.traits.TraitType.GHOST)
output('2')
info.death_tracker.clear_death_type()
output('3')
info.update_age_callbacks()
sim = info.get_sim_instance()
if sim is not None:
output('4')
sim.routing_context.ghost_route = False
output('5')
sim.DeathTracker.IS_DYING_BUFF = False
output('6')
sim._update_facial_overlay()
output('7')
sim._remove_multi_motive_buff_trackers()
output('8')
sim.reset(ResetReason.RESET_EXPECTED, None, 'Command')
output(
'Resurrected sim succesfully 2. If you want to disable all deaths, please, run the command death.toggle and you won´t never die. THANK YOU FOR USING -fer456'
)
return True
output(
'Sim not found. Do you wrote correctly the name?. Check also you haven´t liberated that spirit in the urnstone.THANK YOU FOR USING -fer456'
)
return False
def remove_selectable_sim_by_id(self, sim_id):
if len(self._selectable_sims) <= 1:
return False
sim_info = services.sim_info_manager().get(sim_id)
if sim_info is not None:
self.remove_selectable_sim_info(sim_info)
return True
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 print_relationship_depth(source_sim_id, target_sim_id, _connection=None):
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
depth = source_sim_info.relationship_tracker.get_relationship_depth(target_sim_id)
sims4.commands.output('Relationship Depth: {0}'.format(depth), _connection)
return True
def reset(_connection=None):
services.get_zone_situation_manager().reset()
for sim in services.sim_info_manager().instanced_sims_gen():
try:
sim.reset_role_tracker()
except Exception:
logger.error('Error while resetting role tracker for sim {}', sim)
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 reset(_connection=None):
services.get_zone_situation_manager().reset()
for sim in services.sim_info_manager().instanced_sims_gen():
try:
sim.reset_role_tracker()
except Exception:
logger.error('Error while resetting role tracker for sim {}', sim)
def start_autonomy_load_test(motive_value:float=-40, _connection=None):
sim_list = [sim for sim in services.sim_info_manager().instanced_sims_gen()]
global_autonomy_randomization('disabled', _connection)
for sim in sim_list:
sim.run_full_autonomy_next_ping()
_randomize_all_motives_deterministically(sim_list, motive_value)
services.autonomy_service().start_automated_load_test(_connection, len(sim_list))
def _push_open_street_sims_home(self):
sim_info_manager = services.sim_info_manager()
situation_manager = services.get_zone_situation_manager()
for instanced_sim in sim_info_manager.instanced_sims_gen():
while instanced_sim.id not in self._sims_told_to_leave and instanced_sim.is_npc and not instanced_sim.is_on_active_lot():
situation_manager.make_sim_leave_now_must_run(instanced_sim, super_speed_three_request=True)
self._sims_told_to_leave.add(instanced_sim.id)
def can_be_given_as_goal(cls, actor, situation, inherited_target_sim_info=None, **kwargs):
result = super(SituationGoalTargetedSim, cls).can_be_given_as_goal(actor, situation, **kwargs)
if not result:
return result
actor_sim_info = None if actor is None else actor.sim_info
if cls._target_option == SituationGoalSimTargetingOptions.Inherited:
if inherited_target_sim_info is None:
return TestResult(False, 'Situation goal tuned to look for inherited target, but no inherited target given.')
if actor is None:
return TestResult.TRUE
double_sim_resolver = DoubleSimResolver(actor_sim_info, inherited_target_sim_info)
return cls._target_tests.run_tests(double_sim_resolver)
if cls._target_option == SituationGoalSimTargetingOptions.PlayerChoice:
return TestResult.TRUE
if cls._target_option == SituationGoalSimTargetingOptions.DebugChoice:
return TestResult.TRUE
if situation is None or cls._select_sims_outside_of_situation:
for sim_info in services.sim_info_manager().instanced_sim_info_including_baby_gen():
while cls._can_sim_pass_test(sim_info, actor_sim_info, inherited_target_sim_info):
return TestResult.TRUE
else:
for sim in situation.all_sims_in_situation_gen():
while cls._can_sim_pass_test(sim.sim_info, actor_sim_info, inherited_target_sim_info):
return TestResult.TRUE
return TestResult(False, 'No valid target found for situation goal target.')
def picker_rows_gen(cls, inst, target, context, **kwargs):
inst_or_cls = inst if inst is not None else cls
actor = inst_or_cls.get_participant(
sim=context.sim,
target=target,
participant_type=ParticipantType.Actor,
**kwargs)
familiar_tracker = actor.sim_info.familiar_tracker
if familiar_tracker is not None:
rabbit_hole_service = services.get_rabbit_hole_service()
current_region = services.current_region()
sim_info_manager = services.sim_info_manager()
for familiar_info in familiar_tracker:
is_enable = True
row_tooltip = None
if rabbit_hole_service.is_in_rabbit_hole(
familiar_info.pet_familiar_id):
is_enable = False
row_tooltip = inst_or_cls.rabbit_holed_disabled_tooltip
else:
pet_familiar = sim_info_manager.get(
familiar_info.pet_familiar_id)
sim_region = region.get_region_instance_from_zone_id(
pet_familiar.zone_id)
is_enable = False
row_tooltip = inst_or_cls.incompatible_region_disabled_tooltip
row = BasePickerRow(name=familiar_info.name,
icon_info=familiar_info.icon_info,
tag=familiar_info.uid,
is_enable=is_enable,
row_tooltip=row_tooltip)
yield row
def _reparent_object(self):
inventory_owner = self.owner.get_inventory()
if inventory_owner is not None:
remove_success = inventory_owner.try_remove_object_by_id(
self.owner.id)
if not remove_success:
return
sim_info = services.sim_info_manager().get(self._parent_sim_info_id)
if sim_info is None:
self.owner.remove_component(types.PARENT_TO_SIM_HEAD_COMPONENT)
return
sim_instance = sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS)
def cleanup():
self.owner.remove_component(types.PARENT_TO_SIM_HEAD_COMPONENT)
if sim_instance is not None:
sim_instance.current_object_set_as_head = None
if sim_instance is None or not self._bone_hash:
logger.error('Object {} was saved with an invalid state: {}',
self.owner, self)
cleanup()
return
try:
SetAsHead.set_head_object(sim_instance, self.owner,
self._bone_hash)
except Exception as e:
logger.error(
"Failure to parent to {}'s head. Removing ParentToSimHeadComponent. ({})\nException:{}",
sim_instance, self, e)
cleanup()
def _log_contents(self):
sim_info_manager = services.sim_info_manager()
def get_full_name(sim_id):
if sim_id not in sim_info_manager:
return '<Pruned>'
sim_info = sim_info_manager.get(sim_id)
return '{} {}'.format(sim_info.first_name, sim_info.last_name)
current = (self._owner_id, 1)
def set_parent_node(relationship_index):
nonlocal current
if current[0] in sim_info_manager:
sim_info = sim_info_manager.get(current[0])
parent_ids = tuple(sim_info.genealogy.get_parent_sim_ids_gen())
if len(parent_ids) > relationship_index:
current = (parent_ids[relationship_index], current[1] + 1)
return
current = None
nodes = []
while not nodes:
if current:
nodes.append(current)
set_parent_node(FamilyRelationshipIndex.MOTHER)
else:
current = nodes.pop()
logger.error('\t'*current[1] + get_full_name(current[0]))
set_parent_node(FamilyRelationshipIndex.FATHER)
def invited_sim_infos_gen(self):
for guest_infos in self._job_type_to_guest_infos.values():
for guest_info in guest_infos:
while guest_info.sim_id is not None and guest_info.sim_id != 0:
sim_info = services.sim_info_manager().get(guest_info.sim_id)
if sim_info is not None:
yield sim_info
def _build_relationship_update_proto(self, deltas=None):
msg = commodity_protocol.RelationshipUpdate()
msg.actor_sim_id = self._sim_id
msg.target_id.object_id = self._target_sim_id
msg.target_id.manager_id = services.sim_info_manager().id
client_tracks = [track for track in self._bit_track_tracker if track.display_priority > 0]
client_tracks.sort(key=lambda track: track.display_priority)
track_bits = set()
for track in client_tracks:
if track.visible_to_client:
with ProtocolBufferRollback(msg.tracks) as relationship_track_update:
relationship_track_update.track_score = track.get_value()
relationship_track_update.track_bit_id = track.get_bit_for_client().guid64
relationship_track_update.track_id = track.guid64
relationship_track_update.track_popup_priority = track.display_popup_priority
relationship_track_update.change_rate = track.get_change_rate()
while deltas is not None:
track_delta = deltas.get(track)
while track_delta is not None:
relationship_track_update.delta = track_delta
track_bits.add(track.get_bit_for_client().guid64)
for bit in self._bits.values():
if not bit.visible:
pass
if bit.guid64 in track_bits:
pass
msg.bit_ids.append(bit.guid64)
if self._knowledge is not None:
msg.num_traits = self._knowledge.num_traits
for trait in self._knowledge.known_traits:
msg.known_trait_ids.append(trait.guid64)
target_sim_info = self.find_target_sim_info()
if target_sim_info is not None and target_sim_info.spouse_sim_id is not None:
msg.target_sim_significant_other_id = target_sim_info.spouse_sim_id
return msg
def _send_create_situation_telemetry(self, situation_type, situation_id,
guest_list, hire_cost, zone_id):
if hasattr(situation_type, 'guid64'):
with telemetry_helper.begin_hook(
writer, TELEMETRY_HOOK_CREATE_SITUATION) as hook:
hook.write_int('situ', situation_id)
hook.write_int('host', guest_list.host_sim_id)
hook.write_guid('type', situation_type.guid64)
hook.write_bool('invi', guest_list.invite_only)
hook.write_bool('hire', hire_cost)
hook.write_bool(
'nzon', zone_id != 0
and services.current_zone().id != zone_id)
sim_info_manager = services.sim_info_manager()
if sim_info_manager is not None:
for guest_infos in guest_list._job_type_to_guest_infos.values(
):
for guest_info in guest_infos:
if guest_info.sim_id == 0:
continue
guest_sim = sim_info_manager.get(guest_info.sim_id)
if guest_sim is None:
continue
client = services.client_manager(
).get_client_by_household_id(guest_sim.household_id)
with telemetry_helper.begin_hook(
writer, TELEMETRY_HOOK_GUEST) as hook:
hook.write_int('situ', situation_id)
hook.write_guid('type', situation_type.guid64)
if client is None:
hook.write_int('npcg', guest_info.sim_id)
else:
hook.write_int('pcgu', guest_info.sim_id)
hook.write_guid('jobb',
guest_info.job_type.guid64)
def _get_played_family_tree_distances(self):
with genealogy_caching():
sim_info_manager = services.sim_info_manager()
played_sim_infos = frozenset(sim_info for sim_info in sim_info_manager.get_all() if sim_info.is_player_sim)
def get_sim_ids_with_played_spouses():
return set(sim_info.spouse_sim_id for sim_info in played_sim_infos if sim_info.spouse_sim_id is not None if sim_info.spouse_sim_id in sim_info_manager)
def get_sim_ids_with_played_siblings():
sim_ids_with_played_siblings = set()
visited_ids = set()
for sim_info in played_sim_infos:
if sim_info.id in visited_ids:
continue
siblings = set(sim_info.genealogy.get_siblings_sim_infos_gen())
siblings.add(sim_info)
visited_ids.update(sibling.id for sibling in siblings)
played_siblings = set(sibling for sibling in siblings if sibling.is_player_sim)
if len(played_siblings) == 1:
sim_ids_with_played_siblings.update(sibling.id for sibling in siblings if sibling not in played_siblings)
elif len(played_siblings) > 1:
sim_ids_with_played_siblings.update(sibling.id for sibling in siblings)
return sim_ids_with_played_siblings
def get_played_relative_distances(up=False):
distances = {}
step = 0
next_crawl_set = set(played_sim_infos)
while next_crawl_set:
step += 1
crawl_set = next_crawl_set
next_crawl_set = set()
def relatives_gen(sim_info):
if up:
yield from sim_info.genealogy.get_child_sim_infos_gen()
else:
yield from sim_info.genealogy.get_parent_sim_infos_gen()
for relative in itertools.chain.from_iterable(relatives_gen(sim_info) for sim_info in crawl_set):
if relative.id in distances:
continue
distances[relative.id] = step
if relative not in played_sim_infos:
next_crawl_set.add(relative)
return distances
zero_distance_sim_ids = get_sim_ids_with_played_spouses() | get_sim_ids_with_played_siblings()
ancestor_map = get_played_relative_distances(up=True)
descendant_map = get_played_relative_distances(up=False)
def get_score(sim_info):
sim_id = sim_info.id
if sim_id in zero_distance_sim_ids:
return 0
return min(ancestor_map.get(sim_id, MAX_INT32), descendant_map.get(sim_id, MAX_INT32))
distances = {sim_info.id: get_score(sim_info) for sim_info in sim_info_manager.get_all()}
return distances
def _target_sim_gen(cls, sim):
for target_sim in services.sim_info_manager(
).instanced_sims_on_active_lot_gen():
while target_sim.Buffs.is_appropriate(
cls._required_appropriateness_tags):
if not cls._pushed_interaction_tunables.push_on_actor and target_sim is sim:
pass
yield target_sim
def raw_name(self):
if self._pet_familiar_id is None:
return self._name
pet_familiar = services.sim_info_manager().get(self._pet_familiar_id)
if pet_familiar is None:
logger.error("Attempting to get the name of a pet familiar that doesn't exist.")
return
return pet_familiar.full_name
def get_prepopulated_job_for_sims(cls, sim, target_sim_id=None):
if target_sim_id and cls.targeted_situation is not None:
sim_info = services.sim_info_manager().get(target_sim_id)
if sim_info is None:
return
else:
prepopulated = [(sim.id, cls.targeted_situation.actor_job.guid64), (target_sim_id, cls.targeted_situation.target_job.guid64)]
return prepopulated
def create_relationship(source_sim_id: int, *sim_id_list, _connection=None):
if not source_sim_id:
return False
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
sim_id_list = _get_sim_ids_from_string_list(sim_id_list, _connection)
if sim_id_list is None:
return False
sim_info_set = {
services.sim_info_manager().get(sim_id)
for sim_id in sim_id_list
}
for sim_info in sim_info_set:
source_sim_info.relationship_tracker.create_relationship(
sim_info.sim_id)
return True
def name(self):
if self._pet_familiar_id is None:
return LocalizationHelperTuning.get_raw_text(self._name)
pet_familiar = services.sim_info_manager().get(self._pet_familiar_id)
if pet_familiar is None:
logger.error("Attempting to get the name of a pet familiar that doesn't exist.")
return
return LocalizationHelperTuning.get_sim_name(pet_familiar)
def print_relationship_depth(source_sim_id, target_sim_id, _connection=None):
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
depth = source_sim_info.relationship_tracker.get_relationship_depth(
target_sim_id)
sims4.commands.output('Relationship Depth: {0}'.format(depth), _connection)
return True
def print_relationship_info(source_sim_id: int,
target_sim_id: int,
_connection=None):
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
source_sim_info.relationship_tracker.print_relationship_info(
target_sim_id, _connection)
def modify_relationship(first_name1='',
last_name1='',
first_name2='',
last_name2='',
amount: float = 0,
track_type: TunableInstanceParam(
sims4.resources.Types.STATISTIC) = None,
_connection=None):
info1 = services.sim_info_manager().get_sim_info_by_name(
first_name1, last_name1)
info2 = services.sim_info_manager().get_sim_info_by_name(
first_name2, last_name2)
if info1 is not None and info2 is not None:
info1.relationship_tracker.add_relationship_score(
info2.id, amount, track_type)
return True
return False
def add_bit(source_sim_id, target_sim_id, rel_bit, _connection=None):
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
source_sim_info.relationship_tracker.add_relationship_bit(target_sim_id,
rel_bit,
force_add=True)
return True
def set_value(self,
stat_type,
value,
apply_initial_modifier=False,
**kwargs):
modified_amount = 0.0
if apply_initial_modifier:
if stat_type.tested_initial_modifier is not None:
sim_info_a = services.sim_info_manager().get(
self.rel_data.sim_id_a)
sim_info_b = services.sim_info_manager().get(
self.rel_data.sim_id_b)
if sim_info_a is not None:
if sim_info_b is not None:
modified_amount = stat_type.tested_initial_modifier.get_max_modifier(
DoubleSimResolver(sim_info_a, sim_info_b))
super().set_value(stat_type, value + modified_amount, **kwargs)
def on_all_households_and_sim_infos_loaded(self, client):
self.update()
self.get_demographics()
for sim_info in services.sim_info_manager().get_all():
if sim_info.story_progression_tracker is not None:
sim_info.story_progression_tracker.on_all_households_and_sim_infos_loaded(
)
return super().on_all_households_and_sim_infos_loaded(client)
def force_slow_pregnancy(first_name1='',
last_name1='',
first_name2='',
last_name2='',
_connection=None):
output = sims4.commands.CheatOutput(_connection)
first_sim_info = services.sim_info_manager().get_sim_info_by_name(
first_name1, last_name1)
second_sim_info = services.sim_info_manager().get_sim_info_by_name(
first_name2, last_name2)
pregnancy_tracker = first_sim_info.pregnancy_tracker
pregnancy_tracker.start_pregnancy(first_sim_info, second_sim_info)
if pregnancy_tracker.is_pregnant:
output("Pregnant!")
else:
output("Pregnancy Attempt Failed")
return
def invited_sim_infos_gen(self):
for guest_infos in self._job_type_to_guest_infos.values():
for guest_info in guest_infos:
while guest_info.sim_id is not None and guest_info.sim_id != 0:
sim_info = services.sim_info_manager().get(
guest_info.sim_id)
if sim_info is not None:
yield sim_info
def add_sim_spawn_condition(self, sim_id, callback):
for sim in services.sim_info_manager().instanced_sims_gen():
if sim.id == sim_id:
logger.error(
'Sim {} is already in the world, cannot add the spawn condition',
sim)
return
self._sim_spawn_conditions[sim_id].add(callback)
def _update_client_from_bit_remove(self, bit_type, bit_instance):
sim_info_manager = services.sim_info_manager()
sim_info_a = sim_info_manager.get(self.sim_id_a)
sim_info_b = sim_info_manager.get(self.sim_id_b)
self._update_client_for_sim_info_for_bit_remove(
bit_type, bit_instance, sim_info_a, sim_info_b)
self._update_client_for_sim_info_for_bit_remove(
bit_type, bit_instance, sim_info_b, sim_info_a)
def load_away_action_info_from_proto(self, away_action_tracker_proto):
if away_action_tracker_proto.HasField('away_action'):
away_action_cls = services.get_instance_manager(sims4.resources.Types.AWAY_ACTION).get(away_action_tracker_proto.away_action.away_action_id)
if away_action_tracker_proto.away_action.HasField('target_sim_id'):
target = services.sim_info_manager().get(away_action_tracker_proto.away_action.target_sim_id)
else:
target = None
self._current_away_action = away_action_cls(self, target=target)
def _update_client_from_bit_add(self, bit_type, bit_instance, from_load):
sim_info_manager = services.sim_info_manager()
actor_sim_info = sim_info_manager.get(self._actor_sim_id)
target_sim_info = sim_info_manager.get(self._target_sim_id)
self._update_client_for_sim_info_for_bit_add(bit_type, bit_instance,
actor_sim_info,
target_sim_info,
from_load)
def on_all_households_and_sim_infos_loaded(self, _):
save_slot_data = services.get_persistence_service().get_save_slot_proto_buff()
sim_info_manager = services.sim_info_manager()
for sim_data in save_slot_data.gameplay_data.adoption_service.adoptable_sim_data:
sim_info = sim_info_manager.get(sim_data.adoptable_sim_id)
if sim_info is None:
continue
self._creation_times[sim_data.adoptable_sim_id] = DateAndTime(sim_data.creation_time)
def set_purchase_intents_to_almost_max(_connection=None):
stat_type = RetailCustomerSituation.PURCHASE_INTENT_STATISTIC
almost_max_value = stat_type.max_value - 1
for sim in services.sim_info_manager().instanced_sims_gen():
stat = sim.get_statistic(stat_type, add=False)
if stat is not None:
if stat.get_value() < almost_max_value:
stat.set_value(almost_max_value)
def add_object_message_for_sim_id(sim_id, msg_id, msg):
sim_info = services.sim_info_manager().get(sim_id)
if sim_info is not None:
add_object_message(sim_info, msg_id, msg, False)
else:
logger.error(
'Unable to find Sim for id {} in add_object_message_for_sim_id',
sim_id)
def show_employee_management_dialog(opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
return False
business_services = services.business_service()
business_manager = business_services.get_business_manager_for_zone()
if business_manager is None:
return False
business_tracker = business_services.get_business_tracker_for_household(
sim_info.household_id, business_manager.business_type)
msg = Business_pb2.ManageEmployeesDialog()
msg.hiring_sim_id = sim_info.sim_id
def get_sim_filter_gsi_name():
return 'Business Command: Get New Possible Employees'
for (business_employee_type, business_employee_data
) in business_manager.tuning_data.employee_data_map.items():
with ProtocolBufferRollback(msg.jobs) as employee_job_msg:
total_unlocked_slots = business_employee_data.employee_count_default + business_tracker.get_additional_employee_slots(
business_employee_type)
employee_job_msg.open_slots = total_unlocked_slots - business_manager.get_employee_count(
business_employee_type)
employee_job_msg.locked_slots = business_employee_data.employee_count_max - total_unlocked_slots
employee_job_msg.job_type = int(business_employee_type)
employee_job_msg.job_name = business_employee_data.job_name
employee_job_msg.job_icon = create_icon_info_msg(
IconInfoData(business_employee_data.job_icon))
current_employees = business_manager.get_employees_by_type(
business_employee_type)
sim_info_manager = services.sim_info_manager()
for employee_sim_id in current_employees:
employee_sim_info = sim_info_manager.get(employee_sim_id)
with ProtocolBufferRollback(
employee_job_msg.employees) as employee_msg:
business_manager.populate_employee_msg(
employee_sim_info, employee_msg,
business_employee_type, business_employee_data)
results = services.sim_filter_service().submit_matching_filter(
number_of_sims_to_find=business_employee_data.
potential_employee_pool_size,
sim_filter=business_employee_data.
potential_employee_pool_filter,
requesting_sim_info=sim_info,
allow_yielding=False,
gsi_source_fn=get_sim_filter_gsi_name)
for result in results:
with ProtocolBufferRollback(
employee_job_msg.available_sims) as employee_msg:
business_manager.populate_employee_msg(
result.sim_info, employee_msg, business_employee_type,
business_employee_data)
op = shared_messages.create_message_op(
msg, Consts_pb2.MSG_MANAGE_EMPLOYEES_DIALOG)
Distributor.instance().add_op_with_no_owner(op)
