isaacscript-common 84.0.1 → 84.1.1

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

@@ -0,0 +1,88 @@
+"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.NoSirenSteal = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const decorators_1 = require("../../../decorators");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        familiarBlacklist: [],
+    },
+};
+class NoSirenSteal extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 27
+            [
+                isaac_typescript_definitions_1.ModCallback.POST_NPC_INIT,
+                this.postNPCInitSirenHelper,
+                [isaac_typescript_definitions_1.EntityType.SIREN_HELPER],
+            ],
+        ];
+    }
+    // ModCallback.POST_NPC_INIT (27)
+    // EntityType.SIREN_HELPER (966)
+    postNPCInitSirenHelper = (npc) => {
+        this.checkReturnFamiliarToPlayer(npc);
+    };
+    checkReturnFamiliarToPlayer(npc) {
+        if (npc.Target === undefined) {
+            return;
+        }
+        const familiar = npc.Target.ToFamiliar();
+        if (familiar === undefined) {
+            return;
+        }
+        if (this.blacklistEntryExists(familiar.Variant, familiar.SubType)) {
+            npc.Remove();
+            familiar.AddToFollowers();
+        }
+    }
+    blacklistEntryExists(incomingFamiliarVariant, incomingFamiliarSubType) {
+        for (const familiarTuple of v.run.familiarBlacklist) {
+            const [familiarVariant, familiarSubType] = familiarTuple;
+            if (familiarVariant === incomingFamiliarVariant &&
+                familiarSubType === incomingFamiliarSubType) {
+                // There is an entry that matches the variant and sub-type exactly.
+                return true;
+            }
+            if (familiarVariant === incomingFamiliarVariant &&
+                familiarSubType === undefined) {
+                // There is an entry that matches all sub-types for this variant.
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Blacklists a familiar from being stolen by The Siren boss. This should be called once at the
+     * beginning of every run.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.NO_SIREN_STEAL`.
+     *
+     * @param familiarVariant The familiar variant to blacklist.
+     * @param familiarSubType The sub-type to blacklist. Optional. The default is to blacklist all
+     *                        sub-types of the given variant.
+     * @public
+     */
+    setFamiliarNoSirenSteal(familiarVariant, familiarSubType) {
+        if (this.blacklistEntryExists(familiarVariant, familiarSubType)) {
+            return;
+        }
+        v.run.familiarBlacklist.push([familiarVariant, familiarSubType]);
+    }
+}
+exports.NoSirenSteal = NoSirenSteal;
+__decorate([
+    decorators_1.Exported
+], NoSirenSteal.prototype, "setFamiliarNoSirenSteal", null);

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

@@ -0,0 +1,197 @@
+"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.Pause = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const constants_1 = require("../../../core/constants");
+const decorators_1 = require("../../../decorators");
+const entitiesSpecific_1 = require("../../../functions/entitiesSpecific");
+const isaacAPIClass_1 = require("../../../functions/isaacAPIClass");
+const log_1 = require("../../../functions/log");
+const playerCollectibles_1 = require("../../../functions/playerCollectibles");
+const playerIndex_1 = require("../../../functions/playerIndex");
+const tstlClass_1 = require("../../../functions/tstlClass");
+const utils_1 = require("../../../functions/utils");
+const ReadonlySet_1 = require("../../../types/ReadonlySet");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        isPseudoPaused: false,
+        shouldUnpause: false,
+        initialDescriptions: new Map(),
+    },
+};
+class Pause extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    disableInputs;
+    /** @internal */
+    constructor(disableInputs) {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+            // 13
+            [
+                isaac_typescript_definitions_1.ModCallback.INPUT_ACTION,
+                this.inputActionGetActionValue,
+                [isaac_typescript_definitions_1.InputHook.GET_ACTION_VALUE],
+            ],
+        ];
+        this.disableInputs = disableInputs;
+    }
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        if (!v.run.isPseudoPaused) {
+            return;
+        }
+        const firstPlayer = Isaac.GetPlayer();
+        (0, playerCollectibles_1.useActiveItemTemp)(firstPlayer, isaac_typescript_definitions_1.CollectibleType.PAUSE);
+        this.stopTearsAndProjectilesFromMoving();
+    };
+    stopTearsAndProjectilesFromMoving() {
+        const tearsAndProjectiles = [...(0, entitiesSpecific_1.getTears)(), ...(0, entitiesSpecific_1.getProjectiles)()];
+        for (const tearOrProjectile of tearsAndProjectiles) {
+            const ptrHash = GetPtrHash(tearOrProjectile);
+            const initialDescription = v.run.initialDescriptions.get(ptrHash);
+            if (initialDescription === undefined) {
+                continue;
+            }
+            tearOrProjectile.Position = initialDescription.position;
+            tearOrProjectile.PositionOffset = initialDescription.positionOffset;
+            tearOrProjectile.Velocity = constants_1.VectorZero;
+            tearOrProjectile.Height = initialDescription.height;
+            tearOrProjectile.FallingSpeed = 0;
+            if ((0, isaacAPIClass_1.isTear)(tearOrProjectile)) {
+                tearOrProjectile.FallingAcceleration =
+                    initialDescription.fallingAcceleration;
+            }
+            else {
+                tearOrProjectile.FallingAccel = initialDescription.fallingAcceleration;
+            }
+        }
+    }
+    // ModCallback.INPUT_ACTION (13)
+    // InputHook.GET_ACTION_VALUE (2)
+    inputActionGetActionValue = (_entity, _inputHook, buttonAction) => {
+        if (buttonAction !== isaac_typescript_definitions_1.ButtonAction.SHOOT_RIGHT) {
+            return undefined;
+        }
+        if (!v.run.shouldUnpause) {
+            return undefined;
+        }
+        v.run.shouldUnpause = false;
+        // Returning a value of 1 for a single sub-frame will be enough for the game to register an
+        // unpause but not enough for a tear to actually be fired.
+        return 1;
+    };
+    /**
+     * Helper function to check if the pause feature from `isaacscript-common` is currently
+     * pseudo-pausing the game.
+     *
+     * @public
+     */
+    isPaused() {
+        return v.run.isPseudoPaused;
+    }
+    /**
+     * Helper function to emulate what happens when the player pauses the game. Use the `unpause`
+     * function to return things back to normal.
+     *
+     * Under the hood, this function:
+     * - uses the Pause collectible on every game frame
+     * - disables any player inputs (except for `ButtonAction.MENU_CONFIRM` and
+     *   `ButtonAction.CONSOLE`)
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.PAUSE`.
+     *
+     * @public
+     */
+    pause() {
+        if (v.run.isPseudoPaused) {
+            (0, log_1.logError)("Failed to pseudo-pause the game, since it was already pseudo-paused.");
+            return;
+        }
+        v.run.isPseudoPaused = true;
+        // Tears/projectiles in the room will move slightly on every frame, even when the Pause
+        // collectible is active. Thus, we manually reset the initial positions and heights on every
+        // frame.
+        v.run.initialDescriptions.clear();
+        const tearsAndProjectiles = [...(0, entitiesSpecific_1.getTears)(), ...(0, entitiesSpecific_1.getProjectiles)()];
+        for (const tearOrProjectile of tearsAndProjectiles) {
+            const ptrHash = GetPtrHash(tearOrProjectile);
+            const initialDescription = {
+                position: tearOrProjectile.Position,
+                positionOffset: tearOrProjectile.PositionOffset,
+                velocity: tearOrProjectile.Velocity,
+                height: tearOrProjectile.Height,
+                fallingSpeed: tearOrProjectile.FallingSpeed,
+                fallingAcceleration: (0, isaacAPIClass_1.isTear)(tearOrProjectile)
+                    ? tearOrProjectile.FallingAcceleration
+                    : tearOrProjectile.FallingAccel,
+            };
+            v.run.initialDescriptions.set(ptrHash, initialDescription);
+        }
+        const firstPlayer = Isaac.GetPlayer();
+        (0, playerCollectibles_1.useActiveItemTemp)(firstPlayer, isaac_typescript_definitions_1.CollectibleType.PAUSE);
+        const tstlClassName = (0, tstlClass_1.getTSTLClassName)(this);
+        (0, utils_1.assertDefined)(tstlClassName, "Failed to get the class name for the pause feature.");
+        const whitelist = new ReadonlySet_1.ReadonlySet([
+            isaac_typescript_definitions_1.ButtonAction.MENU_CONFIRM,
+            isaac_typescript_definitions_1.ButtonAction.CONSOLE,
+        ]);
+        this.disableInputs.disableAllInputsExceptFor(tstlClassName, whitelist);
+        for (const player of (0, playerIndex_1.getAllPlayers)()) {
+            // Disable the controls to prevent the players from moving, shooting, and so on. (We also
+            // disable the inputs in the `INPUT_ACTION` callback, but that does not prevent mouse inputs.)
+            player.ControlsEnabled = false;
+            // Prevent the players from leaving the room. (If we don't reset the velocity, they can
+            // continue to move towards a door.)
+            player.Velocity = constants_1.VectorZero;
+        }
+        this.stopTearsAndProjectilesFromMoving();
+    }
+    /**
+     * Helper function to put things back to normal after the `pause` function was used.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.PAUSE`.
+     *
+     * @public
+     */
+    unpause() {
+        if (!v.run.isPseudoPaused) {
+            (0, log_1.logError)("Failed to pseudo-unpause the game, since it was not already pseudo-paused.");
+            return;
+        }
+        v.run.isPseudoPaused = false;
+        v.run.shouldUnpause = true;
+        const tstlClassName = (0, tstlClass_1.getTSTLClassName)(this);
+        (0, utils_1.assertDefined)(tstlClassName, "Failed to find get the class name for the pause feature.");
+        this.disableInputs.enableAllInputs(tstlClassName);
+        for (const player of (0, playerIndex_1.getAllPlayers)()) {
+            player.ControlsEnabled = true;
+        }
+        // After a vanilla pause, the tears will not resume their normal velocity and will "stick" to
+        // the air. Even if we try to help the tears along by explicitly resetting all of the
+        // velocity-related variables to their initial values, this will not make a difference. Thus,
+        // revert to removing all of the tears and projectiles in the room. (If a Ludovico tear is
+        // removed, it will automatically be respawned on the next frame.)
+        (0, entitiesSpecific_1.removeAllTears)();
+        (0, entitiesSpecific_1.removeAllProjectiles)();
+    }
+}
+exports.Pause = Pause;
+__decorate([
+    decorators_1.Exported
+], Pause.prototype, "isPaused", null);
+__decorate([
+    decorators_1.Exported
+], Pause.prototype, "pause", null);
+__decorate([
+    decorators_1.Exported
+], Pause.prototype, "unpause", null);

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

@@ -0,0 +1,168 @@
+"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.PersistentEntities = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const decorators_1 = require("../../../decorators");
+const ISCFeature_1 = require("../../../enums/ISCFeature");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const entities_1 = require("../../../functions/entities");
+const roomData_1 = require("../../../functions/roomData");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        /** Iterates upward as new persistent entities are created. */
+        persistentEntityIndexCounter: 0,
+    },
+    level: {
+        /**
+         * Indexed by persistent entity index.
+         *
+         * When the entity is spawned in the currently room, its corresponding entry in this map will be
+         * temporarily deleted (until the entity itself is despawned).
+         */
+        persistentEntities: new Map(),
+    },
+    room: {
+        spawnedPersistentEntities: new Map(),
+    },
+};
+class PersistentEntities extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    roomHistory;
+    /** @internal */
+    constructor(roomHistory) {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.ROOM_HISTORY];
+        this.callbacksUsed = [
+            // 67
+            [isaac_typescript_definitions_1.ModCallback.POST_ENTITY_REMOVE, this.postEntityRemove],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_REORDERED, this.postNewRoomReordered],
+        ];
+        this.roomHistory = roomHistory;
+    }
+    // ModCallback.POST_ENTITY_REMOVE (67)
+    postEntityRemove = (entity) => {
+        const ptrHash = GetPtrHash(entity);
+        const tuple = v.room.spawnedPersistentEntities.get(ptrHash);
+        if (tuple === undefined) {
+            return;
+        }
+        // A persistent entity is being removed, either because it was killed / manually despawned, or
+        // the player left the room.
+        const index = tuple[0];
+        if (this.roomHistory.isLeavingRoom()) {
+            this.trackDespawningPickupPosition(entity, index);
+        }
+        else {
+            this.removePersistentEntity(index, false);
+        }
+    };
+    /**
+     * The persistent entity is despawning because the player is in the process of leaving the room.
+     * Keep track of the position for later.
+     */
+    trackDespawningPickupPosition(entity, index) {
+        // (The "latest" room description is really the previous room, because the `POST_NEW_ROOM`
+        // callback was not fired yet.)
+        const previousRoomDescription = this.roomHistory.getLatestRoomDescription();
+        if (previousRoomDescription === undefined) {
+            return;
+        }
+        const persistentEntityDescription = {
+            entityType: entity.Type,
+            variant: entity.Variant,
+            subType: entity.SubType,
+            dimension: previousRoomDescription.dimension,
+            roomListIndex: previousRoomDescription.roomListIndex,
+            position: entity.Position,
+        };
+        v.level.persistentEntities.set(index, persistentEntityDescription);
+    }
+    // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+    postNewRoomReordered = () => {
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const persistentEntities = [...v.level.persistentEntities.entries()];
+        const persistentEntitiesInThisRoom = persistentEntities.filter(([_index, description]) => roomListIndex === description.roomListIndex);
+        for (const [index, description] of persistentEntitiesInThisRoom) {
+            v.level.persistentEntities.delete(index);
+            this.spawnAndTrack(description.entityType, description.variant, description.subType, description.position, index, true);
+        }
+    };
+    spawnAndTrack(entityType, variant, subType, position, index, respawning = false) {
+        const entity = (0, entities_1.spawn)(entityType, variant, subType, position);
+        if (respawning) {
+            entity.ClearEntityFlags(isaac_typescript_definitions_1.EntityFlag.APPEAR);
+        }
+        const ptrHash = GetPtrHash(entity);
+        // Keep track that we spawned it so that we can respawn it if the player re-enters the room.
+        const tuple = [index, EntityPtr(entity)];
+        v.room.spawnedPersistentEntities.set(ptrHash, tuple);
+        return entity;
+    }
+    /**
+     * Helper function to stop an entity spawned with the `spawnPersistentEntity` helper function from
+     * respawning.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.PERSISTENT_ENTITIES`.
+     *
+     * @param persistentEntityIndex The index that was returned by the `spawnPersistentEntity`
+     *                              function.
+     * @param removeEntity Optional. True by default. Set to false if you want to stop an entity from
+     *                     being persistent but you don't want to actually remove the
+     *                     currently-spawned entity from the room.
+     * @public
+     */
+    removePersistentEntity(persistentEntityIndex, removeEntity = true) {
+        v.level.persistentEntities.delete(persistentEntityIndex);
+        for (const [ptrHash, tuple] of v.room.spawnedPersistentEntities) {
+            const [index, entityPtr] = tuple;
+            if (index !== persistentEntityIndex) {
+                continue;
+            }
+            v.room.spawnedPersistentEntities.delete(ptrHash);
+            if (removeEntity && entityPtr.Ref !== undefined) {
+                entityPtr.Ref.Remove();
+            }
+        }
+    }
+    /**
+     * Helper function to spawn an entity that will have persistence similar to a pickup.
+     *
+     * By default, as soon as you leave a room, any spawned entities will be despawned and will not
+     * return if the player revisits the room. This means that if you want to have an entity like a
+     * pickup, you have to manually respawn it when the player re-enters the room. Use this helper
+     * function to avoid having to do any tracking on your own.
+     *
+     * Conventionally, the word "persistent" refers to `EntityFlag.FLAG_PERSISTENT`, which is used on
+     * e.g. familiars to make them appear in every room. On the other hand, pickups are also
+     * persistent, but they are not present in every room, only one specific room. This function
+     * spawns entities like pickups, not familiars.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.PERSISTENT_ENTITIES`.
+     *
+     * @returns An object containing the entity and the persistent entity index. You can use the index
+     *          with the `removePersistentEntity` function.
+     * @public
+     */
+    spawnPersistentEntity(entityType, variant, subType, position) {
+        v.run.persistentEntityIndexCounter++;
+        const entity = this.spawnAndTrack(entityType, variant, subType, position, v.run.persistentEntityIndexCounter);
+        return { entity, persistentIndex: v.run.persistentEntityIndexCounter };
+    }
+}
+exports.PersistentEntities = PersistentEntities;
+__decorate([
+    decorators_1.Exported
+], PersistentEntities.prototype, "removePersistentEntity", null);
+__decorate([
+    decorators_1.Exported
+], PersistentEntities.prototype, "spawnPersistentEntity", null);

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

