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))