WolferyScripting / WolferyJS / #11

class ControlledCharacter extends BaseModel implements ControlledCharacterProperties {

    private _pingTimeout!: NodeJS.Timeout | null;

    private _roomProfiles!: RoomProfiles | null;

    private _roomScripts!: RoomScripts | null;

    private onChange = this._onChange.bind(this);

    private onExitAdd = this._onExitAdd.bind(this);

    private onExitChange = this._onExitChange.bind(this);

    private onExitRemove = this._onExitRemove.bind(this);

    private onLookedAtChange = this._onLookedAtChange.bind(this);

    private onNodeAdd = this._onNodeAdd.bind(this);

    private onNodeRemove = this._onNodeRemove.bind(this);

    private onOut = this._onOut.bind(this);

    private onOwnedAreaAdd = this._onOwnedAreaAdd.bind(this);

    private onOwnedAreaRemove = this._onOwnedAreaRemove.bind(this);

    private onOwnedRoomAdd = this._onOwnedRoomAdd.bind(this);

    private onOwnedRoomRemove = this._onOwnedRoomRemove.bind(this);

    private onProfileAdd = this._onProfileAdd.bind(this);

    private onProfileRemove = this._onProfileRemove.bind(this);

    private onRoomCharAdd = this._onRoomCharAdd.bind(this);

    private onRoomCharRemove = this._onRoomCharRemove.bind(this);

    private onRoomProfileAdd = this._onRoomProfileAdd.bind(this);

    private onRoomProfileRemove = this._onRoomProfileRemove.bind(this);

    private onRoomScriptAdd = this._onRoomScriptAdd.bind(this);

    private onRoomScriptRemove = this._onRoomScriptRemove.bind(this);

    private roomExitAwakeCharAddListeners!: Array<{ exit: Exit; fn: AnyFunction; }>;

    private roomExitAwakeCharRemoveListeners!: Array<{ exit: Exit; fn: AnyFunction; }>;

    constructor(client: WolferyJS, api: ResClient, rid: string) {

        super(client, api, rid, { definition: ControlledCharacterDefinition });

        this.p

            .writable("_pingTimeout", null)

            .writable("_roomProfiles", null)

            .writable("_roomScripts", null)

            .writable("onChange")

            .writable("onExitAdd")

            .writable("onExitChange")

            .writable("onExitRemove")

            .writable("onLookedAtChange")

            .writable("onNodeAdd")

            .writable("onNodeRemove")

            .writable("onOut")

            .writable("onOwnedAreaAdd")

            .writable("onOwnedAreaRemove")

            .writable("onOwnedRoomAdd")

            .writable("onOwnedRoomRemove")

            .writable("onProfileAdd")

            .writable("onProfileRemove")

            .writable("onRoomCharAdd")

            .writable("onRoomCharRemove")

            .writable("onRoomProfileAdd")

            .writable("onRoomProfileRemove")

            .writable("onRoomScriptAdd")

            .writable("onRoomScriptRemove")

            .writable("roomExitAwakeCharAddListeners", [])

            .writable("roomExitAwakeCharRemoveListeners", []);

    }

    private async _onChange(data: Partial<this>): Promise<void> {

        if (data.lookingAt !== undefined) {

            this.client.emit("lookAtChange", this, this.lookingAt?.char ?? null, data.lookingAt?.char ?? null);

        }

        if (data.lookedAt !== undefined) {

            await this._listenLookedAt(false, data.lookedAt);

            await this._listenLookedAt(true, this.lookedAt);

        }

        if (data.inRoom !== undefined) {

            await this._listenRoom(false, data.inRoom);

            await this._listenRoom(true, this.inRoom);

        }

    }

    private _onExitAdd(data: CollectionAddRemove<Exit>): void {

        this._listenExit(true, data.item);

        data.item.resourceOn("change", this.onExitChange);

        this.client.emit("exits.add", this, this.inRoom, data.item);

    }

