isaacscript-common 84.0.0 → 84.1.0

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

@@ -0,0 +1,102 @@
+"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.PlayerCollectibleTracking = void 0;
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const array_1 = require("../../../functions/array");
+const collectibles_1 = require("../../../functions/collectibles");
+const playerDataStructures_1 = require("../../../functions/playerDataStructures");
+const DefaultMap_1 = require("../../DefaultMap");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        playersCollectibleTypes: new DefaultMap_1.DefaultMap(() => []),
+    },
+};
+class PlayerCollectibleTracking extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED,
+                this.postPlayerCollectibleAdded,
+            ],
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED,
+                this.postPlayerCollectibleRemoved,
+            ],
+        ];
+    }
+    // ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED
+    postPlayerCollectibleAdded = (player, collectibleType) => {
+        const collectibleTypes = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersCollectibleTypes, player, player);
+        collectibleTypes.push(collectibleType);
+    };
+    // ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED
+    postPlayerCollectibleRemoved = (player, collectibleType) => {
+        const collectibleTypes = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersCollectibleTypes, player, player);
+        (0, array_1.arrayRemoveInPlace)(collectibleTypes, collectibleType);
+    };
+    /**
+     * Helper function to get all of the collectible types that the player has gotten so far on this
+     * run, in order.
+     *
+     * In the case of items given on the first frame of the run or the case where the player rerolls
+     * their build in the middle of the run (e.g. with D4), the order of the collectible types will
+     * not correspond to the order that the items were actually given to the player. In this case, the
+     * order will be from the lowest `CollectibleType` to the highest.
+     *
+     * Under the hood, this feature works by tracking the number of collectibles that a player has on
+     * every frame. Thus, in a situation where a collectible was both added and removed to the player
+     * on the same frame, the amount of total collectibles would stay the same, and the collectible
+     * types would not be updated. In vanilla, this situation would never happen, but another mod
+     * might do this for some reason. (With that said, the next time that a collectible is normally
+     * added or removed, it would trigger a re-scan, and the previous changes would be picked up.)
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.PLAYER_COLLECTIBLE_TRACKING`.
+     *
+     * @param player The player to get the collectible types for.
+     * @param includeActiveCollectibles Optional. If true, will include all active collectibles.
+     *                                Default is true.
+     * @public
+     */
+    getPlayerCollectibleTypes(player, includeActiveCollectibles = true) {
+        const collectibleTypes = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersCollectibleTypes, player, player);
+        if (includeActiveCollectibles) {
+            return collectibleTypes;
+        }
+        return collectibleTypes.filter((collectibleType) => !(0, collectibles_1.isActiveCollectible)(collectibleType));
+    }
+    /**
+     * Helper function to get the last passive collectible type that the player picked up. In most
+     * cases, this will be the passive that would be removed if the player used Clicker.
+     *
+     * Returns undefined if the player does not have any passive collectibles.
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.PLAYER_COLLECTIBLE_TRACKING`.
+     *
+     * @public
+     */
+    getPlayerLastPassiveCollectibleType(player) {
+        const collectibleTypes = this.getPlayerCollectibleTypes(player, false);
+        return collectibleTypes.at(-1);
+    }
+}
+exports.PlayerCollectibleTracking = PlayerCollectibleTracking;
+__decorate([
+    decorators_1.Exported
+], PlayerCollectibleTracking.prototype, "getPlayerCollectibleTypes", null);
+__decorate([
+    decorators_1.Exported
+], PlayerCollectibleTracking.prototype, "getPlayerLastPassiveCollectibleType", null);

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

