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)