    private _onExitChange(data: Partial<Exit>, exit: Exit): void {

        this.client.emit("exits.change", this, this.inRoom, exit, data);

        if (data.target !== undefined) {

            if (data.target === null) {

                this._listenExit(false, exit);

                this._listenExit(true, exit);

            } else {

                const add = this.roomExitAwakeCharAddListeners.find(e => e.exit.id === exit.id);

                const remove = this.roomExitAwakeCharRemoveListeners.find(e => e.exit.id === exit.id);

                if (add) {

                    data.target.awake?.resourceOff("add", add.fn);

                    this.roomExitAwakeCharAddListeners.splice(this.roomExitAwakeCharAddListeners.indexOf(add), 1);

                }

                if (remove) {

                    data.target.awake?.resourceOff("remove", remove.fn);

                    this.roomExitAwakeCharRemoveListeners.splice(this.roomExitAwakeCharRemoveListeners.indexOf(remove), 1);

                }

            }

        }

    }

    private _onExitRemove(data: CollectionAddRemove<Exit>): void {

        this._listenExit(false, data.item);

        data.item.resourceOff("change", this.onExitChange);

        this.client.emit("exits.remove", this, this.inRoom, data.item);

    }

    private async _onLookedAtChange(data: Record<string, true>): Promise<void> {

        const added: Array<string> = [], removed: Array<string> = [];

        for (const [key] of Object.entries(this.lookedAt.props)) {

            if (data[key] === undefined) {

                added.push(key);

            }

        }

        for (const [key] of Object.entries(data)) {

            if (this.lookedAt.props[key] === undefined) {

                removed.push(key);

            }

        }

        // we could mess around with RoomCharacter instances, but they can be unreliable, and we aren't missing anything

        for (const add of added) {

            const char = await this.api.get<Character>(ResourceIDs.CHARACTER({ id: add }));

            this.client.emit("lookedAt.add", this, char);

        }

        for (const remove of removed) {

            const char =  await this.api.get<Character>(ResourceIDs.CHARACTER({ id: remove }));

            this.client.emit("lookedAt.remove", this, char);

        }

    }

    private _onNodeAdd(data: CollectionAddRemove<Node>): void {

        this.client.emit("characterNodes.add", this, data.item);

    }

    private _onNodeRemove(data: CollectionAddRemove<Node>): void {

        this.client.emit("characterNodes.remove", this, data.item);

    }

    private async _onOut(data: Messages.Any): Promise<void> {

        const sent = "char" in data && this.id === data.char.id;

        if (data.type === "broadcast") return; // do characters even get these?

        if (data.type === "privateDescribe") {

            const target = await this.api.get<Character>(ResourceIDs.CHARACTER({ id: data.target.id }));

            this.client.emit("message", "privateDescribe", sent, this, data.msg, target, data.script);

            return;

        }

        if (data.type === "info") {

            this.client.emit("message", "info", sent, this, data.msg);

            return;

        }

        const char = await this.api.get<Character>(ResourceIDs.CHARACTER({ id: data.char.id }));

        switch (data.type) {

            case "wakeup":

            case "sleep":

            case "leave":

            case "arrive": {

                this.client.emit("message", data.type, sent, this, char, data.msg, data.method);

                break;

            }

            case "travel": {

                this.client.emit("message", "travel", sent, this, char, data.msg, data.targetRoom, data.method);

                break;

            }

            case "say":

            case "pose": {

                this.client.emit("message", data.type, sent, this, char, data.msg);

                break;

            }

            case "ooc": {

                this.client.emit("message", data.type, sent, this, char, data.msg, !!data.pose);

                break;

            }

            case "address":

            case "whisper":

            case "message":

            case "mail": {

                const target = await this.api.get<Character>(ResourceIDs.CHARACTER({ id: data.target.id }));

                this.client.emit("message", data.type, sent, this, char, data.msg, target, !!data.pose, !!data.ooc);

                break;

            }

            case "action":

            case "describe": {

                this.client.emit("message", data.type, sent, this, char, data.msg);

                break;

            }

            case "roll": {

                this.client.emit("message", "roll", sent, this, char, data.total, data.result, !!data.quiet);

                break;

            }

        }

    }

    private _onOwnedAreaAdd(data: CollectionAddRemove<Area>): void {

        this.client.emit("ownedAreas.add", this, data.item);

    }

    private _onOwnedAreaRemove(data: CollectionAddRemove<Area>): void {

        this.client.emit("ownedAreas.remove", this, data.item);

    }

    private _onOwnedRoomAdd(data: CollectionAddRemove<Room>): void {

        this.client.emit("ownedRooms.add", this, data.item);

    }