@@ -0,0 +1,86 @@
+"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.PonyDetection = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const flag_1 = require("../../../functions/flag");
+const playerDataStructures_1 = require("../../../functions/playerDataStructures");
+const playerIndex_1 = require("../../../functions/playerIndex");
+const Feature_1 = require("../../private/Feature");
+const FLAGS_WHEN_PONY_IS_ACTIVE = [
+    isaac_typescript_definitions_1.EntityFlag.NO_KNOCKBACK,
+    isaac_typescript_definitions_1.EntityFlag.NO_PHYSICS_KNOCKBACK,
+    isaac_typescript_definitions_1.EntityFlag.NO_DAMAGE_BLINK, // 1 << 36
+];
+const v = {
+    run: {
+        playersIsPonyActive: new Set(),
+    },
+};
+class PonyDetection extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        const effects = player.GetEffects();
+        const entityFlags = player.GetEntityFlags();
+        const hasPonyCollectibleEffect = effects.HasCollectibleEffect(isaac_typescript_definitions_1.CollectibleType.PONY) ||
+            effects.HasCollectibleEffect(isaac_typescript_definitions_1.CollectibleType.WHITE_PONY);
+        const isPonyActiveOnPreviousFrame = (0, playerDataStructures_1.setHasPlayer)(v.run.playersIsPonyActive, player);
+        const hasPonyFlags = (0, flag_1.hasFlag)(entityFlags, ...FLAGS_WHEN_PONY_IS_ACTIVE);
+        const isPonyActiveNow = hasPonyCollectibleEffect || (isPonyActiveOnPreviousFrame && hasPonyFlags);
+        if (isPonyActiveNow) {
+            (0, playerDataStructures_1.setAddPlayer)(v.run.playersIsPonyActive, player);
+        }
+        else {
+            (0, playerDataStructures_1.setDeletePlayer)(v.run.playersIsPonyActive, player);
+        }
+    };
+    /**
+     * Helper function to see if the player is under the effects of A Pony or White Pony charge.
+     * Detecting this is difficult, as the temporary effect will disappear upon entering a new room.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.PONY_DETECTION`.
+     *
+     * @public
+     */
+    isPlayerUsingPony(player) {
+        return (0, playerDataStructures_1.setHasPlayer)(v.run.playersIsPonyActive, player);
+    }
+    /**
+     * Helper function to see if any player is under the effects of A Pony or White Pony charge.
+     * Detecting this is difficult, as the temporary effect will disappear upon entering a new room.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.PONY_DETECTION`.
+     *
+     * @public
+     */
+    anyPlayerUsingPony() {
+        const players = (0, playerIndex_1.getPlayers)();
+        return players.some((player) => this.isPlayerUsingPony(player));
+    }
+}
+exports.PonyDetection = PonyDetection;
+__decorate([
+    decorators_1.Exported
+], PonyDetection.prototype, "isPlayerUsingPony", null);
+__decorate([
+    decorators_1.Exported
+], PonyDetection.prototype, "anyPlayerUsingPony", null);

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