@@ -0,0 +1,229 @@
+"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.PickupIndexCreation = 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 entities_1 = require("../../../functions/entities");
+const frames_1 = require("../../../functions/frames");
+const roomData_1 = require("../../../functions/roomData");
+const stage_1 = require("../../../functions/stage");
+const vector_1 = require("../../../functions/vector");
+const DefaultMap_1 = require("../../DefaultMap");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        /** Is incremented before assignment. Thus, the first pickup will have an index of 1. */
+        pickupCounter: 0,
+        pickupDataTreasureRooms: new Map(),
+        pickupDataBossRooms: new Map(),
+    },
+    level: {
+        /** Indexed by room list index. */
+        pickupData: new DefaultMap_1.DefaultMap(() => new Map()),
+    },
+    room: {
+        pickupIndexes: new Map(),
+    },
+};
+class PickupIndexCreation extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    roomHistory;
+    saveDataManager;
+    /** @internal */
+    constructor(roomHistory, saveDataManager) {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.ROOM_HISTORY, ISCFeature_1.ISCFeature.SAVE_DATA_MANAGER];
+        this.callbacksUsed = [
+            // 34
+            [isaac_typescript_definitions_1.ModCallback.POST_PICKUP_INIT, this.postPickupInit],
+            // 67
+            [
+                isaac_typescript_definitions_1.ModCallback.POST_ENTITY_REMOVE,
+                this.postEntityRemovePickup,
+                [isaac_typescript_definitions_1.EntityType.PICKUP],
+            ],
+        ];
+        this.roomHistory = roomHistory;
+        this.saveDataManager = saveDataManager;
+    }
+    // ModCallback.POST_PICKUP_INIT (34)
+    postPickupInit = (pickup) => {
+        this.setPickupIndex(pickup);
+    };
+    setPickupIndex(pickup) {
+        const ptrHash = GetPtrHash(pickup);
+        // In certain situations, pickups can be morphed, which will trigger the `POST_PICKUP_INIT`
+        // callback but should not incur a new pickup counter. (For example, the collectible rotation
+        // with Tainted Isaac.) For these situations, we will already be tracking an index for this
+        // pointer hash.
+        if (v.room.pickupIndexes.has(ptrHash)) {
+            return;
+        }
+        // First, handle the special case of re-entering a room with a previously tracked pickup. If we
+        // find a match in the level pickup data, we will use the pickup index from the match.
+        const pickupIndexFromLevelData = this.getPickupIndexFromPreviousData(pickup);
+        const room = cachedClasses_1.game.GetRoom();
+        const isFirstVisit = room.IsFirstVisit();
+        if (pickupIndexFromLevelData !== undefined &&
+            !isFirstVisit &&
+            (0, frames_1.onOrBeforeRoomFrame)(0)) {
+            v.room.pickupIndexes.set(ptrHash, pickupIndexFromLevelData);
+            return;
+        }
+        // This is a brand new pickup that we have not previously seen on this run.
+        v.run.pickupCounter++;
+        v.room.pickupIndexes.set(ptrHash, v.run.pickupCounter);
+    }
+    getPickupIndexFromPreviousData(pickup) {
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const pickupDescriptions = v.level.pickupData.getAndSetDefault(roomListIndex);
+        let pickupIndex = getStoredPickupIndex(pickup, pickupDescriptions);
+        if (pickupIndex === undefined) {
+            pickupIndex = this.getPostAscentPickupIndex(pickup);
+        }
+        return pickupIndex;
+    }
+    // ModCallback.POST_ENTITY_REMOVE (67)
+    // EntityType.PICKUP (5)
+    postEntityRemovePickup = (entity) => {
+        this.checkDespawningFromPlayerLeavingRoom(entity);
+    };
+    checkDespawningFromPlayerLeavingRoom(entity) {
+        const ptrHash = GetPtrHash(entity);
+        const pickupIndex = v.room.pickupIndexes.get(ptrHash);
+        if (pickupIndex === undefined) {
+            return;
+        }
+        if (!this.roomHistory.isLeavingRoom()) {
+            return;
+        }
+        this.trackDespawningPickupMetadata(entity, pickupIndex);
+    }
+    /**
+     * This is a pickup that is despawning because the player is in the process of leaving the room.
+     * Keep track of the metadata for later.
+     */
+    trackDespawningPickupMetadata(entity, pickupIndex) {
+        // The "latest" room description is really the previous room, because the `POST_NEW_ROOM`
+        // callback has not fired yet.
+        const previousRoomDescription = this.roomHistory.getLatestRoomDescription();
+        if (previousRoomDescription === undefined) {
+            return;
+        }
+        const previousRoomListIndex = previousRoomDescription.roomListIndex;
+        const pickupDescriptions = v.level.pickupData.getAndSetDefault(previousRoomListIndex);
+        const pickupDescription = {
+            position: entity.Position,
+            initSeed: entity.InitSeed,
+        };
+        pickupDescriptions.set(pickupIndex, pickupDescription);
+        const pickupDataMapForCurrentRoom = this.getPickupDataMapForCurrentRoom();
+        if (pickupDataMapForCurrentRoom !== undefined) {
+            pickupDataMapForCurrentRoom.set(pickupIndex, pickupDescription);
+        }
+        // Since the `POST_ENTITY_REMOVE` callback fires after the `PRE_GAME_EXIT` callback, we need to
+        // explicitly save data again if the player is in the process of saving and quitting the run.
+        if (this.saveDataManager.saveDataManagerInMenu()) {
+            this.saveDataManager.saveDataManagerSave();
+        }
+    }
+    /**
+     * If the despawning pickup was in a Treasure Room or Boss Room, then it is possible that the
+     * pickup could re-appear during The Ascent. If this is the case, we store the metadata on a
+     * separate map to reference later.
+     */
+    getPickupDataMapForCurrentRoom() {
+        if ((0, stage_1.onAscent)()) {
+            return undefined;
+        }
+        const room = cachedClasses_1.game.GetRoom();
+        const roomType = room.GetType();
+        switch (roomType) {
+            case isaac_typescript_definitions_1.RoomType.TREASURE: {
+                return v.run.pickupDataTreasureRooms;
+            }
+            case isaac_typescript_definitions_1.RoomType.BOSS: {
+                return v.run.pickupDataBossRooms;
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    getPostAscentPickupIndex(pickup) {
+        // If we have not found the pickup index yet, we might be re-entering a post-Ascent Treasure
+        // Room or Boss Room.
+        if (!(0, stage_1.onAscent)()) {
+            return undefined;
+        }
+        const room = cachedClasses_1.game.GetRoom();
+        const roomType = room.GetType();
+        switch (roomType) {
+            case isaac_typescript_definitions_1.RoomType.TREASURE: {
+                return getStoredPickupIndex(pickup, v.run.pickupDataTreasureRooms);
+            }
+            case isaac_typescript_definitions_1.RoomType.BOSS: {
+                return getStoredPickupIndex(pickup, v.run.pickupDataBossRooms);
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    /**
+     * Mods often have to track variables relating to a pickups. Finding an index for these kinds of
+     * data structures is difficult, since pickups are respawned every time a player re-enters a room,
+     * so the `PtrHash` will change.
+     *
+     * Use this function to get a unique index for a pickup to use in these data structures.
+     *
+     * Specifically, `PickupIndex` is a number that represents the spawn order of the pickup on the
+     * current run. For example, the first pickup spawned will have an index of 1, the second one will
+     * have an index of 2, and so on.
+     *
+     * Tracking pickups requires stateful tracking, so using pickup indexes requires an upgraded mod.
+     *
+     * Note that the pickup index will not change:
+     * - When a pickup is rolled with e.g. D6 or D20.
+     * - When an item is "rotated" via e.g. Tainted Isaac's mechanic.
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.PICKUP_INDEX_CREATION`.
+     */
+    getPickupIndex(pickup) {
+        const ptrHash = GetPtrHash(pickup);
+        const pickupIndexInitial = v.room.pickupIndexes.get(ptrHash);
+        if (pickupIndexInitial !== undefined) {
+            return pickupIndexInitial;
+        }
+        this.setPickupIndex(pickup);
+        const pickupIndex = v.room.pickupIndexes.get(ptrHash);
+        if (pickupIndex !== undefined) {
+            return pickupIndex;
+        }
+        const entityID = (0, entities_1.getEntityID)(pickup);
+        error(`Failed to generate a new pickup index for pickup: ${entityID}`);
+    }
+}
+exports.PickupIndexCreation = PickupIndexCreation;
+__decorate([
+    decorators_1.Exported
+], PickupIndexCreation.prototype, "getPickupIndex", null);
+function getStoredPickupIndex(pickup, pickupDescriptions) {
+    for (const [pickupIndex, pickupDescription] of pickupDescriptions) {
+        if ((0, vector_1.vectorEquals)(pickupDescription.position, pickup.Position) &&
+            pickupDescription.initSeed === pickup.InitSeed) {
+            return pickupIndex;
+        }
+    }
+    return undefined;
+}