    private _onOwnedRoomRemove(data: CollectionAddRemove<Room>): void {

        this.client.emit("ownedRooms.remove", this, data.item);

    }

    private _onProfileAdd(data: CollectionAddRemove<Profile>): void {

        this.client.emit("profiles.add", this, data.item);

    }

    private _onProfileRemove(data: CollectionAddRemove<Profile>): void {

        this.client.emit("profiles.remove", this, data.item);

    }

    private _onRoomCharAdd(data: CollectionAddRemove<RoomCharacter>): void {

        this.client.emit("roomCharacters.add", this, this.inRoom, data.item);

    }

    private _onRoomCharRemove(data: CollectionAddRemove<RoomCharacter>): void {

        this.client.emit("roomCharacters.remove", this, this.inRoom, data.item);

    }

    private _onRoomExitAwakeCharAdd(char: Character, exit: Exit, room: AfarRoom): void {

        this.client.emit("roomCharacters.exit.add", this, room, exit, char);

    }

    private _onRoomExitAwakeCharRemove(char: Character, exit: Exit, room: AfarRoom): void {

        this.client.emit("roomCharacters.exit.remove", this, room, exit, char);

    }

    private _onRoomProfileAdd(data: CollectionAddRemove<RoomProfile>): void {

        this.client.emit("roomProfiles.add", this, this.inRoom, data.item);

    }

    private _onRoomProfileRemove(data: CollectionAddRemove<RoomProfile>): void {

        this.client.emit("roomProfiles.remove", this, this.inRoom, data.item);

    }

    private _onRoomScriptAdd(data: CollectionAddRemove<RoomScript>): void {

        this.client.emit("roomScripts.add", this, this.inRoom, data.item);

    }

    private _onRoomScriptRemove(data: CollectionAddRemove<RoomScript>): void {

        this.client.emit("roomScripts.remove", this, this.inRoom, data.item);

    }

    protected override async _listen(on: boolean): Promise<void> {

        await super._listen(on);

        const m = on ? "resourceOn" : "resourceOff";

        this[m]("change", this.onChange);

        this[m]("out", this.onOut);

        await this._listenLookedAt(on, this.lookedAt);

        if (this.client.options.pingCharacters) {

            if (on) {

                this._pingTimeout = setInterval(() => this.ping(),  PING_DURATION);

            } else if (this._pingTimeout) {

                clearInterval(this._pingTimeout);

            }

        }

        await this._listenRoom(on, this.inRoom);

        this.profiles[m]("add", this.onProfileAdd);

        this.profiles[m]("remove", this.onProfileRemove);

        this.ownedAreas[m]("add", this.onOwnedAreaAdd);

        this.ownedAreas[m]("remove", this.onOwnedAreaRemove);

        this.ownedRooms[m]("add", this.onOwnedRoomAdd);

        this.ownedRooms[m]("remove", this.onOwnedRoomRemove);

        this.nodes[m]("add", this.onNodeAdd);

    }

    protected _listenExit(on: boolean, exit: Exit): void {

        if (on && exit.target?.awake) {

            const room = exit.target;

            const add = (data: CollectionAddRemove<Character>): void => this._onRoomExitAwakeCharAdd(data.item, exit, room);

            const remove = (data: CollectionAddRemove<Character>): void => this._onRoomExitAwakeCharRemove(data.item, exit, room);

            exit.target.awake.resourceOn("add", add);

            exit.target.awake.resourceOn("remove", remove);

            this.roomExitAwakeCharAddListeners.push({ exit, fn: add });

            this.roomExitAwakeCharRemoveListeners.push({ exit, fn: remove });

        } else if  (!on) {

            const add = this.roomExitAwakeCharAddListeners.find(e => e.exit.id === exit.id);

            const remove = this.roomExitAwakeCharRemoveListeners.find(e => e.exit.id === exit.id);

            if (add) {

                exit.target?.awake?.resourceOff("add", add.fn);

                this.roomExitAwakeCharAddListeners.splice(this.roomExitAwakeCharAddListeners.indexOf(add), 1);

            }

            if (remove) {

                exit.target?.awake?.resourceOff("remove", remove.fn);

                this.roomExitAwakeCharRemoveListeners.splice(this.roomExitAwakeCharRemoveListeners.indexOf(remove), 1);

            }

        }

    }