@@ -0,0 +1,71 @@
+"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.PressInput = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const decorators_1 = require("../../../decorators");
+const playerIndex_1 = require("../../../functions/playerIndex");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        buttonActionPairs: [],
+    },
+};
+class PressInput extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 13
+            [
+                isaac_typescript_definitions_1.ModCallback.INPUT_ACTION,
+                this.isActionTriggered,
+                [isaac_typescript_definitions_1.InputHook.IS_ACTION_TRIGGERED],
+            ],
+        ];
+    }
+    // ModCallback.INPUT_ACTION (13)
+    // InputHook.IS_ACTION_TRIGGERED (1)
+    isActionTriggered = (entity, _inputHook, buttonAction) => {
+        if (entity === undefined) {
+            return undefined;
+        }
+        const player = entity.ToPlayer();
+        if (player === undefined) {
+            return undefined;
+        }
+        const playerIndex = (0, playerIndex_1.getPlayerIndex)(player);
+        for (let i = v.run.buttonActionPairs.length - 1; i >= 0; i--) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const pair = v.run.buttonActionPairs[i];
+            if (pair.playerIndex === playerIndex &&
+                pair.buttonAction === buttonAction) {
+                v.run.buttonActionPairs.splice(i);
+                return true;
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Helper function to press an arbitrary `ButtonAction` on the next possible input poll. In most
+     * cases, this will be equivalent to if the first player pressed the corresponding input. It
+     * usually takes 1 frame for the input to take effect.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.PRESS_INPUT`.
+     */
+    pressInput(player, buttonAction) {
+        const playerIndex = (0, playerIndex_1.getPlayerIndex)(player);
+        v.run.buttonActionPairs.push({ playerIndex, buttonAction });
+    }
+}
+exports.PressInput = PressInput;
+__decorate([
+    decorators_1.Exported
+], PressInput.prototype, "pressInput", null);

package/dist/classes/features/other/PreventChildEntities.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.PreventChildEntities = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const decorators_1 = require("../../../decorators");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    room: {
+        preventingEntities: new Set(),
+    },
+};
+class PreventChildEntities extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 27
+            [isaac_typescript_definitions_1.ModCallback.POST_NPC_INIT, this.postNPCInit],
+        ];
+    }
+    // ModCallback.POST_NPC_INIT (27)
+    postNPCInit = (npc) => {
+        const spawnerEntityMatch = npc.SpawnerEntity !== undefined &&
+            v.room.preventingEntities.has(GetPtrHash(npc.SpawnerEntity));
+        const parentMatch = npc.Parent !== undefined &&
+            v.room.preventingEntities.has(GetPtrHash(npc.Parent));
+        if (spawnerEntityMatch || parentMatch) {
+            npc.Remove();
+        }
+    };
+    /**
+     * Helper function to prevent an entity from spawning any other entities. Meant to be used on NPCs
+     * like Squirts. This behavior will only last for the current room.
+     *
+     * Under the hood, this function will remove any new NPCs spawned that have a
+     * `Entity.SpawnerEntity` or `Entity.Parent` value that matches the provided entity. (They are
+     * removed during the `POST_NPC_INIT` callback specifically.)
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.PREVENT_CHILD_ENTITIES`.
+     *
+     * @public
+     */
+    preventChildEntities(entity) {
+        const ptrHash = GetPtrHash(entity);
+        v.room.preventingEntities.add(ptrHash);
+    }
+}
+exports.PreventChildEntities = PreventChildEntities;
+__decorate([
+    decorators_1.Exported
+], PreventChildEntities.prototype, "preventChildEntities", null);

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

@@ -0,0 +1,159 @@
+"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.PreventGridEntityRespawn = 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 ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const array_1 = require("../../../functions/array");
+const gridEntities_1 = require("../../../functions/gridEntities");
+const players_1 = require("../../../functions/players");
+const roomData_1 = require("../../../functions/roomData");
+const DefaultMap_1 = require("../../DefaultMap");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    level: {
+        roomListIndexToDecorationGridIndexes: new DefaultMap_1.DefaultMap(() => []),
+    },
+    room: {
+        manuallyUsingShovel: false,
+    },
+};
+class PreventGridEntityRespawn extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    runInNFrames;
+    /** @internal */
+    constructor(runInNFrames) {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.RUN_IN_N_FRAMES];
+        this.callbacksUsed = [
+            // 23
+            [
+                isaac_typescript_definitions_1.ModCallback.PRE_USE_ITEM,
+                this.preUseItemWeNeedToGoDeeper,
+                [isaac_typescript_definitions_1.CollectibleType.WE_NEED_TO_GO_DEEPER],
+            ],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_REORDERED, this.postNewRoomReordered],
+        ];
+        this.runInNFrames = runInNFrames;
+    }
+    // ModCallback.PRE_USE_ITEM (23)
+    // CollectibleType.WE_NEED_TO_GO_DEEPER (84)
+    preUseItemWeNeedToGoDeeper = (_collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData) => {
+        if (v.room.manuallyUsingShovel) {
+            return undefined;
+        }
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        if (!v.level.roomListIndexToDecorationGridIndexes.has(roomListIndex)) {
+            return undefined;
+        }
+        // Since the room was filled with decorations to prevent any grid entities from respawning, if
+        // the player uses a shovel, it will always reveal a crawl space. In order to restore the normal
+        // shovel functionality, we cancel the shovel use, remove all the decorations, wait a frame,
+        // manually use the shovel again, and then respawn the decorations. (We can't do it all on this
+        // frame because updating the room causes two invocations of the shovel to happen.)
+        const decorations = (0, gridEntities_1.getGridEntities)(isaac_typescript_definitions_1.GridEntityType.DECORATION);
+        for (const decoration of decorations) {
+            (0, gridEntities_1.removeGridEntity)(decoration, false);
+        }
+        const entityPtr = EntityPtr(player);
+        this.runInNFrames.runNextGameFrame(() => {
+            const futurePlayer = (0, players_1.getPlayerFromPtr)(entityPtr);
+            if (futurePlayer === undefined) {
+                return;
+            }
+            const futureRoomListIndex = (0, roomData_1.getRoomListIndex)();
+            if (futureRoomListIndex !== roomListIndex) {
+                return;
+            }
+            v.room.manuallyUsingShovel = true;
+            futurePlayer.UseActiveItem(isaac_typescript_definitions_1.CollectibleType.WE_NEED_TO_GO_DEEPER);
+            v.room.manuallyUsingShovel = false;
+            const decorationGridIndexes = v.level.roomListIndexToDecorationGridIndexes.getAndSetDefault(roomListIndex);
+            (0, array_1.emptyArray)(decorationGridIndexes);
+            this.preventGridEntityRespawn();
+        });
+        // Cancel the original effect.
+        return true;
+    };
+    // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+    postNewRoomReordered = () => {
+        this.setDecorationsInvisible();
+    };
+    /**
+     * Every time we re-enter the room, the sprites for all of the decorations will come back, so we
+     * have to remove them again.
+     */
+    setDecorationsInvisible() {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const decorationGridIndexes = v.level.roomListIndexToDecorationGridIndexes.get(roomListIndex);
+        if (decorationGridIndexes === undefined) {
+            return;
+        }
+        for (const gridIndex of decorationGridIndexes) {
+            const gridEntity = room.GetGridEntity(gridIndex);
+            if (gridEntity !== undefined) {
+                // Other grid entities may have spawned, like trapdoors or crawl spaces. Thus, only make
+                // decorations invisible.
+                const gridEntityType = gridEntity.GetType();
+                if (gridEntityType === isaac_typescript_definitions_1.GridEntityType.DECORATION) {
+                    (0, gridEntities_1.setGridEntityInvisible)(gridEntity);
+                }
+            }
+        }
+    }
+    /**
+     * Helper function to prevent any removed grid entities from respawning if the player re-enters
+     * the current room.
+     *
+     * This is accomplished by spawning a new grid entity on every tile that does not already have a
+     * grid entity. This will force the game to spawn the new grid entity instead of the old one. The
+     * natural grid entity to choose for this purpose is a decoration, since it is non-interacting.
+     * Then, the decorations are made invisible and any shovel uses are intercepted to avoid creating
+     * a crawl space (instead of a trapdoor).
+     *
+     * Another option besides decorations would be to use a pressure plates with a state of 1, which
+     * is a state that is normally unused by the game and makes it invisible & persistent. However,
+     * pickups will not be able to spawn on pressure plates, which lead to various bugs (e.g. pickups
+     * spawning on top of pits). Thus, using a decoration is preferable.
+     *
+     * Yet another option to accomplish this would be to replace the room data with that of an empty
+     * room. However, the room data must exactly match the room type, the room shape, and the doors,
+     * so this is not possible to do in a robust way without adding empty rooms to the mod's `content`
+     * folder to draw the data from.
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.PREVENT_GRID_ENTITY_RESPAWN`.
+     */
+    preventGridEntityRespawn() {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const decorationGridIndexes = v.level.roomListIndexToDecorationGridIndexes.getAndSetDefault(roomListIndex);
+        for (const gridIndex of (0, gridEntities_1.getAllGridIndexes)()) {
+            const existingGridEntity = room.GetGridEntity(gridIndex);
+            if (existingGridEntity !== undefined) {
+                continue;
+            }
+            const decoration = (0, gridEntities_1.spawnGridEntity)(isaac_typescript_definitions_1.GridEntityType.DECORATION, gridIndex);
+            if (decoration !== undefined) {
+                (0, gridEntities_1.setGridEntityInvisible)(decoration);
+            }
+            decorationGridIndexes.push(gridIndex);
+        }
+    }
+}
+exports.PreventGridEntityRespawn = PreventGridEntityRespawn;
+__decorate([
+    decorators_1.Exported
+], PreventGridEntityRespawn.prototype, "preventGridEntityRespawn", null);

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

