def notify_travel_service():
if services.travel_service().has_pending_travel(sim_info.account):
travel_service.on_travel_interaction_succeeded(
sim_info, from_zone_id, to_zone_id, callback, context)
if not sim_info.is_npc:
services.client_manager().get_first_client(
).send_selectable_sims_update()
def client_sync():
output("locks", "acquiring incoming lock 1")
with incoming_lock:
global incoming_commands
output("receive", "{} \n".format(len(incoming_commands)))
for unpacked_msg_data in incoming_commands:
if type(unpacked_msg_data) is Message:
try:
client = services.client_manager().get_first_client()
client_instance = services.client_manager().get_first_client()
if client == None:
return
except Exception:
continue
omega.send(client_instance.id, unpacked_msg_data.msg_id, unpacked_msg_data.msg)
incoming_commands.remove(unpacked_msg_data)
elif type(unpacked_msg_data) is File:
client_file = open(get_file_matching_name(unpacked_msg_data.file_name)[0], "wb")
new_architecture_data = unpacked_msg_data.file_contents
client_file.write(new_architecture_data)
client_file.close()
incoming_commands.remove(unpacked_msg_data)
output("locks", "releasing incoming lock")
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 debug_create_baby(actor_sim, position, gender, routing_surface=None):
baby = None
try:
actor_sim_info = actor_sim.sim_info
account = actor_sim.sim_info.account
sim_creator = SimCreator(gender=gender, age=Age.BABY, first_name=SimSpawner.get_random_first_name(account, gender == Gender.FEMALE), last_name=SimSpawner.get_family_name_for_gender(account, actor_sim.last_name, gender == Gender.FEMALE))
(sim_info_list, _) = SimSpawner.create_sim_infos((sim_creator,), household=actor_sim_info.household, account=account, zone_id=actor_sim_info.zone_id, creation_source='cheat: debug_create_baby')
sim_info = sim_info_list[0]
baby_def = Baby.get_default_baby_def()
baby = create_object(baby_def, sim_info.sim_id)
baby.set_sim_info(sim_info)
fgl_context = placement.FindGoodLocationContext(starting_position=position, object_id=baby.id, search_flags=placement.FGLSearchFlagsDefault, object_footprints=(baby.get_footprint(),))
(trans, orient) = placement.find_good_location(fgl_context)
if trans is not None:
baby.location = sims4.math.Location(sims4.math.Transform(trans, orient), routing_surface)
client = services.client_manager().get_client_by_household_id(sim_info.household_id)
while client is not None:
client.selectable_sims.add_selectable_sim_info(sim_info)
except Exception as e:
logger.exception('Create baby fail', e)
if actor_sim_info.household.sim_in_household(sim_info.sim_id):
actor_sim_info.household.remove_sim_info(sim_info)
client = services.client_manager().get_client_by_household_id(sim_info.household_id)
if client is not None:
client.selectable_sims.remove_selectable_sim_info(sim_info)
while baby is not None:
baby.destroy(source=actor_sim, cause='Create baby fail')
def sim_picker_dialog_test(_connection=None):
client_id = services.client_manager().get_first_client_id()
output = sims4.commands.CheatOutput(client_id)
client = services.client_manager().get_first_client()
injector = GameInjector()
injector.wrap_function(sims.sim.Sim, 'on_add', observe_key='test_inject')
injector.after('test_inject', watch_stuff)
def add_client_sims(_connection=None):
output = sims4.commands.CheatOutput(_connection)
# Add the first client's selectable sims to the new client's. Only expects one multiplayer client at the moment.
client = services.client_manager().get(1000)
first_client = services.client_manager().get_first_client()
for sim_info in first_client._selectable_sims:
client._selectable_sims.add_selectable_sim_info(sim_info)
client.set_next_sim()
def cnc(_connection=None):
#Create a new client. Deprecated.
output = sims4.commands.CheatOutput(_connection)
client = services.client_manager().get_first_client()
account = server.account.Account(865431, "Jon Snow")
new_client = services.client_manager().create_client(
1000, account, client._household_id)
# new_client.clear_selectable_sims()
# for sim_info in client._selectable_sims:
# new_client._selectable_sims.add_selectable_sim_info(sim_info)
# new_client.set_next_sim()
output("Adding client")
def create_pet_with_breed(breed: TunableInstanceParam(
sims4.resources.Types.BREED),
gender: Gender = Gender.FEMALE,
age: Age = Age.ADULT,
x: float = 0,
y: float = 0,
z: float = 0,
_connection=None):
if age not in (Age.CHILD, Age.ADULT, Age.ELDER):
sims4.commands.output('Invalid age for pet: {}'.format(age),
_connection)
return
client = services.client_manager().get(_connection)
position = sims4.math.Vector3(x, y, z) if x and y and z else None
sims4.commands.output('Creating pet with breed: {}'.format(breed.__name__),
_connection)
sim_creator = SimCreator(age=age,
gender=gender,
species=breed.breed_species,
additional_tags=(breed.breed_tag, ))
SimSpawner.create_sims((sim_creator, ),
household=None,
tgt_client=client,
generate_deterministic_sim=True,
sim_position=position,
account=client.account,
creation_source='cheat: pets.create_pet_with_breed')
def on_sim_creation(self, sim):
matching_requests = []
for request in tuple(self._spawning_requests):
if request._sim_info is sim.sim_info:
self._spawning_requests.remove(request)
matching_requests.append(request)
for request in matching_requests:
self._customer_success_notification(sim, request)
self._sim_spawned_callbacks(sim)
if self._mode == _SpawningMode.BATCH_SPAWNING:
if not self._spawning_requests:
self._mode = _SpawningMode.WAITING_HITTING_MARKS
while self._submitted_requests:
request = self._submitted_requests.pop(0)
self._customer_denied_notification(request, 'Request denied because batch spawning is complete.')
while self._listening_requests:
request = self._listening_requests.pop(0)
self._customer_denied_notification(request, 'Request denied because batch spawning is complete.')
if self._gui_smoke_notification_enabled and not self._spawning_requests and not self._submitted_requests:
self._gui_smoke_notification_enabled = False
client = services.client_manager().get_first_client()
if client:
output = sims4.commands.AutomationOutput(client.id)
if output:
output('SituationSpawning; Success:True')
def purchase_to_inventory(inventory_obj, def_id:str=None, mailman_purchase:bool=False, _connection=None):
definition_manager = services.definition_manager()
definition = definition_manager.get(def_id)
if definition is None:
return False
client = services.client_manager().get(_connection)
if client is None:
return False
household = client.household
price = definition.price
if household.funds.money < price:
return False
if mailman_purchase:
obj = services.active_lot().create_object_in_hidden_inventory(definition)
else:
inventory = inventory_obj.get_target().inventory_component
if inventory is None:
return False
obj = create_object(definition)
if obj is None:
return False
if not inventory.player_try_add_object(obj):
obj.destroy(source=inventory, cause='Failed to purchase object into inventory')
return False
obj.set_household_owner_id(household.id)
obj.try_post_bb_fixup(force_fixup=True, active_household_id=services.active_household_id())
household.funds.remove(price, Consts_pb2.TELEMETRY_OBJECT_BUY)
return True
def contains_selectable_sim(self):
client = services.client_manager().get_first_client()
if client is None:
return False
elif any(sim_info in self.invited_sim_infos_gen() for sim_info in client.selectable_sims):
return True
return False
def add(self, amount, reason, sim, tags=None, count_as_earnings=True):
amount = round(amount)
if amount < 0:
logger.error('Attempt to add negative amount of money to Family Funds.', owner='mduke')
return
if sim is None:
for client in services.client_manager().objects:
while client.household_id == self._household.id:
self._update_money(amount, reason, client.account.id, tags=tags, count_as_earnings=count_as_earnings)
return
logger.callstack('Attempt to raise household funds on a house with no client connected.', owner='nbaker', level=sims4.log.LEVEL_WARN)
else:
if sim.household != self._household:
logger.error('Attempt to add funds to the wrong household.', owner='mduke')
return
status = sim.account_connection
if status == AccountConnection.OFFLINE:
return
if status == AccountConnection.DIFFERENT_LOT:
sim.sim_info.add_to_personal_funds(amount)
with telemetry_helper.begin_hook(writer, TELEMETRY_HOOK_POCKET, sim=sim) as hook:
hook.write_int(TELEMETRY_AMOUNT, amount)
hook.write_int(TELEMETRY_REASON, reason)
else:
self._update_money(amount, reason, sim.account_id, sim, tags=tags, count_as_earnings=count_as_earnings)
def _trigger_phone_call_gen(self, timeline):
client = services.client_manager().get_first_client()
if client is None:
return
client_household = client.household
if client_household is None:
return
sims_to_check = [sim for sim in client_household.instanced_sims_gen()]
random.shuffle(sims_to_check)
for sim in sims_to_check:
call_types = []
ask_to_come_over_phone_call = HouseholdManager.PHONE_CALL_INFO.ask_to_come_over(sim)
call_types.append((ask_to_come_over_phone_call.weight, ask_to_come_over_phone_call))
chat_phone_call = HouseholdManager.PHONE_CALL_INFO.chat(sim)
call_types.append((chat_phone_call.weight, chat_phone_call))
invite_over_phone_call = HouseholdManager.PHONE_CALL_INFO.invite_over(sim)
call_types.append((invite_over_phone_call.weight, invite_over_phone_call))
while call_types:
call_type = pop_weighted(call_types)
if call_type.try_and_setup():
call_type.execute()
self._phone_call_element = None
return
yield element_utils.run_child(timeline, element_utils.sleep_until_next_tick_element())
self._phone_call_element = None
def switch_sim_from_household_to_target_household(self, sim_info, starting_household, destination_household, destroy_if_empty_household=True):
active_household = services.active_household()
if services.hidden_sim_service().is_hidden(sim_info.id):
services.hidden_sim_service().unhide(sim_info.id)
if starting_household is destination_household:
logger.error('Trying to run AddToHousehold basic extra on a sim who is already in the destination household.')
return False
if not destination_household.can_add_sim_info(sim_info):
logger.error('Trying to run AddToHousehold basic extra when there is no room in the destination household.')
return False
starting_household.remove_sim_info(sim_info, destroy_if_empty_household=destroy_if_empty_household, assign_to_none=False)
destination_household.add_sim_info_to_household(sim_info)
client = services.client_manager().get_first_client()
if destination_household is active_household:
client.add_selectable_sim_info(sim_info)
sim_info.apply_fixup_actions(SimInfoFixupActionTiming.ON_ADDED_TO_ACTIVE_HOUSEHOLD)
else:
client.remove_selectable_sim_info(sim_info)
if sim_info.career_tracker is not None:
sim_info.career_tracker.remove_invalid_careers()
sim = sim_info.get_sim_instance()
if sim is not None:
sim.update_intended_position_on_active_lot(update_ui=True)
situation_manager = services.get_zone_situation_manager()
for situation in situation_manager.get_situations_sim_is_in(sim):
if destination_household is active_household and situation.is_user_facing:
continue
situation_manager.remove_sim_from_situation(sim, situation.id)
services.daycare_service().on_sim_spawn(sim_info)
return True
def change_persona_client(name, _connection=None):
output = sims4.commands.CheatOutput(_connection)
# output("working")
client_manager = services.client_manager()
client = client_manager.get(1000)
client._account._persona_name = name
output(client._account._persona_name)
def check_collection_complete(self, collection_id):
collection_data = ObjectCollectionData.get_collection_data(collection_id)
collection_count = len(collection_data.object_list)
collected_count = sum(1 for collection in self._collections.values() if collection == collection_id)
if not collection_count or not collected_count:
return
client = services.client_manager().get_client_by_household(self._owner)
if client is not None and client.active_sim is not None:
message_owner_info = client.active_sim.sim_info
else:
message_owner_info = None
if collection_data.first_collected_notification is not None and message_owner_info is not None and collected_count == 1:
dialog = collection_data.first_collected_notification(message_owner_info, None)
dialog.show_dialog()
if collection_count == collected_count:
if client is not None:
with telemetry_helper.begin_hook(collection_telemetry_writer, TELEMETRY_HOOK_COLLECTION_COMPLETE, household=client.household) as hook:
hook.write_int(TELEMETRY_COLLECTION_ID, collection_id)
_sting = ObjectCollectionData.COLLECTION_COMPLETED_STING(client.active_sim)
_sting.start()
if message_owner_info is not None:
dialog = collection_data.completed_award_notification(message_owner_info, None)
dialog.show_dialog()
if collection_data.screen_slam is not None:
collection_data.screen_slam.send_screen_slam_message(message_owner_info, collection_data.collection_name)
lot = services.active_lot()
if lot is not None:
lot.create_object_in_hidden_inventory(collection_data.completed_award)
household = services.household_manager().get(self._owner.id)
if household is not None:
household.funds.add(collection_data.completed_award_money, Consts_pb2.TELEMETRY_MONEY_ASPIRATION_REWARD, None)
elif client is not None:
_sting = ObjectCollectionData.COLLECTION_COLLECTED_STING(client.active_sim)
_sting.start()
def _try_start_special_event(self, scheduler, alarm_data, extra_data):
entry = alarm_data.entry
situation = entry.situation
situation_manager = services.get_zone_situation_manager()
if self._active_special_event_id is None:
client_manager = services.client_manager()
client = next(iter(client_manager.values()))
invited_sim = client.active_sim
active_sim_available = situation.is_situation_available(invited_sim)
def _start_special_event(dialog):
guest_list = None
if dialog.accepted:
start_user_facing = True
guest_list = SituationGuestList()
guest_info = SituationGuestInfo.construct_from_purpose(invited_sim.id, situation.venue_situation_player_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
else:
start_user_facing = False
situation_id = situation_manager.create_situation(situation, guest_list=guest_list, user_facing=start_user_facing)
self._active_special_event_id = situation_id
if not situation_manager.is_user_facing_situation_running() and active_sim_available:
dialog = situation.venue_invitation_message(invited_sim, SingleSimResolver(invited_sim))
dialog.show_dialog(on_response=_start_special_event, additional_tokens=(situation.display_name, situation.venue_situation_player_job.display_name))
else:
situation_id = situation_manager.create_situation(situation, user_facing=False)
self._active_special_event_id = situation_id
def get_selectable_sims(_connection=None):
output = commands.CheatOutput(_connection)
tgt_client = services.client_manager().get(_connection)
for sim_info in tgt_client.selectable_sims:
output("sim {} {} is selectable".format(sim_info.first_name,
sim_info.last_name))
def invoke_command(command=None, zone_id:int=None):
ready = False
output_accum = ''
response = ''
def _callback(result):
nonlocal response, ready
if result:
response = 'Success<br>' + output_accum
else:
response = 'Failure<br>' + output_accum
ready = True
if command is not None:
def _fake_output(s, context=None):
nonlocal response
response += '<br>' + s
connection = services.client_manager().get_first_client()
sims4.core_services.command_buffer_service().add_command(command, _callback, _fake_output, zone_id, connection.id)
timeout_counter = 0
while not ready:
time.sleep(SLEEP_TIME)
timeout_counter += 1
while timeout_counter > TIMEOUT:
ready = True
continue
return {'response': response}
def set_active_sim(first_name='', last_name='', _connection=None):
output = commands.CheatOutput(_connection)
try:
if _connection is None:
output('SetActiveSim; Status:ParamError')
return False
tgt_client = services.client_manager().get(_connection)
if tgt_client is None:
output('SetActiveSim; Status:ClientError no client')
return False
sim_info = (services.sim_info_manager().get_sim_info_by_name(
first_name, last_name))
if sim_info is None:
output('SetActiveSim; Status:SimError no sim with this name found')
return False
SelectionGroupService \
.get(services.active_household_id()) \
.make_sim_selectable(sim_info)
if tgt_client.set_active_sim_by_id(sim_info.id):
output('SetActiveSim; Status:Success')
return True
output('SetActiveSim; Status:NoChange')
return True
except BaseException as exception:
output('Error: {}'.format(exception))
Logger.log(traceback.format_exc())
def _load_household_from_household_proto(self, household_proto, fixup_helper=None):
account = services.account_service().get_account_by_id(household_proto.account_id, try_load_account=True)
if account is None:
sims4.log.error('Persistence', "Household account doesn't exist in account ids. Creating temp account", owner='yshan')
account = server.account.Account(household_proto.account_id, 'TempPersonaName')
household = sims.household.Household(account)
resend_sim_infos = household.load_data(household_proto, fixup_helper)
logger.info('Household loaded. name:{:20} id:{:10} #sim_infos:{:2}', household.name, household.id, len(household))
self.add(household)
if resend_sim_infos:
household.resend_sim_infos()
household.initialize_sim_infos()
if household is services.client_manager().get_first_client().household:
for sim_info in household.sim_info_gen():
for other_info in household.sim_info_gen():
if sim_info is not other_info:
relationship_service = services.relationship_service()
if relationship_service.has_bit(sim_info.id, other_info.id, global_relationship_tuning.RelationshipGlobalTuning.NEIGHBOR_RELATIONSHIP_BIT):
relationship_service.remove_relationship_bit(sim_info.id, other_info.id, global_relationship_tuning.RelationshipGlobalTuning.NEIGHBOR_RELATIONSHIP_BIT)
household.bills_manager.sanitize_household_inventory()
if self._pending_household_funds is not None:
pending_funds_reasons = self._pending_household_funds.get(household.id)
if pending_funds_reasons is not None:
del self._pending_household_funds[household.id]
for (fund, reason) in pending_funds_reasons:
household.funds.add(fund, reason, None)
return household
def fill_motive(stat_type, _connection=None):
if stat_type is not None:
tgt_client = services.client_manager().get(_connection)
tracker = tgt_client.active_sim.get_tracker(stat_type)
tracker.set_value(stat_type, stat_type.max_value)
return True
return False
def _get_target(self, _connection):
if self._target_id is None:
client = services.client_manager().get(_connection)
if client is not None:
return client.active_sim_info
return
return services.sim_info_manager().get(self._target_id)
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)
def _test_execute_buy_affordance(self, object_to_buy):
retail_component = object_to_buy.retail_component
if retail_component is None:
return (object_to_buy,
TestResult(False, '{} missing retail component'))
buy_affordance = retail_component.get_buy_affordance()
if buy_affordance is None:
return (object_to_buy,
TestResult(False, '{} missing buy affordance'))
context = InteractionContext(
self.owner._customer,
InteractionContext.SOURCE_SCRIPT,
Priority.High,
client=services.client_manager().get_first_client())
buy_aop = interactions.aop.AffordanceObjectPair(
buy_affordance, object_to_buy, buy_affordance, None)
test_result = buy_aop.test(context)
execute_result = None
if test_result:
execute_result = buy_aop.execute(context)
if execute_result:
for custom_key in self.owner.buy_interaction.custom_keys_gen():
self._test_event_register(TestEvent.InteractionComplete,
custom_key)
self.object_id = object_to_buy.id
return (object_to_buy, EnqueueResult(test_result, execute_result))
def display_outcomes(sim_id:int=None, _connection=None):
sim = services.object_manager().get(sim_id)
client = services.client_manager().get(_connection)
if not sim:
sim = _active_sim(client)
for si in sim.si_state.sis_actor_gen():
sims4.commands.output('Outcome for {} = {}'.format(si.affordance, si.outcome_result), _connection)
def set_interaction_mode(mode:InteractionModes=None, source:int=None, priority:interactions.priority.Priority=None, _connection=None):
output = sims4.commands.Output(_connection)
client = services.client_manager().get(_connection)
if client is None:
return 0
sources = {}
for (key, val) in vars(interactions.context.InteractionContext).items():
while key.startswith('SOURCE'):
sources[val] = key
if mode is None and source is None and priority is None:
output('Source options:')
for val in sources.values():
output(' {}'.format(val))
output('Priority options:')
for val in interactions.priority.Priority:
output(' {}'.format(val.name))
if mode is InteractionModes.default:
client.interaction_source = None
client.interaction_priority = None
elif mode is InteractionModes.autonomous:
client.interaction_source = interactions.context.InteractionContext.SOURCE_AUTONOMY
client.interaction_priority = interactions.priority.Priority.Low
if source is not None:
client.interaction_source = source
if priority is not None:
client.interaction_priority = priority
source = sources.get(client.interaction_source, client.interaction_source)
output('Client interaction mode: source={} priority={}'.format(source, client.interaction_priority.name))
return 1
def fill_visible_commodities_household(opt_object: OptionalTargetParam = None,
_connection=None):
active_sim_info = services.client_manager().get(_connection).active_sim
household = active_sim_info.household
for sim_info in household.sim_info_gen():
sim_info.commodity_tracker.set_all_commodities_to_max(
visible_only=True)
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 = services.client_manager().get(session_id)
if client is None:
services.sim_info_manager().add_sims_to_zone(sim_ids)
return SUCCESS_CODE
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.'
)
else:
ret = sims.sim_spawner.SimSpawner.load_sim(sim_id)
if not ret:
logger.error(
'Sim failed to load while spinning up sim_id: {}.', sim_id)
return LOADSIMS_FAILED_ERROR_CODE
if add_to_skewer:
for sim_id in sim_ids:
sim_info = services.sim_info_manager().get(sim_id)
if sim_info is not None:
if client.household_id == sim_info.household_id:
client.add_selectable_sim_info(sim_info)
return SUCCESS_CODE
def _on_send_to_daycare():
sent_sim_infos = []
for sim_info in daycare_sim_infos:
if household.home_zone_id == current_zone_id:
self._apply_daycare_effects_to_sim(sim_info)
if not self.is_sim_info_at_daycare(sim_info):
sent_sim_infos.append(sim_info)
sim_info.add_trait(DaycareTuning.DAYCARE_TRAIT_ON_KIDS)
if sim_info.zone_id != household.home_zone_id:
sim_info.inject_into_inactive_zone(household.home_zone_id)
if sim_info.zone_id != current_zone_id:
if sim_info.away_action_tracker is not None:
sim_info.away_action_tracker.reset_to_default_away_action()
if is_active_household:
services.client_manager().get_first_client().send_selectable_sims_update()
self._show_daycare_notification(household, sent_sim_infos, is_enable=True)
def push_walk_away(sim_id:int=None, _connection=None):
if sim_id is None:
client = services.client_manager().get(_connection)
sim = _active_sim(client)
else:
sim = services.object_manager().get(sim_id)
push_backoff(sim)
def request_client_disconnect_gen(timeline):
try:
zone = services.current_zone()
if zone is not None:
client_manager = services.client_manager()
client = client_manager.get(session_id)
logger.info('Client {0} starting save of zone {1}', session_id,
zone_id)
yield from 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)
yield
client_manager.remove(client)
return callback(zone_id, session_id, SUCCESS_CODE)
yield
except:
logger.exception('Error disconnecting the client')
return callback(zone_id, session_id, EXCEPTION_ERROR_CODE)
yield
def set_age(age: str = 'Adult', _connection=None):
output = sims4.commands.Output(_connection)
tgt_client = services.client_manager().get(_connection)
if tgt_client.active_sim is None:
output('Set Sim Age Failure: No Sim Selected')
return False
age_to_set = sims.sim_info_types.Age.ADULT
if age == 'Child':
age_to_set = sims.sim_info_types.Age.CHILD
elif age == 'Teen':
age_to_set = sims.sim_info_types.Age.TEEN
elif age == 'Young Adult':
age_to_set = sims.sim_info_types.Age.YOUNGADULT
elif age == 'Adult':
age_to_set = sims.sim_info_types.Age.ADULT
elif age == 'Elder':
age_to_set = sims.sim_info_types.Age.ELDER
else:
output(
'Set Sim Age Failure: Invalid Age. Options are: Child, Young Adult, Adult, Elder'
)
return False
tgt_client.active_sim.sim_info.advance_age(force_age=age_to_set)
output('Selected Sim Set to Age: ' + age)
return True
def on_remove(self):
# We override the on_remove function of the client so we can remove the stand-in client at the same time.
# Only supports one multiplayer client at the moment, which has the id of 1000.
if self.active_sim is not None:
self._set_active_sim_without_field_distribution(None)
if self._account is not None:
self._account.unregister_client(self)
for sim_info in self._selectable_sims:
self.on_sim_removed_from_skewer(sim_info)
self.selectable_sims.remove_watcher(self)
distributor_instance = Distributor.instance()
distributor_instance.remove_client(self)
self._selectable_sims = None
self.active = False
if self.id != 1000:
Distributor.instance().remove_client_from_id(1000)
client_manager = services.client_manager()
client = client_manager.get(1000)
client_manager.remove(client)
def debugvis_test(name, _connection=None):
client = services.client_manager().get(_connection)
sim = client.active_sim
time = services.time_service().sim_now
hour = time.hour() % 12*sims4.math.TWO_PI/12
minute = time.minute()*sims4.math.TWO_PI/60
a = sim.position + sims4.math.Vector3(0, 1, 0)
b = a + sims4.math.Vector3(math.cos(hour), 0, math.sin(hour))*3
c = a + sims4.math.Vector3(math.cos(minute), 0, math.sin(minute))*4
with Context(name, routing_surface=sim.routing_surface) as layer:
layer.set_color(Color.YELLOW)
layer.add_segment(a, b, color=Color.CYAN)
layer.add_segment(a, c, color=Color.RED)
layer.add_point(a, size=0.2)
layer.add_point(b, size=0.1, color=Color.BLUE)
layer.add_point(c, size=0.1, color=Color.MAGENTA)
layer.add_circle(a, 5, color=Color.GREEN)
for i in range(12):
theta = i*sims4.math.TWO_PI/12
x = sims4.math.Vector3(4.75*math.cos(theta), 0, 4.75*math.sin(theta))
color = sims4.color.interpolate(Color.YELLOW, Color.BLUE, i/11)
layer.add_arrow(a + x, 0.5*sims4.math.PI - theta, end_arrow=False, color=color)
layer.add_text_world(a + x, str(i), color_foreground=pseudo_random_color(i))
layer.add_text_screen(sims4.math.Vector2(4, 32), 'Displaying debug visualization tests.')
for i in range(200):
layer.add_text_object(sim, sims4.math.Vector3.ZERO(), str(i), bone_index=i)
return 1
def live_drag_end(object_source_id:int, object_target_id:int, end_system:LiveDragLocation, _connection=None):
current_zone = services.current_zone()
source_object = current_zone.find_object(object_source_id)
target_object = None
if object_target_id:
target_object = current_zone.find_object(object_target_id)
if gsi_handlers.live_drag_handlers.live_drag_archiver.enabled:
gsi_handlers.live_drag_handlers.archive_live_drag('End', 'Command', end_system, LiveDragLocation.GAMEPLAY_SCRIPT, live_drag_object=source_object, live_drag_object_id=object_source_id, live_drag_target=target_object)
if source_object is None:
logger.error('Ending Live Drag with an object that does not exist. object_id: {}'.format(object_source_id), owner='rmccord')
sims4.commands.output('Live Drag object with id: {} does not exist.'.format(object_source_id), _connection)
return
if target_object is None and object_target_id:
logger.error('Ending Live Drag with a drop target that does not exist. object_id: {}'.format(object_target_id), owner='rmccord')
sims4.commands.output('Live Drag target object with id: {} does not exist.'.format(object_target_id), _connection)
return
client = services.client_manager().get_first_client()
if client is None:
logger.error('Client is not connected', owner='rmccord')
sims4.commands.output('Client is not connected.', _connection)
return
if target_object is None:
parent_obj = source_object.parent_object()
if parent_obj is not None:
target_object = parent_obj
client.end_live_drag(source_object, target_object, end_system)
def _award_insurance_money(self):
client = services.client_manager().get_first_client()
active_sim = client.active_sim
if self._insurance_value > 0 and active_sim is not None:
services.active_household().funds.add(self._insurance_value, Consts_pb2.TELEMETRY_INTERACTION_COST, None)
dialog = self.FIRE_INSURANCE_CLAIM_NOTIFICATION(active_sim, SingleSimResolver(active_sim))
dialog.show_dialog(additional_tokens=(self._insurance_value,))
self._insurance_value = 0
def get_active_sim_home_zone_id():
client = services.client_manager().get_first_client()
if client is not None:
active_sim = client.active_sim
if active_sim is not None:
household = active_sim.household
if household is not None:
return household.home_zone_id
def cancel_mixer_interaction(interaction_id, mixer_id, server_ref, context_handle:int=None, _connection=None):
logger.debug('cancel_sub_interaction {0}', interaction_id)
client = services.client_manager().get(_connection)
sim = _active_sim(client)
interaction = sim.find_sub_interaction_by_aop_id(interaction_id, mixer_id)
if interaction is not None and sim.queue.running != interaction:
return interaction.cancel_user(cancel_reason_msg='Command interactions.cancel')
return False
def check_command_permission(self, client_id, command_type):
tgt_client = services.client_manager().get(client_id)
if tgt_client is None:
return False
if command_type == CommandType.Cheat:
household = tgt_client.household
if household is not None:
return household.cheats_enabled
return tgt_client.account.check_command_permission(command_type)
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 automation_test_cheats(enable:bool=False, _connection=None):
tgt_client = services.client_manager().get(_connection)
output = sims4.commands.CheatOutput(_connection)
household = tgt_client.household
household.cheats_enabled = enable
if enable:
output('Cheats are enabled.')
else:
output('Cheats are disabled.')
def push_interaction_on_all_sims(affordance, opt_target:RequiredTargetParam=None, _connection=None):
target = opt_target.get_target() if opt_target is not None else None
client = services.client_manager().get(_connection)
for sim_info in client.selectable_sims:
sim = sim_info.get_sim_instance()
while sim is not None:
context = InteractionContext(sim, InteractionContext.SOURCE_PIE_MENU, Priority.High, client=client, pick=None)
sim.push_super_affordance(affordance, target, context)
return True
def _get_target(self, _connection):
if self._target_id is None:
tgt_client = services.client_manager().get(_connection)
if tgt_client is not None:
return tgt_client.active_sim
return
if self._target_id == self.TARGET_ID_ACTIVE_LOT:
return services.active_lot()
return services.object_manager().get(self._target_id)
def ui_dialog_notification_test(*all_text, _connection=None):
client = services.client_manager().get(_connection)
all_text_str = ' '.join(all_text)
if '/' in all_text:
(title, text) = all_text_str.split('/')
notification = UiDialogNotification.TunableFactory().default(client.active_sim, text=lambda **_: LocalizationHelperTuning.get_raw_text(text), title=lambda **_: LocalizationHelperTuning.get_raw_text(title))
else:
notification = UiDialogNotification.TunableFactory().default(client.active_sim, text=lambda **_: LocalizationHelperTuning.get_raw_text(all_text_str))
notification.show_dialog(icon_override=(None, client.active_sim))
def start_baby_neglect(baby):
baby._started_neglect_moment = True
sim_info = baby.sim_info
dialog = Baby.NEGLECT_NOTIFICATION(sim_info, SingleSimResolver(sim_info))
dialog.show_dialog()
neglect_effect = vfx.PlayEffect(sim_info, 's40_Sims_neglected', sims4.hash_util.hash32('_FX_'))
neglect_effect.start()
camera.focus_on_sim(sim_info, follow=False)
sim_info_manager = services.sim_info_manager()
with genealogy_caching():
for member_id in sim_info.genealogy.get_immediate_family_sim_ids_gen():
member_info = sim_info_manager.get(member_id)
member_info.add_buff_from_op(Baby.NEGLECT_BUFF_IMMEDIATE_FAMILY.buff_type, Baby.NEGLECT_BUFF_IMMEDIATE_FAMILY.buff_reason)
empty_bassinet = _replace_bassinet(sim_info)
empty_bassinet.set_state(Baby.NEGLECT_EMPTY_BASSINET_STATE.state, Baby.NEGLECT_EMPTY_BASSINET_STATE)
services.client_manager().get_first_client().selectable_sims.remove_selectable_sim_info(sim_info)
services.get_persistence_service().del_sim_proto_buff(sim_info.id)
sim_info_manager.remove_permanently(sim_info)
def _classify_sim(sim, household):
if household.is_persistent_npc:
return 4
if household.is_npc_household:
return 3
client = services.client_manager().get_client_by_household_id(household.id)
if sim == client.active_sim:
return 1
return 2
def get_optional_target(opt_target:OptionalTargetParam=None, _connection=None):
if opt_target is not None:
target = opt_target._get_target(_connection)
if target is None:
sims4.commands.output('Object ID not in the object manager: {}.'.format(opt_target._target_id), _connection)
return target
tgt_client = services.client_manager().get(_connection)
if tgt_client is not None:
return tgt_client.active_sim
def force_bills_due(_connection=None):
tgt_client = services.client_manager().get(_connection)
if tgt_client is None:
return False
if tgt_client.household is None:
return False
tgt_client.household.bills_manager.allow_bill_delivery()
tgt_client.household.bills_manager.trigger_bill_notifications_from_delivery()
return True
def return_sim_to_home_lot(self, alarm_handle):
self._return_sim_to_home_lot_alarm_handles.discard(alarm_handle)
sim_info = alarm_handle.owner
if sim_info is None or sim_info.is_instanced(allow_hidden_flags=ALL_HIDDEN_REASONS) or sim_info.is_dead:
return
success = sims.sim_spawner.SimSpawner.spawn_sim(sim_info)
if success:
client = services.client_manager().get_client_by_household_id(sim_info.household_id)
if client is not None:
client.add_selectable_sim_info(sim_info)
def fake_perform_service(service_npc_type, _connection=None):
service_npc_tuning = services.service_npc_manager().get(service_npc_type)
if service_npc_tuning is not None:
tgt_client = services.client_manager().get(_connection)
if tgt_client is None:
return False
household = tgt_client.household
service_npc_tuning.fake_perform(household)
return True
return False
def cancel_service(service_npc_type, max_duration:int=240, _connection=None):
service_npc_tuning = services.service_npc_manager().get(service_npc_type)
if service_npc_tuning is not None:
tgt_client = services.client_manager().get(_connection)
if tgt_client is None:
return False
household = tgt_client.household
services.current_zone().service_npc_service.cancel_service(household, service_npc_tuning)
return True
return False
def _get_default_account(cls):
client = services.client_manager().get_first_client()
if client is not None:
account = client.account
if account is not None:
return account
account = services.account_service().get_account_by_id(cls.SYSTEM_ACCOUNT_ID)
if account is not None:
return account
account = server.account.Account(cls.SYSTEM_ACCOUNT_ID, 'SystemAccount')
return account
def modify_relationship(self, sim_id, value, add=True):
if not add:
return
if not (sim_id not in self._relationships and self.add_relationship(sim_id)):
return
self._relationships[sim_id].add_value(value)
self._send_relationship_data(sim_id)
self._trigger_relationship_changed_callbacks_for_sim_id(sim_id)
client = services.client_manager().get_first_client()
if client is not None and client.active_sim is not None and client.active_sim.sim_id == sim_id:
self._update_state(self._relationships[sim_id])
def disable_sim_transition_path_logging(sim_id:int=None, _connection=None):
output = sims4.commands.AutomationOutput(_connection)
if sim_id is None:
client = services.client_manager().get(_connection)
sim = _active_sim(client)
else:
sim = services.object_manager().get(sim_id)
if sim is None:
output('SimTransitionPathToggleOff; SimId:None')
return False
sim.transition_path_logging = False
output('[AreaInstanceInteraction] SimTransitionPathToggleOff; SimId:%d, Logging:%d' % (sim.id, sim.interaction_logging))