    protected async _listenLookedAt(on: boolean, lookedAt: LookedAt): Promise<void> {

        const m = on ? "resourceOn" : "resourceOff";

        lookedAt[m]("change", this.onLookedAtChange);

    }

    protected async _listenRoom(on: boolean, room: RoomDetails): Promise<void> {

        if (on) {

            room.exits.resourceOn("add", this.onExitAdd);

            room.exits.resourceOn("remove", this.onExitRemove);

            for (const exit of room.exits) {

                exit.resourceOn("change", this.onExitChange);

                this._listenExit(on, exit);

            }

            room.chars?.resourceOn("add", this.onRoomCharAdd);

            room.chars?.resourceOn("remove", this.onRoomCharRemove);

            if (room.owner.id === this.id) {

                // we own the room, listen for profile & script changes

                this._roomProfiles = await room.getProfiles();

                this._roomScripts = await room.getScripts();

                this._roomProfiles.resourceOn("add", this.onRoomProfileAdd);

                this._roomProfiles.resourceOn("remove", this.onRoomProfileRemove);

                this._roomScripts.resourceOn("add", this.onRoomScriptAdd);

                this._roomScripts.resourceOn("remove", this.onRoomScriptRemove);

            }

        } else {

            room.exits.resourceOff("add", this.onExitAdd);

            room.exits.resourceOff("remove", this.onExitRemove);

            for (const exit of room.exits) {

                exit.resourceOff("change", this.onExitChange);

                this._listenExit(on, exit);

            }

            this.roomExitAwakeCharAddListeners = [];

            this.roomExitAwakeCharRemoveListeners = [];

            room.chars?.resourceOff("add", this.onRoomCharAdd);

            room.chars?.resourceOff("remove", this.onRoomCharRemove);

            if (this._roomProfiles) {

                this._roomProfiles.resourceOff("add", this.onRoomProfileAdd);

                this._roomProfiles.resourceOff("remove", this.onRoomProfileRemove);

                this._roomProfiles = null;

            }

            if (this._roomScripts) {

                this._roomScripts.resourceOff("add", this.onRoomScriptAdd);

                this._roomScripts.resourceOff("remove", this.onRoomScriptRemove);

                this._roomScripts = null;

            }

        }

    }

    get avatarURL(): string | null {

        return this.avatar === "" ? null : `${this.client.fileURL}/core/char/avatar/${this.avatar}`;

    }

    get fullname(): string {

        return `${this.name} ${this.surname}`.trim();

    }

    get isPuppet(): boolean {

        return ResourceIDs.CONTROLLED_PUPPET.regex.test(this.rid);

    }

    /**

     * Accept a control request for a character.

     * @param charId The ID of the character to accept control for.

     */

    async acceptControl(charId: string): Promise<null> {

        return this.call<null>("controlRequestAccept", { charId });

    }

    /**

     * Add a tag to this character.

     * @param tagId The ID of the tag to add.

     * @param pref The preference for the tag.

     */

    async addTag(tagId: string, pref: "like" | "dislike"): Promise<null> {

        return this.tags.add(tagId, pref);

    }

    /**

     * Add a new teleport node.

     * @param options The options for the teleport node.

     */

    async addTeleport(options: Commands.ControlledCharacter.AddTeleportOptions): Promise<null> {

        return this.call<null>("addTeleport", options);

    }

    /**

     * Address a character. This is the equivalent of the `@` command in the web client.

     * @param charId The ID of the character to address.

     * @param options The options for addressing the character.

     */

    async address(charId: string, options: Commands.ControlledCharacter.AddressOptions): Promise<null> {

        return this.call<null>("address", { charId, ...options });

    }

    /** Set this character as away (afk). */

    async away(status?: string): Promise<null> {

        return this.call<null>("away", { status });

    }

    /**

     * Copy this character's avatar to the profile.

     * @param profileId The ID of the profile to copy the avatar to.

     * @returns The profile.

     */

    async copyProfileAvatar(profileId: string): Promise<Profile> {

        return this.call<Record<"profile", NameBasicResponse>>("copyProfileAvatar", { profileId })

            .then(r => this.api.get<Profile>(ResourceIDs.PROFILE({ id: r.profile.id })));

    }