@@ -0,0 +1,69 @@
+"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.RerunDetection = void 0;
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const rooms_1 = require("../../../functions/rooms");
+const stage_1 = require("../../../functions/stage");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    // We cannot use a "run" object since the variables would be reset when a rerun starts.
+    persistent: {
+        pastFirstFloor: false,
+        onRerun: false,
+    },
+};
+class RerunDetection extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_GAME_STARTED_REORDERED,
+                this.postGameStartedReordered,
+            ],
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_LEVEL_REORDERED, this.postNewLevelReordered],
+        ];
+    }
+    // ModCallbackCustom.POST_GAME_STARTED_REORDERED
+    postGameStartedReordered = (isContinued) => {
+        if (isContinued) {
+            if ((0, stage_1.onFirstFloor)() && (0, rooms_1.inStartingRoom)() && v.persistent.pastFirstFloor) {
+                v.persistent.onRerun = true;
+            }
+        }
+        else {
+            v.persistent.onRerun = false;
+        }
+    };
+    // ModCallbackCustom.POST_NEW_LEVEL_REORDERED
+    postNewLevelReordered = () => {
+        v.persistent.pastFirstFloor = !(0, stage_1.onFirstFloor)();
+    };
+    /**
+     * Helper function to detect if the current run was starting using the "Rerun" option from the
+     * main menu.
+     *
+     * Under the hood, this assumes that any run that is past the first floor and continues in the
+     * starting room of the run is a rerun.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.RERUN_DETECTION`.
+     *
+     * @public
+     */
+    onRerun() {
+        return v.persistent.onRerun;
+    }
+}
+exports.RerunDetection = RerunDetection;
+__decorate([
+    decorators_1.Exported
+], RerunDetection.prototype, "onRerun", null);

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

