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 create_friends_for_sim(opt_sim: OptionalTargetParam = None, _connection=None): def callback_spawn_sims(filter_results, callback_data): sim_infos = [result.sim_info for result in filter_results] for sim_info in sim_infos: services.get_zone_situation_manager().add_debug_sim_id(sim_info.id) SimSpawner.spawn_sim(sim_info) quantity = 1 if RelationshipCommandTuning.CREATE_FRIENDS_COMMAND_QUANTITY is not None: quantity = RelationshipCommandTuning.CREATE_FRIENDS_COMMAND_QUANTITY friend_filter = RelationshipCommandTuning.CREATE_FRIENDS_COMMAND_FILTER active_sim_info = None tgt_client = services.client_manager().get(_connection) if tgt_client is not None: active_sim_info = services.client_manager().get(_connection).active_sim else: logger.error("tgt_client is None-- can't get active SimInfo") if active_sim_info is None: sims4.commands.output( 'error: A valid sim is needed to carry out this command.', _connection) def get_sim_filter_gsi_name(): return 'Relationship Command: Create Friend for {}'.format( active_sim_info) sims4.commands.output('Generating friends for active sim...', _connection) services.sim_filter_service().submit_matching_filter( number_of_sims_to_find=quantity, sim_filter=friend_filter, callback=callback_spawn_sims, requesting_sim_info=active_sim_info, continue_if_constraints_fail=True, gsi_source_fn=get_sim_filter_gsi_name)
def filter_create_friends(number_to_create: int, opt_sim: OptionalTargetParam = None, _connection=None): def callback(filter_results, callback_event_data): if filter_results: sim_infos = [result.sim_info for result in filter_results] for sim_info in sim_infos: sims4.commands.output( 'Created info name {}'.format(sim_info.full_name), _connection) sim = get_optional_target(opt_sim, _connection) def get_sim_filter_gsi_name(): return 'Sim Filter Command: Create Friends' services.sim_filter_service().submit_matching_filter( number_of_sims_to_find=number_to_create, sim_filter=filters.tunable.TunableSimFilter.ANY_FILTER, callback=callback, requesting_sim_info=sim.sim_info, continue_if_constraints_fail=True, allow_yielding=True, blacklist_sim_ids={ sim_info.id for sim_info in services.sim_info_manager().values() }, gsi_source_fn=get_sim_filter_gsi_name)
def get_predefined_guest_list(cls): active_sim_info = services.active_sim_info() door_knocker_results = services.sim_filter_service().submit_filter(cls._door_knocker_situation_job.filter, callback=None, requesting_sim_info=active_sim_info, allow_yielding=False, gsi_source_fn=cls.get_sim_filter_gsi_name) if not door_knocker_results: return door_knocker = random.choice(door_knocker_results) guest_list = SituationGuestList(invite_only=True, host_sim_id=door_knocker.sim_info.sim_id, filter_requesting_sim_id=active_sim_info.sim_id) guest_list.add_guest_info(SituationGuestInfo(door_knocker.sim_info.sim_id, cls._door_knocker_situation_job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP, expectation_preference=True)) blacklist = set() blacklist.add(door_knocker.sim_info.sim_id) kava_carrier_results = services.sim_filter_service().submit_filter(cls._fruitcake_bearer_situation_job.filter, callback=None, requesting_sim_info=active_sim_info, allow_yielding=False, blacklist_sim_ids=blacklist, gsi_source_fn=cls.get_sim_filter_gsi_name) if not kava_carrier_results: return kava_carrier = random.choice(kava_carrier_results) guest_list.add_guest_info(SituationGuestInfo(kava_carrier.sim_info.sim_id, cls._fruitcake_bearer_situation_job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP, expectation_preference=True)) blacklist.add(kava_carrier.sim_info.sim_id) lei_carrier_results = services.sim_filter_service().submit_filter(cls._lei_carrier_situation_job.filter, callback=None, requesting_sim_info=active_sim_info, allow_yielding=False, blacklist_sim_ids=blacklist, gsi_source_fn=cls.get_sim_filter_gsi_name) if not lei_carrier_results: return lei_carrier = random.choice(lei_carrier_results) guest_list.add_guest_info(SituationGuestInfo(lei_carrier.sim_info.sim_id, cls._lei_carrier_situation_job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP, expectation_preference=True)) blacklist.add(lei_carrier.sim_info.sim_id) other_neighbors_results = services.sim_filter_service().submit_filter(cls._other_neighbors_job.filter, callback=None, requesting_sim_info=active_sim_info, allow_yielding=False, blacklist_sim_ids=blacklist, gsi_source_fn=cls.get_sim_filter_gsi_name) if not other_neighbors_results: return guest_list if len(other_neighbors_results) > cls._number_of_neighbors: neighbors = random.sample(other_neighbors_results, cls._number_of_neighbors) else: neighbors = other_neighbors_results for neighbor in neighbors: guest_list.add_guest_info(SituationGuestInfo(neighbor.sim_info.sim_id, cls._other_neighbors_job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP, expectation_preference=True)) return guest_list
def filter_create_many_infos(*filter_names, _connection=None): def callback(results, callback_event_data): sims4.commands.output('Filter: {}'.format(callback_event_data), _connection) for result in results: sims4.commands.output( ' Sim ID:{}, score: {}'.format(result.sim_info.id, result.score), _connection) def get_sim_filter_gsi_name(): return 'Sim Filter Command: Create Many Sim Infos' for filter_name in filter_names: filter_type = get_tunable_instance(sims4.resources.Types.SIM_FILTER, filter_name) if filter_type is not None: services.sim_filter_service().submit_matching_filter( number_of_sims_to_find=1, sim_filter=filter_type, callback=callback, callback_event_data=filter_name, gsi_source_fn=get_sim_filter_gsi_name) sims4.commands.output('Processing filter: {}'.format(filter_name), _connection) else: sims4.commands.output('Unknown filter: {}'.format(filter_name), _connection)
def _update(self): career = self.sim_info.career_tracker.get_at_work_career() if career is None: logger.error( 'CareerTone {} trying to update performance when Sim {} not at work', self, self.sim_info, owner='tingyul') return if career._upcoming_gig is not None and career._upcoming_gig.odd_job_tuning is not None: return now = services.time_service().sim_now elapsed = now - self._last_update_time self._last_update_time = now career.apply_performance_change(elapsed, self.performance_multiplier) career.resend_career_data() resolver = SingleSimResolver(self.sim_info) for entry in self.periodic_sim_filter_loot: chance = entry.chance.get_chance(resolver) * elapsed.in_hours() if random.random() > chance: continue services.sim_filter_service().submit_filter( entry.sim_filter, self._sim_filter_loot_response, callback_event_data=entry, requesting_sim_info=self.sim_info, gsi_source_fn=self.get_sim_filter_gsi_name)
def _find_sims_with_filter(filter_type, requesting_sim, callback, _connection=None): if callback is None: sims4.commands.output('No callback supplied for _execute_filter', _connection) return requesting_sim_info = requesting_sim.sim_info if requesting_sim is not None else None services.sim_filter_service().submit_filter(filter_type, callback, None, requesting_sim_info=requesting_sim_info) sims4.commands.output('Processing filter: {}'.format(filter_type), _connection)
def filter_create(filter_type, continue_if_constraints_fail: bool = False, opt_sim: OptionalTargetParam = None, num_of_sims: int = 1, _connection=None): def callback(sim_infos, callback_event_data): if sim_infos: for sim_info in sim_infos: services.get_zone_situation_manager().add_debug_sim_id( sim_info.id) sims.sim_spawner.SimSpawner.spawn_sim(sim_info, None) sims4.commands.output( 'Spawned {} with id {}'.format(sim_info, sim_info.id), _connection) else: sims4.commands.output( 'No filter with {}'.format(callback_event_data), _connection) sim = get_optional_target(opt_sim, _connection) filter_name = str(filter_type) services.sim_filter_service().submit_matching_filter( num_of_sims, filter_type, callback, filter_name, requesting_sim_info=sim.sim_info, continue_if_constraints_fail=continue_if_constraints_fail) sims4.commands.output('Processing filter: {}'.format(filter_name), _connection)
def on_add(self, _): if self._has_been_added: return sim_filter_service = services.sim_filter_service() if sim_filter_service is not None: for sim_id in self._blacklist_sim_ids: services.sim_filter_service().add_sim_id_to_global_blacklist(sim_id, self._reason) self._has_been_added = True
def filter_create_friends(number_to_create, opt_sim:OptionalTargetParam=None, _connection=None): def callback(sim_infos, callback_event_data): if sim_infos: for sim_info in sim_infos: sims4.commands.output('Created info name {}'.format(sim_info.full_name), _connection) sim = get_optional_target(opt_sim, _connection) services.sim_filter_service().submit_matching_filter(number_to_create, filters.tunable.TunableSimFilter.ANY_FILTER, callback, requesting_sim_info=sim.sim_info, continue_if_constraints_fail=True, allow_yielding=True, blacklist_sim_ids={sim_info.id for sim_info in services.sim_info_manager().values()})
def _find_sims_with_filter(filter_type, requesting_sim, callback, _connection=None): if callback is None: sims4.commands.output('No callback supplied for _execute_filter', _connection) return requesting_sim_info = requesting_sim.sim_info if requesting_sim is not None else None services.sim_filter_service().submit_filter( filter_type, callback, None, requesting_sim_info=requesting_sim_info) sims4.commands.output('Processing filter: {}'.format(filter_type), _connection)
def filter_create(filter_type: TunableInstanceParam( sims4.resources.Types.SIM_FILTER), continue_if_constraints_fail: bool = False, opt_sim: OptionalTargetParam = None, num_of_sims: int = 1, spawn_sims: bool = True, _connection=None): def callback(filter_results, callback_event_data): sims4.commands.automation_output( 'FilterResults; SimCount: {}'.format(len(filter_results)), _connection) if filter_results: situation_manager = services.get_zone_situation_manager() sim_infos = [result.sim_info for result in filter_results] for sim_info in sim_infos: if spawn_sims: situation_manager.add_debug_sim_id(sim_info.id) sims.sim_spawner.SimSpawner.spawn_sim(sim_info, None) sims4.commands.output( 'Spawned {} with id {}'.format(sim_info, sim_info.id), _connection) sims4.commands.automation_output( 'FilterResultSim; SimId: {}'.format(sim_info.id), _connection) else: sims4.commands.output( 'No filter with {}'.format(callback_event_data), _connection) instanced_sim_ids = tuple( sim.sim_info.id for sim in services.sim_info_manager().instanced_sims_gen()) household_sim_ids = tuple( sim_info.id for sim_info in services.active_household().sim_info_gen()) blacklist_sim_ids = set(instanced_sim_ids + household_sim_ids) sim = get_optional_target(opt_sim, _connection) def get_sim_filter_gsi_name(): return 'Sim Filter Command: Create Sim to Match Filter' filter_name = str(filter_type) services.sim_filter_service().submit_matching_filter( number_of_sims_to_find=num_of_sims, sim_filter=filter_type, callback=callback, callback_event_data=filter_name, requesting_sim_info=sim.sim_info, blacklist_sim_ids=blacklist_sim_ids, continue_if_constraints_fail=continue_if_constraints_fail, gsi_source_fn=get_sim_filter_gsi_name) sims4.commands.output('Processing filter: {}'.format(filter_name), _connection)
def filter_create_many_infos(*filter_names, _connection=None): def callback(results, callback_event_data): sims4.commands.output('Filter: {}'.format(callback_event_data), _connection) for result in results: sims4.commands.output(' Sim ID:{}, score: {}'.format(result.sim_info.id, result.score), _connection) for filter_name in filter_names: filter_type = get_tunable_instance(sims4.resources.Types.SIM_FILTER, filter_name) if filter_type is not None: services.sim_filter_service().submit_filter(filter_type, callback, callback_event_data=filter_name, create_if_needed=True) sims4.commands.output('Processing filter: {}'.format(filter_name), _connection) else: sims4.commands.output('Unknown filter: {}'.format(filter_name), _connection)
def filter_create(filter_type, continue_if_constraints_fail:bool=False, opt_sim:OptionalTargetParam=None, num_of_sims:int=1, _connection=None): def callback(sim_infos, callback_event_data): if sim_infos: for sim_info in sim_infos: services.get_zone_situation_manager().add_debug_sim_id(sim_info.id) sims.sim_spawner.SimSpawner.spawn_sim(sim_info, None) sims4.commands.output('Spawned {} with id {}'.format(sim_info, sim_info.id), _connection) else: sims4.commands.output('No filter with {}'.format(callback_event_data), _connection) sim = get_optional_target(opt_sim, _connection) filter_name = str(filter_type) services.sim_filter_service().submit_matching_filter(num_of_sims, filter_type, callback, filter_name, requesting_sim_info=sim.sim_info, continue_if_constraints_fail=continue_if_constraints_fail) sims4.commands.output('Processing filter: {}'.format(filter_name), _connection)
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 can_sim_be_given_job(cls, sim_id, requesting_sim_info): if cls.filter is None: return True household_id = 0 if requesting_sim_info is not None: household_id = requesting_sim_info.household.id return services.sim_filter_service().does_sim_match_filter(sim_id, sim_filter=cls.filter, requesting_sim_info=requesting_sim_info, household_id=household_id)
def _roll_cast(self): resolver = SingleSimResolver(self._owner) blacklist_sim_ids = { sim_info.sim_id for sim_info in services.active_household() } blacklist_sim_ids.update( set(sim_info.sim_id for sim_info in services.sim_info_manager().instanced_sims_gen())) def get_sim_filter_gsi_name(): return 'Cast member for gig.' for potential_cast_member in self.gig_cast: if not potential_cast_member.filter_test.run_tests( resolver=resolver): continue generated_result = services.sim_filter_service( ).submit_matching_filter( sim_filter=potential_cast_member.sim_filter, allow_yielding=False, blacklist_sim_ids=blacklist_sim_ids, gsi_source_fn=get_sim_filter_gsi_name) for result in generated_result: cast_sim_info = result.sim_info self._owner.relationship_tracker.add_relationship_bit( cast_sim_info.id, potential_cast_member.cast_member_rel_bit) self._cast_list_ids.append(cast_sim_info.id) blacklist_sim_ids.add(cast_sim_info.id)
def get_hireable_employees(employee_type: BusinessEmployeeType, _connection=None): automation_output = sims4.commands.AutomationOutput(_connection) automation_output('GetHireableEmployees; Status:Begin') business_services = services.business_service() business_manager = business_services.get_business_manager_for_zone() if business_manager is not None: employee_data = business_manager.tuning_data.employee_data_map.get( employee_type) if employee_data is not None: sim_info = services.active_sim_info() def get_sim_filter_gsi_name(): return '[Automation] Business Command: Get New Possible Employees' results = services.sim_filter_service().submit_matching_filter( number_of_sims_to_find=employee_data. potential_employee_pool_size, sim_filter=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: automation_output( 'GetHireableEmployees; Status:Data, SimId:{}'.format( result.sim_info.id)) automation_output('GetHireableEmployees; Status:End')
def get_predefined_guest_list(cls): guest_list = SituationGuestList(invite_only=True) grabbed_members = [] for ( job, member_info ) in cls.member_job_and_role_states.org_member_jobs_and_roles.items(): members_sim_ids = cls.get_members_sim_infos( job, member_info, blacklist_sims=grabbed_members) grabbed_members.extend(members_sim_ids) for member_sim_id in members_sim_ids: guest_list.add_guest_info( SituationGuestInfo(member_sim_id, job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.BACKGROUND_HIGH)) filter_service = services.sim_filter_service() grabbed_non_members = [] for (job, role_info ) in cls.non_member_job_and_role_states.jobs_and_roles.items(): non_member_ids = filter_service.submit_matching_filter( sim_filter=job.filter, number_of_sims_to_find=role_info.number_of_sims_to_find, allow_yielding=False, blacklist_sim_ids={ sim_info.sim_id for sim_info in services.active_household() }) grabbed_non_members.extend(non_member_ids) for non_member_result in non_member_ids: guest_list.add_guest_info( SituationGuestInfo(non_member_result.sim_info.id, job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.BACKGROUND_HIGH)) return guest_list
def _activate_rabbit_hole(self, sim_id, rabbit_hole_id): rabbit_hole = self._get_rabbit_hole(sim_id, rabbit_hole_id) if rabbit_hole.current_phase is RabbitHolePhase.ACTIVE: return rabbit_hole.current_phase = RabbitHolePhase.ACTIVE sim_info = services.sim_info_manager().get(sim_id) rabbit_hole.on_activate() sim_filter_service = services.sim_filter_service() sim_filter_service.add_sim_id_to_global_blacklist( sim_id, SimFilterGlobalBlacklistReason.RABBIT_HOLE) exit_condition_callback = lambda _, sim_id=sim_id: self.remove_sim_from_rabbit_hole( sim_id, rabbit_hole_id, canceled=True) exit_condition_test_resolver = SingleSimResolver(sim_info) exit_conditions = ( exit_condition for exit_condition in rabbit_hole.exit_conditions if exit_condition.tests.run_tests(exit_condition_test_resolver)) if exit_conditions: self._conditional_actions_manager.attach_conditions( rabbit_hole, exit_conditions, exit_condition_callback) if rabbit_hole.time_tracking_policy is not RabbitHoleTimingPolicy.NO_TIME_LIMIT: time_expired_callback = lambda _, sim_id=sim_id: self.remove_sim_from_rabbit_hole( sim_id, rabbit_hole_id) rabbit_hole.set_expiration_alarm(time_expired_callback) if rabbit_hole.away_action is not None and sim_info.away_action_tracker is not None: sim_info.away_action_tracker.create_and_apply_away_action( rabbit_hole.away_action)
def _select_sims_from_results(self, results, sims_to_spawn): self._selected_sim_infos = [] global_blacklist = services.sim_filter_service().get_global_blacklist() for result in tuple(results): while result.sim_info.is_instanced(allow_hidden_flags=ALL_HIDDEN_REASONS) or result.sim_info.id in self._blacklist_sim_ids or result.sim_info.id in global_blacklist: results.remove(result) sorted_results = sorted(results, key=lambda x: x.score, reverse=True) if self._sim_filter.use_weighted_random: index = filters.tunable.TunableSimFilter.TOP_NUMBER_OF_SIMS_TO_LOOK_AT randomization_group = [(result.score, result.sim_info) for result in sorted_results[:index]] while index < len(sorted_results): while len(self._selected_sim_infos) < sims_to_spawn: random_choice = random.pop_weighted(randomization_group) randomization_group.append((sorted_results[index].score, sorted_results[index].sim_info)) logger.info('Sim ID matching request {0}', random_choice) self._selected_sim_infos.append(random_choice) index += 1 while True: while randomization_group and len(self._selected_sim_infos) < self._number_of_sims_to_find: random_choice = random.pop_weighted(randomization_group) logger.info('Sim ID matching request {0}', random_choice) self._selected_sim_infos.append(random_choice) else: for result in sorted_results: if len(self._selected_sim_infos) == sims_to_spawn: break logger.info('Sim ID matching request {0}', result.sim_info) self._selected_sim_infos.append(result.sim_info) return self._selected_sim_infos
def get_predefined_guest_list(cls): guest_list = SituationGuestList(invite_only=True) situation_manager = services.get_zone_situation_manager() worker_filter = cls.group_filter if cls.group_filter is not None else cls.default_job( ).filter instanced_sim_ids = [ sim.sim_info.id for sim in services.sim_info_manager().instanced_sims_gen() ] household_sim_ids = [ sim_info.id for sim_info in services.active_household().sim_info_gen() ] auto_fill_blacklist = situation_manager.get_auto_fill_blacklist( sim_job=cls.blacklist_job) situation_sims = set() for situation in situation_manager.get_situations_by_tags(cls.tags): situation_sims.update(situation.invited_sim_ids) blacklist_sim_ids = set( itertools.chain(situation_sims, instanced_sim_ids, household_sim_ids, auto_fill_blacklist)) filter_results = services.sim_filter_service().submit_matching_filter( sim_filter=worker_filter, allow_yielding=False, blacklist_sim_ids=blacklist_sim_ids, gsi_source_fn=cls.get_sim_filter_gsi_name) if not filter_results: return for result in filter_results: job = cls.situation_job_mapping.get(result.tag, cls.default_job()) guest_list.add_guest_info( SituationGuestInfo(result.sim_info.sim_id, job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.BACKGROUND_HIGH)) return guest_list
def _get_sims_from_filter(self): results = services.sim_filter_service().submit_filter( self.population_filter, None, allow_yielding=False, gsi_source_fn=self.get_sim_filter_gsi_name) return tuple(StoryProgressionAgentSimInfo(r.sim_info) for r in results)
def process_action(self, story_progression_flags): def _on_filter_request_complete(results, *_, **__): if results is None: return self._pre_apply_action() for result in results: sim_info = result.sim_info if sim_info is None: continue if not self._allow_instanced_sims(): if not sim_info.is_instanced(allow_hidden_flags=ALL_HIDDEN_REASONS): self._apply_action(sim_info) self._apply_action(sim_info) self._post_apply_action() services.sim_filter_service().submit_filter(self._get_filter(), _on_filter_request_complete, household_id=services.active_household_id(), gsi_source_fn=self.get_sim_filter_gsi_name)
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)
def get_predefined_guest_list(cls): active_sim_info = services.active_sim_info() fire_brigade_volunteers = services.sim_filter_service().submit_matching_filter(number_of_sims_to_find=cls.number_of_volunteers, sim_filter=cls.fire_brigade_job.filter, requesting_sim_info=active_sim_info, allow_yielding=False, blacklist_sim_ids={sim_info.sim_id for sim_info in services.active_household()}, gsi_source_fn=cls.get_sim_filter_gsi_name) if len(fire_brigade_volunteers) < cls.number_of_volunteers: return guest_list = SituationGuestList(invite_only=True, host_sim_id=fire_brigade_volunteers[0].sim_info.sim_id, filter_requesting_sim_id=active_sim_info.sim_id) for volunteer in fire_brigade_volunteers: guest_list.add_guest_info(SituationGuestInfo(volunteer.sim_info.sim_id, cls.fire_brigade_job, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP, expectation_preference=True)) return guest_list
def get_predefined_guest_list(cls): guest_list = SituationGuestList(True) worker_filter = cls.default_job().filter sim_infos = services.sim_filter_service().submit_filter(worker_filter, None, allow_yielding=False) if sim_infos: guest_list.add_guest_info(SituationGuestInfo(sim_infos[0].sim_info.sim_id, cls.default_job(), RequestSpawningOption.DONT_CARE, None)) else: guest_list.add_guest_info(SituationGuestInfo(0, cls.default_job(), RequestSpawningOption.DONT_CARE, None)) return guest_list
def _is_valid_agent(self, sim_info_agent): def get_sim_filter_gsi_name(): return 'Request to check if {} matches filter from {}'.format( sim_info_agent, self) return services.sim_filter_service().does_sim_match_filter( sim_info_agent.sim_id, sim_filter=self.population_filter, gsi_source_fn=get_sim_filter_gsi_name)
def _select_sims_from_results(self, results, sims_to_spawn): self._filter_results = [] self._filter_results_info = [] global_blacklist = services.sim_filter_service().get_global_blacklist() for result in tuple(results): if not result.sim_info.is_instanced( allow_hidden_flags=ALL_HIDDEN_REASONS): if not result.sim_info.id in self._blacklist_sim_ids: if result.sim_info.id in global_blacklist: results.remove(result) results.remove(result) sorted_results = sorted(results, key=lambda x: x.score, reverse=True) if self._sim_filter.use_weighted_random: index = filters.tunable.TunableSimFilter.TOP_NUMBER_OF_SIMS_TO_LOOK_AT randomization_group = [(result.score, result) for result in sorted_results[:index]] while index < len(sorted_results): while len(self._filter_results) < sims_to_spawn: random_choice = random.pop_weighted(randomization_group) if index < len(sorted_results): randomization_group.append( (sorted_results[index].score, sorted_results[index])) index += 1 logger.info('Sim ID matching request {0}', random_choice) self._filter_results.append(random_choice) self._filter_results_info.append(random_choice.sim_info) index += 1 if len(self._filter_results) < sims_to_spawn: if randomization_group: while True: while randomization_group and len( self._filter_results ) < self._number_of_sims_to_find: random_choice = random.pop_weighted( randomization_group) logger.info('Sim ID matching request {0}', random_choice) self._filter_results.append(random_choice) self._filter_results_info.append( random_choice.sim_info) else: for result in sorted_results: if len(self._filter_results) == sims_to_spawn: break logger.info('Sim ID matching request {0}', result.sim_info) self._filter_results.append(result) self._filter_results_info.append(result.sim_info) if self._sim_gsi_logging_data is not None: for result in self._filter_results: sim_filter_handlers.archive_filter_request( result.sim_info, self._sim_gsi_logging_data, rejected=False, reason='Score > 0 and chosen for spawning') return self._filter_results
def _get_valid_choices_gen(self, timeline): self.sim_ids = [] requesting_sim_info = self.sim.sim_info blacklist = {sim_info.id for sim_info in services.sim_info_manager().instanced_sims_gen(allow_hidden_flags=ALL_HIDDEN_REASONS)} for sim_filter in self.sim_filters: for _ in range(sim_filter.number_of_sims): sim_infos = services.sim_filter_service().submit_matching_filter(1, sim_filter.filter, None, blacklist_sim_ids=blacklist, requesting_sim_info=requesting_sim_info, allow_yielding=False, zone_id=0) for sim_info in sim_infos: self.sim_ids.append(sim_info.id) blacklist.add(sim_info.id) yield element_utils.run_child(timeline, element_utils.sleep_until_next_tick_element())
def test_add_sim(self, sim, requesting_sim_info): household_id = 0 if requesting_sim_info is not None: household_id = requesting_sim_info.household.id if self._job_type.filter: return services.sim_filter_service().does_sim_match_filter( sim.id, sim_filter=self._job_type.filter, requesting_sim_info=requesting_sim_info, household_id=household_id) return True
def get_predefined_guest_list(cls): active_sim_info = services.active_sim_info() guest_list = SituationGuestList(invite_only=True, host_sim_id=active_sim_info.id) worker_filter = cls.group_filter if cls.group_filter is not None else cls.default_job().filter filter_results = services.sim_filter_service().submit_matching_filter(sim_filter=worker_filter, allow_yielding=False, gsi_source_fn=cls.get_sim_filter_gsi_name) if not filter_results: logger.error('Failed to find/create any sims for {}; using defaults in ambient service', cls, owner='rez') return guest_list for result in filter_results: guest_list.add_guest_info(SituationGuestInfo(result.sim_info.sim_id, cls.default_job(), RequestSpawningOption.MUST_SPAWN, BouncerRequestPriority.BACKGROUND_LOW)) return guest_list
def can_sim_be_given_job(cls, sim_id, requesting_sim_info): if cls.filter is None: return True household_id = 0 if requesting_sim_info is not None: household_id = requesting_sim_info.household.id return services.sim_filter_service().does_sim_match_filter( sim_id, sim_filter=cls.filter, requesting_sim_info=requesting_sim_info, household_id=household_id)
def remove_permanently(self, sim_info): sim_id = sim_info.id sim_filter_service = services.sim_filter_service() try: sim_filter_service.add_sim_id_to_global_blacklist(sim_id, SimFilterGlobalBlacklistReason.SIM_INFO_BEING_REMOVED) clubs.on_sim_killed_or_culled(sim_info) sim_info.relationship_tracker.destroy_all_relationships() self.remove(sim_info) self.on_sim_info_removed(sim_info) finally: sim_filter_service.remove_sim_id_from_global_blacklist(sim_id, SimFilterGlobalBlacklistReason.SIM_INFO_BEING_REMOVED)
def _find_sims_with_filter(filter_type, requesting_sim, callback, _connection=None): if callback is None: sims4.commands.output('No callback supplied for _execute_filter', _connection) return requesting_sim_info = requesting_sim.sim_info if requesting_sim is not None else None def get_sim_filter_gsi_name(): return 'Sim Filter Command: Find Sims with Filter' services.sim_filter_service().submit_filter( filter_type, callback, None, requesting_sim_info=requesting_sim_info, gsi_source_fn=get_sim_filter_gsi_name) sims4.commands.output('Processing filter: {}'.format(filter_type), _connection)
def create_friends_for_sim(opt_sim:OptionalTargetParam=None, _connection=None): def callback_spawn_sims(filter_results, callback_data): for f_result in filter_results: services.get_zone_situation_manager().add_debug_sim_id(f_result.id) SimSpawner.spawn_sim(f_result) quantity = 1 if RelationshipCommandTuning.CREATE_FRIENDS_COMMAND_QUANTITY is not None: quantity = RelationshipCommandTuning.CREATE_FRIENDS_COMMAND_QUANTITY friend_filter = RelationshipCommandTuning.CREATE_FRIENDS_COMMAND_FILTER active_sim_info = None tgt_client = services.client_manager().get(_connection) if tgt_client is not None: active_sim_info = services.client_manager().get(_connection).active_sim else: logger.error("tgt_client is None-- can't get active SimInfo") if active_sim_info is None: sims4.commands.output('error: A valid sim is needed to carry out this command.', _connection) sims4.commands.output('Generating friends for active sim...', _connection) services.sim_filter_service().submit_matching_filter(number_of_sim_to_find=quantity, sim_filter=friend_filter, callback=callback_spawn_sims, requesting_sim_info=active_sim_info, continue_if_constraints_fail=True)
def get_parent(self, interaction, pregnancy_subject_sim_info): filter_results = services.sim_filter_service( ).submit_matching_filter( sim_filter=self.filter, allow_yielding=False, requesting_sim_info=pregnancy_subject_sim_info, gsi_source_fn=self.get_sim_filter_gsi_name) if filter_results: parent = random.choice([ filter_result.sim_info for filter_result in filter_results ]) return parent
def get_landlord_sim_info(self): landlord_filter = LandlordTuning.LANDLORD_FILTER if landlord_filter is None: return if self._landlord_id is not None: if services.sim_filter_service().does_sim_match_filter( self._landlord_id, sim_filter=landlord_filter): return services.sim_info_manager().get(self._landlord_id) self._landlord_id = None landlords = services.sim_filter_service().submit_matching_filter( sim_filter=landlord_filter, number_of_sims_to_find=1, allow_instanced_sims=True, allow_yielding=False, gsi_source_fn=self.get_sim_filter_gsi_name) if landlords: landlord_sim_info = landlords[0].sim_info self._landlord_id = landlord_sim_info.id else: landlord_sim_info = None return landlord_sim_info
def _clear_missing_pet_data(self, pet_id): self._missing_pet_id = 0 self._alert_posted = False if self._return_alarm is not None: alarms.cancel_alarm(self._return_alarm) self._return_alarm = None sim_filter_service = services.sim_filter_service() global_blacklist = sim_filter_service.get_global_blacklist() if pet_id in global_blacklist: sim_filter_service.remove_sim_id_from_global_blacklist(pet_id, SimFilterGlobalBlacklistReason.MISSING_PET) services.hidden_sim_service().unhide_sim(pet_id) services.get_first_client().send_selectable_sims_update()
def _run_filter_query(self): sim_info_manager = services.sim_info_manager() constrained_sim_ids = self._get_constrained_sims() results = sim_info_manager.find_sims_matching_filter(self._sim_filter.get_filter_terms(), constrained_sim_ids=constrained_sim_ids, start_time=self._start_time, end_time=self._end_time, household_id=self._household_id, requesting_sim_info=self._requesting_sim_info) global_blacklist = services.sim_filter_service().get_global_blacklist() for result in tuple(results): while result.sim_info.id in self._blacklist_sim_ids or result.sim_info.id in global_blacklist: results.remove(result) if not results and self._create_if_needed: results = [] create_result = self._sim_filter.create_sim_info(zone_id=self._zone_id, requesting_sim_info=self._requesting_sim_info, start_time=self._start_time, end_time=self._end_time) if create_result: results.append(create_result) logger.info('Created Sim Info with ID to match request {0}', create_result.sim_info.id) else: logger.info('Failed to create Sim info that matches filter. Reason: {}', create_result) return results
def get_npc_hosted_sims(cls): possible_pairs = [] client = services.client_manager().get_first_client() if client is None: return client_household = client.household if client_household is None: return blacklist_sim_ids = {sim.id for sim in services.sim_info_manager().instanced_sims_gen()} for sim_info in client_household.sim_info_gen(): blacklist_sim_ids.add(sim_info.id) for sim in client_household.instanced_sims_gen(): single_sim_resolver = event_testing.resolver.SingleSimResolver(sim.sim_info) if not cls._NPC_hosted_player_tests.run_tests(single_sim_resolver): pass results = services.sim_filter_service().submit_filter(cls._NPC_host_filter, None, requesting_sim_info=sim.sim_info, allow_yielding=False, blacklist_sim_ids=blacklist_sim_ids) if not results: pass chosen_NPC_id = sims4.random.weighted_random_item([(result.score, result.sim_info.id) for result in results]) possible_pairs.append((sim, chosen_NPC_id)) if not possible_pairs: return return random.choice(possible_pairs)
def _generate_target(self): blacklist_sim_ids = [sim.id for sim in services.sim_info_manager().instanced_sims_gen()] filter_results = services.sim_filter_service().submit_filter(self._sim_filter, None, requesting_sim_info=self._sim.sim_info, blacklist_sim_ids=blacklist_sim_ids, allow_yielding=False) if filter_results: self._target = sims4.random.weighted_random_item([(result.score, result.sim_info) for result in filter_results])
def _dialog_callback(self, dialog): services.sim_filter_service().remove_sim_id_from_global_blacklist(self._target.id, SimFilterGlobalBlacklistReason.PHONE_CALL) if not dialog.accepted: return self._on_dialog_accepted()
def execute(self): services.sim_filter_service().add_sim_id_to_global_blacklist(self._target.id, SimFilterGlobalBlacklistReason.PHONE_CALL) dialog = self._dialog(self._sim, DoubleSimResolver(self._sim.sim_info, self._target)) dialog.show_dialog(on_response=self._dialog_callback)
def release(self): sim_filter_service = services.sim_filter_service() if sim_filter_service is not None: for sim_id in self._blacklist_sim_ids: services.sim_filter_service().remove_sim_id_from_global_blacklist(sim_id, self._reason)