    /**

     * Copy this character's image to the profile.

     * @param profileId The ID of the profile to copy the image to.

     * @returns The profile.

     */

    async copyProfileImage(profileId: string): Promise<Profile> {

        return this.call<Record<"profile", NameBasicResponse>>("copyProfileImage", { profileId })

            .then(r => this.api.get<Profile>(ResourceIDs.PROFILE({ id: r.profile.id })));

    }

    /**

     * Create a new area.

     * @param name The name of the area.

     */

    async createArea(name: string): Promise<Area> {

        return this.call<NameBasicResponse>("createArea", { name })

            .then(r => this.client.waitForCached<Area>(ResourceIDs.AREA({ id: r.id })));

    }

    /**

     * Create an exit to another room.

     * @param name The name of the exit.

     * @param keys The keys to use to go through the exit.

     * @param targetRoom The ID of the room to go to. Provide `null` to create a new room.

     */

    async createExit(name: string, keys: Array<string>, targetRoom: string | null): Promise<{ exit: Exit; targetRoom: Room; }> {

        return this.call<Record<"exit" | "targetRoom", NameBasicResponse>>("createExit", { name, keys, targetRoom }).then(async r => {

            const [exit, room] = await Promise.all([this.client.waitForCached<Exit>(ResourceIDs.EXIT({ id: r.exit.id })), this.client.waitForCached<Room>(ResourceIDs.ROOM({ id: r.targetRoom.id }))]);

            return { exit, targetRoom: room };

        });

    }

    /**

     * Create a profile based on this character's current attributes.

     * @param name The name of the profile.

     * @param key The key of the profile.

     */

    async createProfile(name: string, key: string): Promise<Profile> {

        return this.call<Record<"profile", NameBasicResponse>>("createProfile", { name, key }).then(r => this.client.waitForCached<Profile>(ResourceIDs.PROFILE({ id: r.profile.id })));

    }

    /**

     * Create a room.

     * @param name The name of the room.

     */

    async createRoom(name: string): Promise<Room> {

        return this.call<NameBasicResponse>("createRoom", { name }).then(r => this.client.waitForCached<Room>(ResourceIDs.ROOM({ id: r.id })));

    }

    /**

     * Create a room profile. You must own the room, and be present in it.

     * @param name The name of the room profile.

     * @param key The key of the room profile.

     */

    async createRoomProfile(name: string, key: string): Promise<RoomProfile> {

        return this.call<Record<"profile", NameBasicResponse>>("createRoomProfile", { name, key }).then(r => this.client.waitForCached<RoomProfile>(ResourceIDs.ROOM_PROFILE({ id: r.profile.id })));

    }

    /**

     * Create a room script. It will be created in the room the character is located in.

     * @param key The key of the room script.

     * @param options The options for the room script.

     */

    async createRoomScript(key: string, options?: Commands.ControlledCharacter.CreateRoomScriptOptions): Promise<{ room: Room; script: RoomScript; }> {

        return this.call<{ room: NameBasicResponse; script: KeyBasicResponse; }>("createRoomScript", { key, ...options }).then(async r => {

            const [room, script] = await Promise.all([

                this.api.get<Room>(ResourceIDs.ROOM({ id: r.room.id })),

                this.api.get<RoomScript>(ResourceIDs.ROOMSCRIPT({ id: r.script.id }))

            ]);

            return { room, script };

        });

    }

    /**

     * Delete an area.

     * @param areaId The ID of the area to delete.

     */

    async deleteArea(areaId: string): Promise<{ area: Area; response: DeleteNameResponse; }> {

        const area = await this.api.get<Area>(ResourceIDs.AREA({ id: areaId }));

        return this.call<DeleteNameResponse>("deleteArea", { areaId })

            .then(r => ({ area, response: r }));

    }

    /**

     * Delete an exit.

     * @param exitId The ID of the exit to delete.

     */

    async deleteExit(exitId: string): Promise<Exit> {

        const exit = this.api.get<Exit>(ResourceIDs.EXIT({ id: exitId }));

        return this.call<null>("deleteExit", { exitId }).then(() => exit);

    }

    /**

     * Delete a mail message. You must be using the username/password authentication method to use this.

     * @param messageId The ID of the message to delete.

     */

