isaacscript-common 84.0.1 → 84.1.0

package/dist/classes/features/other/RoomHistory.js

@@ -0,0 +1,196 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomHistory = void 0;
+const cachedClasses_1 = require("../../../core/cachedClasses");
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const dimensions_1 = require("../../../functions/dimensions");
+const roomData_1 = require("../../../functions/roomData");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        roomHistory: [],
+    },
+};
+class RoomHistory extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_EARLY, this.postNewRoomEarly],
+        ];
+    }
+    // ModCallbackCustom.POST_NEW_ROOM_EARLY
+    postNewRoomEarly = () => {
+        const level = cachedClasses_1.game.GetLevel();
+        const stage = level.GetStage();
+        const stageType = level.GetStageType();
+        const room = cachedClasses_1.game.GetRoom();
+        const roomType = room.GetType();
+        const seeds = cachedClasses_1.game.GetSeeds();
+        const startSeedString = seeds.GetStartSeedString();
+        const stageID = (0, roomData_1.getRoomStageID)();
+        const dimension = (0, dimensions_1.getDimension)();
+        const roomVariant = (0, roomData_1.getRoomVariant)();
+        const roomSubType = (0, roomData_1.getRoomSubType)();
+        const roomName = (0, roomData_1.getRoomName)();
+        const roomGridIndex = (0, roomData_1.getRoomGridIndex)();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const roomVisitedCount = (0, roomData_1.getRoomVisitedCount)();
+        const roomDescription = {
+            startSeedString,
+            stage,
+            stageType,
+            stageID,
+            dimension,
+            roomType,
+            roomVariant,
+            roomSubType,
+            roomName,
+            roomGridIndex,
+            roomListIndex,
+            roomVisitedCount,
+        };
+        v.run.roomHistory.push(roomDescription);
+    };
+    /**
+     * Helper function to manually delete the last room description from the internal array. This is
+     * useful if a mod needs to send the player to a room temporarily and the room should not count as
+     * the player having traveled to that room.
+     *
+     * @public
+     */
+    deleteLastRoomDescription() {
+        v.run.roomHistory.pop();
+    }
+    /**
+     * Helper function to get the total number of rooms that the player has entered thus far on the
+     * run. (Re-entering the same room will increment the number returned.)
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
+     *
+     * @public
+     */
+    getNumRoomsEntered() {
+        return v.run.roomHistory.length;
+    }
+    /**
+     * Helper function to get information about all of the rooms that a player has visited thus far on
+     * this run.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
+     *
+     * @public
+     */
+    getRoomHistory() {
+        return v.run.roomHistory;
+    }
+    /**
+     * Helper function to get information about the room that was previously visited.
+     *
+     * In the special case of only one room having been visited thus far (i.e. the starting room of
+     * the run), the starting room will be returned.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
+     *
+     * @public
+     */
+    getPreviousRoomDescription() {
+        const previousRoomDescription = v.run.roomHistory.at(-2);
+        if (previousRoomDescription !== undefined) {
+            return previousRoomDescription;
+        }
+        const startingRoomDescription = v.run.roomHistory[0];
+        if (startingRoomDescription !== undefined) {
+            return startingRoomDescription;
+        }
+        error("Failed to find a room description for any rooms thus far on this run.");
+    }
+    /**
+     * Helper function to get information about the most recent room that is stored in the room
+     * history array.
+     *
+     * This is useful in the `POST_ENTITY_REMOVE` callback; see the `isLeavingRoom` function.
+     *
+     * Note that this function can return undefined in the case where it is called on the first room
+     * of the run.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
+     *
+     * @public
+     */
+    getLatestRoomDescription() {
+        return v.run.roomHistory.at(-1);
+    }
+    /**
+     * Helper function to detect if the player is on the first room of the room.
+     *
+     * @public
+     */
+    inFirstRoom() {
+        return v.run.roomHistory.length === 1;
+    }
+    /**
+     * Helper function to detect if the game is in the state where the room index has changed to a new
+     * room, but the entities from the previous room are currently in the process of despawning. (At
+     * this point, the `POST_NEW_ROOM` callback and the `POST_NEW_ROOM_EARLY` callback will not have
+     * fired yet, and there will not be an entry in the room history array for the current room.)
+     *
+     * This function is intended to be used in the `POST_ENTITY_REMOVE` callback to detect when an
+     * entity is despawning.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_HISTORY`.
+     *
+     * @public
+     */
+    isLeavingRoom() {
+        const level = cachedClasses_1.game.GetLevel();
+        const stage = level.GetStage();
+        const stageType = level.GetStageType();
+        const seeds = cachedClasses_1.game.GetSeeds();
+        const startSeedString = seeds.GetStartSeedString();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const roomVisitedCount = (0, roomData_1.getRoomVisitedCount)();
+        const latestRoomDescription = this.getLatestRoomDescription();
+        // Sometimes, this function can be called in situations where entities from the previous run are
+        // being despawned. If this is the case, then the room history will currently be empty.
+        if (latestRoomDescription === undefined) {
+            return false;
+        }
+        return (startSeedString !== latestRoomDescription.startSeedString ||
+            stage !== latestRoomDescription.stage ||
+            stageType !== latestRoomDescription.stageType ||
+            roomListIndex !== latestRoomDescription.roomListIndex ||
+            roomVisitedCount !== latestRoomDescription.roomVisitedCount);
+    }
+}
+exports.RoomHistory = RoomHistory;
+__decorate([
+    decorators_1.Exported
+], RoomHistory.prototype, "deleteLastRoomDescription", null);
+__decorate([
+    decorators_1.Exported
+], RoomHistory.prototype, "getNumRoomsEntered", null);
+__decorate([
+    decorators_1.Exported
+], RoomHistory.prototype, "getRoomHistory", null);
+__decorate([
+    decorators_1.Exported
+], RoomHistory.prototype, "getPreviousRoomDescription", null);
+__decorate([
+    decorators_1.Exported
+], RoomHistory.prototype, "getLatestRoomDescription", null);
+__decorate([
+    decorators_1.Exported
+], RoomHistory.prototype, "inFirstRoom", null);
+__decorate([
+    decorators_1.Exported
+], RoomHistory.prototype, "isLeavingRoom", null);

