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)