    async deleteMail(messageId: string): Promise<null> {

        return this.client.modules.core.getPlayer().then(player =>

            this.api.call<null>(ResourceIDs.PLAYER_MAIL_MESSAGE({ player: player.id, message: messageId }), "delete")

        );

    }

    /**

     * Delete a profile.

     * @param profileId The ID of the profile to delete.

     */

    async deleteProfile(profileId: string): Promise<Profile> {

        const profile = await this.api.get<Profile>(ResourceIDs.PROFILE({ id: profileId }));

        return this.call<Record<"profile", NameBasicResponse>>("deleteProfile", { profileId })

            .then(() => profile);

    }

    /**

     * Delete a room.

     * @param roomId The ID of the room to delete.

     */

    async deleteRoom(roomId: string): Promise<Room> {

        const room = await this.api.get<Room>(ResourceIDs.ROOM({ id: roomId }));

        return this.call<null>("deleteRoom", { roomId })

            .then(() => room);

    }

    /**

     * Delete a room profile. You must own the room, and be present in it.

     * @param profileId The ID of the room profile to delete.

     */

    async deleteRoomProfile(profileId: string): Promise<Record<"profile", NameBasicResponse>> {

        return this.call<Record<"profile", NameBasicResponse>>("deleteRoomProfile", { profileId });

    }

    /**

     * Delete a room script. You must own the room, and be present in it.

     * @param scriptId The ID of the room script to delete.

     */

    async deleteRoomScript(scriptId: string): Promise<{ room: Room; script: RoomScript | KeyBasicResponse; }> {

        return this.call<{ room: NameBasicResponse; script: KeyBasicResponse; }>("deleteRoomScript", { scriptId }).then(async r => {

            const room = await this.api.get<Room>(ResourceIDs.ROOM({ id: r.room.id }));

            const script = this.api.getCached<RoomScript>(ResourceIDs.ROOMSCRIPT({ id: r.script.id })) ?? r.script;

            return { room, script };

        });

    }

    /**

     * Describe a scene or action.

     * @param msg The message.

     */

    async describe(msg: string): Promise<null> {

        return this.call<null>("describe", { msg });

    }

    /**

     * Evict a character from their teleport nodes or home for the current room.

     * @param charId The ID of the character to evict.

     * @returns The evicted character.

     */

    async evict(charId: string): Promise<Character> {

        return this.call<BasicCharacterResponse<"targetChar">>("evict", { charId })

            .then(r => this.api.get<Character>(ResourceIDs.CHARACTER({ id: r.targetChar.id })));

    }

    /**

     * Evict a character from their home in the current room.

     * @param charId The ID of the character to evict.

     * @returns The evicted character.

     */

    async evictHome(charId: string): Promise<Character> {

        return this.call<BasicCharacterResponse<"char">>("evictHome", { charId })

            .then(r => this.api.get<Character>(ResourceIDs.CHARACTER({ id: r.char.id })));

    }

    /**

     * Evict a character from controlling a puppet.

     * @param charId The ID of the character to evict.

     * @param puppetId The ID of the puppet to evict.

     * @returns The evicted character and puppet.

     */

    async evictPuppeteer(charId: string, puppetId: string): Promise<{ char: Character; puppet: Character; }> {

        return this.call<BasicCharacterResponse<"char"> & BasicCharacterResponse<"puppet">>("evictPuppeteer", { charId, puppetId })

            .then(async r => {

                const [char, puppet] = await Promise.all([

                    this.api.get<Character>(ResourceIDs.CHARACTER({ id: r.char.id })),

                    this.api.get<Character>(ResourceIDs.CHARACTER({ id: r.puppet.id }))

                ]);

                return { char, puppet };

            });

    }

    /**

     * Evict a character from their teleport node.

     * @param charId The ID of the character to evict.

     * @returns The evicted character.

     */

    async evictTeleport(charId: string): Promise<Character> {

        return this.call<BasicCharacterResponse<"char">>("evictTeleport", { charId })

            .then(r => this.api.get<Character>(ResourceIDs.CHARACTER({ id: r.char.id })));

    }

    /**

     * Focus a character.

     * Focus a character.

     * @param targetId The ID of the character to focus.

     * @param options The options for focusing the character.

     * @returns The focused character.

     */

    async focusChar(targetId: string, options: Omit<Commands.Player.FocusCharOptions, "targetId">): Promise<Character> {

        return this.client.modules.core.getPlayer().then(player =>

            player.focusChar(this.id, { targetId, ...options })

        );

    }