package/dist/classes/features/other/RunInNFrames.js

@@ -0,0 +1,323 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunInNFrames = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../core/cachedClasses");
+const decorators_1 = require("../../../decorators");
+const ISCFeature_1 = require("../../../enums/ISCFeature");
+const array_1 = require("../../../functions/array");
+const run_1 = require("../../../functions/run");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        queuedGameFunctions: [],
+        queuedRenderFunctions: [],
+        intervalGameFunctions: [],
+        intervalRenderFunctions: [],
+    },
+};
+class RunInNFrames extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    vConditionalFunc = () => false;
+    roomHistory;
+    /** @internal */
+    constructor(roomHistory) {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.ROOM_HISTORY];
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+        this.roomHistory = roomHistory;
+    }
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+        checkExecuteQueuedFunctions(v.run.queuedGameFunctions, gameFrameCount, numRoomsEntered);
+        checkExecuteIntervalFunctions(v.run.intervalGameFunctions, gameFrameCount, numRoomsEntered);
+    };
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        const renderFrameCount = Isaac.GetFrameCount();
+        const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+        checkExecuteQueuedFunctions(v.run.queuedRenderFunctions, renderFrameCount, numRoomsEntered);
+        checkExecuteIntervalFunctions(v.run.intervalRenderFunctions, renderFrameCount, numRoomsEntered);
+    };
+    /**
+     * Helper function to restart on the next render frame. Useful because it is impossible to restart
+     * the game inside of the `POST_NEW_ROOM`, `POST_NEW_LEVEL`, or `POST_GAME_STARTED` callbacks when
+     * a run is first starting.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+     *
+     * @param character Optional. If specified, will restart the game as the specified character.
+     * @public
+     */
+    restartNextRenderFrame(character) {
+        this.runNextRenderFrame(() => {
+            (0, run_1.restart)(character);
+        });
+    }
+    /**
+     * Supply a function to run N game frames from now in the `POST_UPDATE` callback.
+     *
+     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
+     * similar way.
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+     *
+     * @param func The function to run.
+     * @param numGameFrames The amount of game frames to wait before running the function.
+     * @param cancelIfRoomChanges Optional. Whether to cancel running the function if a new room is
+     *                            loaded in the interim. Default is false.
+     * @public
+     */
+    runInNGameFrames(func, numGameFrames, cancelIfRoomChanges = false) {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+        const frameCountToFire = gameFrameCount + numGameFrames;
+        const queuedFunction = {
+            func,
+            frameCountToFire,
+            numRoomsEntered,
+            cancelIfRoomChanges,
+        };
+        v.run.queuedGameFunctions.push(queuedFunction);
+    }
+    /**
+     * Supply a function to run N render frames from now in the `POST_RENDER` callback.
+     *
+     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
+     * similar way.
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+     *
+     * @param func The function to run.
+     * @param numRenderFrames The amount of render frames to wait before running the function.
+     * @param cancelIfRoomChanges Optional. Whether to cancel running the function if a new room is
+     *                            loaded in the interim. Default is false.
+     * @public
+     */
+    runInNRenderFrames(func, numRenderFrames, cancelIfRoomChanges = false) {
+        const renderFrameCount = Isaac.GetFrameCount();
+        const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+        const frameCountToFire = renderFrameCount + numRenderFrames;
+        const queuedFunction = {
+            func,
+            frameCountToFire,
+            numRoomsEntered,
+            cancelIfRoomChanges,
+        };
+        v.run.queuedRenderFunctions.push(queuedFunction);
+    }
+    /**
+     * Supply a function to run on the next `POST_UPDATE` callback.
+     *
+     * For example:
+     *
+     * ```ts
+     * const NUM_EXPLODER_EXPLOSIONS = 5;
+     *
+     * function useItemExploder(player: EntityPlayer) {
+     *   playSound("exploderBegin");
+     *   explode(player, NUM_EXPLODER_EXPLOSIONS);
+     * }
+     *
+     * function explode(player: EntityPlayer, numFramesLeft: int) {
+     *   Isaac.Explode(player, undefined, 1);
+     *   numFramesLeft -= 1;
+     *   if (numFramesLeft === 0) {
+     *     runNextFrame(() => {
+     *       explode(player, numFramesLeft);
+     *     });
+     *   }
+     * }
+     * ```
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+     *
+     * @param func The function to run.
+     * @param cancelIfRoomChanges Optional. Whether to cancel running the function if a new room is
+     *                            loaded in the interim. Default is false.
+     * @public
+     */
+    runNextGameFrame(func, cancelIfRoomChanges = false) {
+        this.runInNGameFrames(func, 1, cancelIfRoomChanges);
+    }
+    /**
+     * Supply a function to run on the next `POST_RENDER` callback.
+     *
+     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
+     * similar way.
+     *
+     * Note that this function will not handle saving and quitting.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+     *
+     * @param func The function to run.
+     * @param cancelIfRoomChanges Optional. Whether to cancel running the function if a new room is
+     *                            loaded in the interim. Default is false.
+     * @public
+     */
+    runNextRenderFrame(func, cancelIfRoomChanges = false) {
+        this.runInNRenderFrames(func, 1, cancelIfRoomChanges);
+    }
+    /**
+     * Supply a function to be repeatedly run on an interval of N game frames in the `POST_UPDATE`
+     * callback. The function will continue to be fired until `false` is returned from the function.
+     *
+     * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+     * corresponding `clearInterval` function. (Instead, the return value from the supplied function
+     * is used to stop the interval.)
+     *
+     * Note that this function will not handle saving and quitting. You must manually restart any
+     * intervals if the player saves and quits in the middle of a run.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+     *
+     * @param func The function to repeatedly run on an interval.
+     * @param numGameFrames The amount of game frames to wait between each run.
+     * @param runImmediately Whether to execute the function right now before waiting for the
+     *                       interval.
+     * @param cancelIfRoomChanges Optional. Whether to cancel running the function if a new room is
+     *                            loaded in the interim. Default is false.
+     * @public
+     */
+    setIntervalGameFrames(func, numGameFrames, runImmediately, cancelIfRoomChanges = false) {
+        if (runImmediately) {
+            const returnValue = func();
+            if (!returnValue) {
+                return;
+            }
+        }
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+        const intervalFunction = {
+            func,
+            frameCountToFire: gameFrameCount + numGameFrames,
+            numRoomsEntered,
+            cancelIfRoomChanges,
+            numIntervalFrames: numGameFrames,
+        };
+        v.run.intervalGameFunctions.push(intervalFunction);
+    }
+    /**
+     * Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
+     * callback. The function will continue to be fired until `false` is returned from the function.
+     *
+     * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+     * corresponding `clearInterval` function. (Instead, the return value from the supplied function
+     * is used to stop the interval.)
+     *
+     * Note that this function will not handle saving and quitting. You must manually restart any
+     * intervals if the player saves and quits in the middle of a run.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+     *
+     * @param func The function to repeatedly run on an interval.
+     * @param numRenderFrames The amount of game frames to wait between each run.
+     * @param runImmediately Whether to execute the function right now before waiting for the
+     *                       interval.
+     * @param cancelIfRoomChanges Optional. Whether to cancel running the function if a new room is
+     *                            loaded in the interim. Default is false.
+     * @public
+     */
+    setIntervalRenderFrames(func, numRenderFrames, runImmediately, cancelIfRoomChanges = false) {
+        if (runImmediately) {
+            const returnValue = func();
+            if (!returnValue) {
+                return;
+            }
+        }
+        const renderFrameCount = Isaac.GetFrameCount();
+        const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+        const intervalFunction = {
+            func,
+            frameCountToFire: renderFrameCount + numRenderFrames,
+            numRoomsEntered,
+            cancelIfRoomChanges,
+            numIntervalFrames: numRenderFrames,
+        };
+        v.run.intervalRenderFunctions.push(intervalFunction);
+    }
+}
+exports.RunInNFrames = RunInNFrames;
+__decorate([
+    decorators_1.Exported
+], RunInNFrames.prototype, "restartNextRenderFrame", null);
+__decorate([
+    decorators_1.Exported
+], RunInNFrames.prototype, "runInNGameFrames", null);
+__decorate([
+    decorators_1.Exported
+], RunInNFrames.prototype, "runInNRenderFrames", null);
+__decorate([
+    decorators_1.Exported
+], RunInNFrames.prototype, "runNextGameFrame", null);
+__decorate([
+    decorators_1.Exported
+], RunInNFrames.prototype, "runNextRenderFrame", null);
+__decorate([
+    decorators_1.Exported
+], RunInNFrames.prototype, "setIntervalGameFrames", null);
+__decorate([
+    decorators_1.Exported
+], RunInNFrames.prototype, "setIntervalRenderFrames", null);
+function checkExecuteQueuedFunctions(
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+queuedFunctions, frameCount, newNumRoomsEntered) {
+    const firingFunctions = queuedFunctions.filter(({ frameCountToFire }) => frameCount >= frameCountToFire);
+    for (const firingFunction of firingFunctions) {
+        const { func, cancelIfRoomChanges, numRoomsEntered } = firingFunction;
+        if (!cancelIfRoomChanges || numRoomsEntered === newNumRoomsEntered) {
+            func();
+        }
+        (0, array_1.arrayRemoveInPlace)(queuedFunctions, firingFunction);
+    }
+}
+function checkExecuteIntervalFunctions(
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+intervalFunctions, frameCount, newNumRoomsEntered) {
+    const firingFunctions = intervalFunctions.filter(({ frameCountToFire }) => frameCount >= frameCountToFire);
+    for (const firingFunction of firingFunctions) {
+        const { func, cancelIfRoomChanges, numRoomsEntered, numIntervalFrames } = firingFunction;
+        let returnValue = false;
+        if (!cancelIfRoomChanges || numRoomsEntered === newNumRoomsEntered) {
+            returnValue = func();
+        }
+        (0, array_1.arrayRemoveInPlace)(intervalFunctions, firingFunction);
+        // Queue the next interval (as long as the function did not return false).
+        if (returnValue) {
+            const newIntervalFunction = {
+                func,
+                frameCountToFire: frameCount + numIntervalFrames,
+                numRoomsEntered,
+                cancelIfRoomChanges,
+                numIntervalFrames,
+            };
+            intervalFunctions.push(newIntervalFunction);
+        }
+    }
+}