@@ -0,0 +1,94 @@
+"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.RoomClearFrame = void 0;
+const cachedClasses_1 = require("../../../core/cachedClasses");
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    room: {
+        roomClearGameFrame: undefined,
+        roomClearRenderFrame: undefined,
+        roomClearRoomFrame: undefined,
+    },
+};
+class RoomClearFrame extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_ROOM_CLEAR_CHANGED,
+                this.postRoomClearChangedTrue,
+            ],
+        ];
+    }
+    // ModCallbackCustom.POST_ROOM_CLEAR_CHANGED
+    // true
+    postRoomClearChangedTrue = () => {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const room = cachedClasses_1.game.GetRoom();
+        const roomFrameCount = room.GetFrameCount();
+        const renderFrameCount = Isaac.GetFrameCount();
+        v.room.roomClearGameFrame = gameFrameCount;
+        v.room.roomClearRenderFrame = renderFrameCount;
+        v.room.roomClearRoomFrame = roomFrameCount;
+    };
+    /**
+     * Helper function to get the game frame (i.e. `Game.GetFrameCount`) of the last time that this
+     * room was cleared. Returns undefined if the room has never been cleared.
+     *
+     * Note that if the room is left, all room clear tracking for it will be discarded.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_CLEAR_FRAME`.
+     *
+     * @public
+     */
+    getRoomClearGameFrame() {
+        return v.room.roomClearGameFrame;
+    }
+    /**
+     * Helper function to get the render frame (i.e. `Isaac.GetFrameCount`) of the last time that this
+     * room was cleared. Returns undefined if the room has never been cleared.
+     *
+     * Note that if the room is left, all room clear tracking for it will be discarded.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_CLEAR_FRAME`.
+     *
+     * @public
+     */
+    getRoomClearRenderFrame() {
+        return v.room.roomClearRenderFrame;
+    }
+    /**
+     * Helper function to get the room frame (i.e. `Room.GetFrameCount`) of the last time that this
+     * room was cleared. Returns undefined if the room has never been cleared.
+     *
+     * Note that if the room is left, all room clear tracking for it will be discarded.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.ROOM_CLEAR_FRAME`.
+     *
+     * @public
+     */
+    getRoomClearRoomFrame() {
+        return v.room.roomClearRoomFrame;
+    }
+}
+exports.RoomClearFrame = RoomClearFrame;
+__decorate([
+    decorators_1.Exported
+], RoomClearFrame.prototype, "getRoomClearGameFrame", null);
+__decorate([
+    decorators_1.Exported
+], RoomClearFrame.prototype, "getRoomClearRenderFrame", null);
+__decorate([
+    decorators_1.Exported
+], RoomClearFrame.prototype, "getRoomClearRoomFrame", null);