    /**

     * Request to follow a character.

     * @param charId The ID of the character to follow.

     */

    async follow(charId: string): Promise<null> {

        return this.call<null>("follow", { charId });

    }

    /**

     * Get the character for this controlled character.

     * @returns The character.

     */

    async getChar(): Promise<Character> {

        return this.api.get<Character>(ResourceIDs.CHARACTER({ id: this.id }));

    }

    /**

     * Get an exit in the current room.

     * @param options The options for getting the exit.

     * @returns The exit.

     */

    async getExit(options: Commands.ControlledCharacter.GetExitOptions): Promise<Exit> {

        return this.call<Exit>("getExit", options);

    }

    async getLogEvents(startTime?: number): Promise<Commands.LogEvents> {

        return this.api.call<Commands.LogEvents>("log.events", "get", { charId: this.id, startTime });

    }

    /**

     * Get the owned character for this controlled character. If the character is a puppet, use {@link getPuppet} instead.

     * @returns The owned character.

     */

    async getOwnedChar(): Promise<OwnedCharacter> {

        return this.api.get<OwnedCharacter>(ResourceIDs.OWNED_CHARACTER({ id: this.id }));

    }

    /**

     * Get the puppet for this controlled character. If the character is not a puppet, use {@link getOwnedChar} instead.

     * @returns The controlled puppet.

     */

    async getPuppet(): Promise<Puppet> {

        const { char, puppet } = ResourceIDs.CONTROLLED_PUPPET.parts(this.rid);

        return this.api.get<Puppet>(ResourceIDs.PUPPET({ char, puppet }));

    }

    /**

     * Get the room character for this controlled character.

     * @returns The room character.

     */

    async getRoomChar(): Promise<RoomCharacter> {

        return this.api.get<RoomCharacter>(ResourceIDs.ROOM_CHARACTER({ id: this.id }));

    }

    /**

     * Send a message to the helpers.

     * @param msg The message.

     */

    async helpme(msg: string): Promise<null> {

        return this.call<null>("helpme", { msg });

    }

    /**

     * Request to join a character.

     * @param charId The ID of the character to join.

     */

    async join(charId: string): Promise<null> {

        return this.call<null>("join", { charId });

    }

    /**

     * Request to lead a character.

     * @param charId The ID of the character to lead.

     */

    async lead(charId: string): Promise<null> {

        return this.call<null>("lead", { charId });

    }

    /**

     * Set the LFRP status for the character.

     * @param msg The message to display when LFRP is enabled.

     */

    async lfrp(msg?: string): Promise<null> {

        if (msg) {

            await this.client.modules.core.getPlayer().then(player => player.setCharSettings(this.id, { lfrpDesc: msg }));

        }

        return this.call<null>("set", { rp: "lfrp" });

    }

    /**

     * Look at a character.

     * @param charId The ID of the character to look at.

     */

    async look(charId: string): Promise<null> {

        return this.call<null>("look", { charId });

    }

    /**

     * Send a mail to a character. You must be using the username/password authentication method to use this.

     * @param toCharId The ID of the character to send the mail to.

     * @param options The options for the mail.

     */

    async mail(toCharId: string, options: Commands.Inbox.SendOptions): Promise<Character> {

        return this.client.modules.core.getPlayer().then(player => player.getInbox()).then(inbox => inbox.send(this.id, toCharId, options));

    }

    /**

     * Send a message to a character.

     * @param charId The ID of the character to send the message to.

     * @param options The options for sending the message.

     */

    async message(charId: string, options: Commands.ControlledCharacter.MessageOptions): Promise<null> {

        return this.call<null>("message", { charId, ...options });

    }

    /**

     * Teleport to a node.

     * @param nodeId The ID of the node to teleport to.

     */

    async nodeTeleport(nodeId: string): Promise<null> {

        return this.teleport({ nodeId });

    }

    /**

     * Send an OOC message.

     * @param options The options for the OOC message.

     */

    async ooc(options: Commands.ControlledCharacter.OOCOptions): Promise<null> {

        return this.call<null>("ooc", options);

    }

    /** Send a ping to avoid being released for inactivity. */

    async ping(): Promise<null> {

        return this.call<null>("ping");