package/dist/classes/features/other/RunNextRoom.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunNextRoom = void 0;
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const array_1 = require("../../../functions/array");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        queuedFunctions: [],
+    },
+};
+class RunNextRoom extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    vConditionalFunc = () => false;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_REORDERED, this.postNewRoomReordered],
+        ];
+    }
+    // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+    postNewRoomReordered = () => {
+        for (const func of v.run.queuedFunctions) {
+            func();
+        }
+        (0, array_1.emptyArray)(v.run.queuedFunctions);
+    };
+    /**
+     * Supply a function to run on the next `POST_NEW_ROOM` callback.
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_NEXT_ROOM`.
+     */
+    runNextRoom(func) {
+        v.run.queuedFunctions.push(func);
+    }
+}
+exports.RunNextRoom = RunNextRoom;
+__decorate([
+    decorators_1.Exported
+], RunNextRoom.prototype, "runNextRoom", null);

package/dist/classes/features/other/RunNextRun.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunNextRun = void 0;
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const array_1 = require("../../../functions/array");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    persistent: {
+        queuedFunctions: [],
+    },
+};
+class RunNextRun extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    vConditionalFunc = () => false;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_GAME_STARTED_REORDERED,
+                this.postGameStartedReorderedFalse,
+                [false],
+            ],
+        ];
+    }
+    // ModCallbackCustom.POST_GAME_STARTED_REORDERED
+    // false
+    postGameStartedReorderedFalse = () => {
+        for (const func of v.persistent.queuedFunctions) {
+            func();
+        }
+        (0, array_1.emptyArray)(v.persistent.queuedFunctions);
+    };
+    /**
+     * Supply a function to run on the next `POST_GAME_STARTED` callback.
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_NEXT_ROOM`.
+     *
+     * @public
+     */
+    runNextRun(func) {
+        v.persistent.queuedFunctions.push(func);
+    }
+}
+exports.RunNextRun = RunNextRun;
+__decorate([
+    decorators_1.Exported
+], RunNextRun.prototype, "runNextRun", null);