isaacscript-common 84.0.1 → 84.1.0

package/dist/functions/minimap.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRoomDisplayFlags = exports.setFloorDisplayFlags = exports.setAllDisplayFlags = exports.isRoomVisible = exports.hideRoomOnMinimap = exports.getRoomDisplayFlags = exports.getFloorDisplayFlags = exports.clearRoomDisplayFlags = exports.clearFloorDisplayFlags = exports.addRoomDisplayFlag = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const flag_1 = require("./flag");
+const roomData_1 = require("./roomData");
+const rooms_1 = require("./rooms");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * Helper function to add a `DisplayFlag` to a particular room's minimap display flags (e.g. whether
+ * it is visible and so on).
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ *
+ * @param roomGridIndex Set to undefined to use the current room index.
+ * @param displayFlag The `DisplayFlag` to set. (See the `DisplayFlag` enum.)
+ * @param updateVisibility Optional. Whether to call the `Level.UpdateVisibility` method in order to
+ *                         make the changes immediately visible. Default is true.
+ */
+function addRoomDisplayFlag(roomGridIndex, displayFlag, updateVisibility = true) {
+    const oldDisplayFlags = getRoomDisplayFlags(roomGridIndex);
+    const newDisplayFlags = (0, flag_1.addFlag)(oldDisplayFlags, displayFlag);
+    setRoomDisplayFlags(roomGridIndex, newDisplayFlags, updateVisibility);
+}
+exports.addRoomDisplayFlag = addRoomDisplayFlag;
+/**
+ * Helper function to set the value of `DisplayFlag` for every room on the floor to 0.
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ *
+ * This function automatically calls the `Level.UpdateVisibility` after setting the flags so that
+ * the changes will be immediately visible.
+ */
+function clearFloorDisplayFlags() {
+    setAllDisplayFlags(isaac_typescript_definitions_1.DisplayFlagZero);
+}
+exports.clearFloorDisplayFlags = clearFloorDisplayFlags;
+/**
+ * Helper function to set the value of `DisplayFlag` for a room 0.
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ *
+ * This function automatically calls the `Level.UpdateVisibility` after setting the flags so that
+ * the changes will be immediately visible.
+ *
+ * Note that if you clear the display flags of a room but then the player travels to the room (or an
+ * adjacent room), the room will appear on the minimap again. If you want to permanently hide the
+ * room even in this circumstance, use the `hideRoomOnMinimap` helper function instead.
+ */
+function clearRoomDisplayFlags(roomGridIndex) {
+    setRoomDisplayFlags(roomGridIndex, isaac_typescript_definitions_1.DisplayFlagZero);
+}
+exports.clearRoomDisplayFlags = clearRoomDisplayFlags;
+/**
+ * Helper function to get the minimap `DisplayFlag` value for every room on the floor. Returns a map
+ * that is indexed by the room's safe grid index.
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ *
+ * @param minimapAPI Optional. If MinimapAPI should be used, if present. Default is true.
+ */
+function getFloorDisplayFlags(minimapAPI = true) {
+    const displayFlagsMap = new Map();
+    for (const roomDescriptor of (0, rooms_1.getRoomsInsideGrid)()) {
+        const roomGridIndex = roomDescriptor.SafeGridIndex;
+        const displayFlags = getRoomDisplayFlags(roomGridIndex, minimapAPI);
+        displayFlagsMap.set(roomGridIndex, displayFlags);
+    }
+    return displayFlagsMap;
+}
+exports.getFloorDisplayFlags = getFloorDisplayFlags;
+/**
+ * Helper function to get a particular room's minimap display flags (e.g. whether it is visible and
+ * so on).
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ * @param minimapAPI Optional. If MinimapAPI should be used, if present. Default is true.
+ */
+function getRoomDisplayFlags(roomGridIndex, minimapAPI = true) {
+    if (roomGridIndex === undefined) {
+        roomGridIndex = (0, roomData_1.getRoomGridIndex)();
+    }
+    if (MinimapAPI === undefined || !minimapAPI) {
+        const roomDescriptor = (0, roomData_1.getRoomDescriptor)(roomGridIndex);
+        return roomDescriptor.DisplayFlags;
+    }
+    const minimapAPIRoomDescriptor = MinimapAPI.GetRoomByIdx(roomGridIndex);
+    (0, utils_1.assertDefined)(minimapAPIRoomDescriptor, `Failed to get the MinimapAPI room descriptor for the room at grid index: ${roomGridIndex}`);
+    return minimapAPIRoomDescriptor.GetDisplayFlags();
+}
+exports.getRoomDisplayFlags = getRoomDisplayFlags;
+/**
+ * Helper function to hide a specific room on the minimap.
+ *
+ * If you want the room to be permanently hidden, you must to call this function on every new room.
+ * This is because if the player enters into the room or walks into an adjacent room, the room will
+ * reappear on the minimap.
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ */
+function hideRoomOnMinimap(roomGridIndex) {
+    clearRoomDisplayFlags(roomGridIndex);
+    // In vanilla, the map only updates at the beginning of every room. In MinimapAPI, it constant
+    // updates, so we must specifically tell MinimapAPI that the room should be hidden using the
+    // `Hidden` property.
+    if (MinimapAPI !== undefined) {
+        const minimapAPIRoomDescriptor = MinimapAPI.GetRoomByIdx(roomGridIndex);
+        (0, utils_1.assertDefined)(minimapAPIRoomDescriptor, `Failed to get the MinimapAPI room descriptor for the room at grid index: ${roomGridIndex}`);
+        minimapAPIRoomDescriptor.Hidden = true;
+    }
+}
+exports.hideRoomOnMinimap = hideRoomOnMinimap;
+/**
+ * Helper function to check if a given room is visible on the minimap.
+ *
+ * @param roomGridIndexOrRoomDescriptor The room to check.
+ * @param minimapAPI Optional. Whether MinimapAPI should be used, if present. Default is true.
+ */
+function isRoomVisible(roomGridIndexOrRoomDescriptor, minimapAPI = true) {
+    const roomGridIndex = (0, types_1.isInteger)(roomGridIndexOrRoomDescriptor)
+        ? roomGridIndexOrRoomDescriptor
+        : roomGridIndexOrRoomDescriptor.SafeGridIndex;
+    const roomDisplayFlags = getRoomDisplayFlags(roomGridIndex, minimapAPI);
+    return roomDisplayFlags !== isaac_typescript_definitions_1.DisplayFlagZero;
+}
+exports.isRoomVisible = isRoomVisible;
+/**
+ * Helper function to set the minimap `DisplayFlag` value for every room on the floor at once.
+ *
+ * This function automatically calls the `Level.UpdateVisibility` after setting the flags so that
+ * the changes will be immediately visible.
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ */
+function setAllDisplayFlags(displayFlags) {
+    for (const room of (0, rooms_1.getRoomsInsideGrid)()) {
+        // We pass false to the `updateVisibility` argument as a small optimization.
+        setRoomDisplayFlags(room.SafeGridIndex, displayFlags, false);
+    }
+    // In vanilla, we must call the "Level.UpdateVisibility" method for the changes to be visible.
+    if (MinimapAPI === undefined) {
+        const level = cachedClasses_1.game.GetLevel();
+        level.UpdateVisibility();
+    }
+}
+exports.setAllDisplayFlags = setAllDisplayFlags;
+/**
+ * Helper function to set the minimap `DisplayFlag` value for multiple rooms at once.
+ *
+ * This function automatically calls the `Level.UpdateVisibility` after setting the flags so that
+ * the changes will be immediately visible.
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ *
+ * @param displayFlagsMap A map of the display flags that is indexed by the room's safe grid index.
+ */
+function setFloorDisplayFlags(displayFlagsMap) {
+    for (const [roomGridIndex, displayFlags] of displayFlagsMap) {
+        // We pass false to the `updateVisibility` argument as a small optimization.
+        setRoomDisplayFlags(roomGridIndex, displayFlags, false);
+    }
+    // In vanilla, we must call the "Level.UpdateVisibility" method for the changes to be visible.
+    if (MinimapAPI === undefined) {
+        const level = cachedClasses_1.game.GetLevel();
+        level.UpdateVisibility();
+    }
+}
+exports.setFloorDisplayFlags = setFloorDisplayFlags;
+/**
+ * Helper function to set a particular room's minimap display flags (e.g. whether it is visible and
+ * so on).
+ *
+ * This function automatically accounts for if MinimapAPI is being used.
+ *
+ * @param roomGridIndex Set to undefined to use the current room index.
+ * @param displayFlags The bit flags value to set. (See the `DisplayFlag` enum.)
+ * @param updateVisibility Optional. Whether to call the `Level.UpdateVisibility` method in order to
+ *                         make the changes immediately visible. Default is true. Set this to false
+ *                         if you are doing a bunch of display flag setting and then manually call
+ *                         the `Level.UpdateVisibility` method after you are done.
+ */
+function setRoomDisplayFlags(roomGridIndex, displayFlags, updateVisibility = true) {
+    if (roomGridIndex === undefined) {
+        roomGridIndex = (0, roomData_1.getRoomGridIndex)();
+    }
+    if (MinimapAPI === undefined) {
+        const roomDescriptor = (0, roomData_1.getRoomDescriptor)(roomGridIndex);
+        roomDescriptor.DisplayFlags = displayFlags;
+        if (updateVisibility) {
+            const level = cachedClasses_1.game.GetLevel();
+            level.UpdateVisibility();
+        }
+    }
+    else {
+        const minimapAPIRoomDescriptor = MinimapAPI.GetRoomByIdx(roomGridIndex);
+        (0, utils_1.assertDefined)(minimapAPIRoomDescriptor, `Failed to get the MinimapAPI room descriptor for the room at grid index: ${roomGridIndex}`);
+        minimapAPIRoomDescriptor.SetDisplayFlags(displayFlags);
+    }
+}
+exports.setRoomDisplayFlags = setRoomDisplayFlags;

package/dist/functions/modFeatures.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initModFeatures = void 0;
+/**
+ * Helper function to instantiate an array of mod features all at once. Use this function if your
+ * mod uses the pattern of expressing mod features as `ModFeature` classes.
+ *
+ * If your feature classes have `v` variables, then this function will successfully register them
+ * with the save data manager.
+ *
+ * For example:
+ *
+ * ```ts
+ * const MOD_FEATURES = [
+ *   MyFeature1,
+ *   MyFeature2,
+ *   MyFeature3,
+ * ] as const;
+ * initModFeatures(mod, MOD_FEATURES);
+ * ```
+ *
+ * @param mod The upgraded mod to use.
+ * @param modFeatures An array of the feature classes that you have in your mod.
+ * @param init Optional. Whether to automatically add the callbacks on the feature. Defaults to
+ *             true.
+ * @returns An array of the instantiated features in the same order that the constructors were
+ *          passed in. (In most cases, you probably won't need the returned array.)
+ */
+function initModFeatures(mod, modFeatures, init = true) {
+    const instantiatedModFeatures = [];
+    for (const modFeature of modFeatures) {
+        // eslint-disable-next-line new-cap
+        const instantiatedModFeature = new modFeature(mod, false);
+        instantiatedModFeature.init(init);
+        instantiatedModFeatures.push(instantiatedModFeature);
+    }
+    return instantiatedModFeatures;
+}
+exports.initModFeatures = initModFeatures;

package/dist/functions/newArray.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newArray = void 0;
+const deepCopy_1 = require("./deepCopy");
+const utils_1 = require("./utils");
+/**
+ * Initializes an array with all of the elements containing the specified default value.
+ *
+ * The provided default value will be copied with the `deepCopy` function before adding it to the
+ * new array. Thus, you can initialize an array of arrays, or an array of maps, and so on. (If the
+ * `deepCopy` function was not used, then all of the array elements would just be references to the
+ * same underlying data structure.)
+ *
+ * For example:
+ *
+ * ```ts
+ * const arrayWithZeroes = newArray(0, 10); // Has 10 elements of 0.
+ * const arrayWithArrays = newArray([0], 20); // Has 20 elements of an array with a 0 in it.
+ * ```
+ */
+// eslint-disable-next-line isaacscript/no-mutable-return
+function newArray(defaultValue, size) {
+    const array = [];
+    (0, utils_1.repeat)(size, () => {
+        const copy = (0, deepCopy_1.deepCopy)(defaultValue);
+        array.push(copy);
+    });
+    return array;
+}
+exports.newArray = newArray;

package/dist/functions/nextStage.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextStageType = exports.getNextStage = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const curses_1 = require("./curses");
+const roomData_1 = require("./roomData");
+const stage_1 = require("./stage");
+/**
+ * Helper function to get the stage that a trapdoor or heaven door would take the player to, based
+ * on the current stage, room, and game state flags.
+ *
+ * If you want to account for the player having visited Repentance floors in The Ascent, use the
+ * `getNextStageUsingHistory` helper function instead (from the stage history feature). Handling
+ * this requires stateful tracking as the player progresses through the run.
+ */
+function getNextStage() {
+    const level = cachedClasses_1.game.GetLevel();
+    const backwardsPath = cachedClasses_1.game.GetStateFlag(isaac_typescript_definitions_1.GameStateFlag.BACKWARDS_PATH);
+    const mausoleumHeartKilled = cachedClasses_1.game.GetStateFlag(isaac_typescript_definitions_1.GameStateFlag.MAUSOLEUM_HEART_KILLED);
+    const stage = level.GetStage();
+    const repentanceStage = (0, stage_1.onRepentanceStage)();
+    const roomGridIndex = (0, roomData_1.getRoomGridIndex)();
+    // First, handle the special case of being on the backwards path.
+    if (backwardsPath) {
+        const nextStage = stage - 1;
+        return nextStage === 0 ? isaac_typescript_definitions_1.LevelStage.HOME : nextStage;
+    }
+    // Second, handle the special case of being in a specific off-grid room.
+    switch (roomGridIndex) {
+        // -8
+        case isaac_typescript_definitions_1.GridRoom.BLUE_WOMB: {
+            return isaac_typescript_definitions_1.LevelStage.BLUE_WOMB;
+        }
+        // -9
+        case isaac_typescript_definitions_1.GridRoom.VOID: {
+            return isaac_typescript_definitions_1.LevelStage.VOID;
+        }
+        // -10
+        case isaac_typescript_definitions_1.GridRoom.SECRET_EXIT: {
+            if (repentanceStage) {
+                // e.g. From Downpour 2 to Mines 1, etc.
+                return stage + 1;
+            }
+            if (stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_2 ||
+                (stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_1 && (0, curses_1.hasCurse)(isaac_typescript_definitions_1.LevelCurse.LABYRINTH))) {
+                // From Depths 2 to Mausoleum 2 through the strange door.
+                return isaac_typescript_definitions_1.LevelStage.DEPTHS_2;
+            }
+            // e.g. From Basement 1 to Downpour 1, from Basement 2 to Downpour 2, etc.
+            return stage;
+        }
+    }
+    // 2
+    if (repentanceStage && stage === isaac_typescript_definitions_1.LevelStage.BASEMENT_2) {
+        // From Downpour 2 to Caves 2.
+        return isaac_typescript_definitions_1.LevelStage.CAVES_2;
+    }
+    // 4
+    if (repentanceStage && stage === isaac_typescript_definitions_1.LevelStage.CAVES_2) {
+        // From Mines 2 to Depths 2.
+        return isaac_typescript_definitions_1.LevelStage.DEPTHS_2;
+    }
+    // 6
+    if (repentanceStage && stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_2) {
+        if (mausoleumHeartKilled) {
+            // From Mausoleum 2 to Corpse 1.
+            return isaac_typescript_definitions_1.LevelStage.WOMB_1;
+        }
+        // From Mausoleum 2 to Womb 2.
+        return isaac_typescript_definitions_1.LevelStage.WOMB_2;
+    }
+    // 8
+    if (stage === isaac_typescript_definitions_1.LevelStage.WOMB_2) {
+        // From Womb 2 to Sheol or Cathedral.
+        return isaac_typescript_definitions_1.LevelStage.SHEOL_CATHEDRAL;
+    }
+    // 11
+    if (stage === isaac_typescript_definitions_1.LevelStage.DARK_ROOM_CHEST) {
+        // - The Chest goes to The Chest.
+        // - The Dark Room goes to the Dark Room.
+        return isaac_typescript_definitions_1.LevelStage.DARK_ROOM_CHEST;
+    }
+    // 12
+    if (stage === isaac_typescript_definitions_1.LevelStage.VOID) {
+        // The Void goes to The Void.
+        return isaac_typescript_definitions_1.LevelStage.VOID;
+    }
+    // By default, go to the next floor.
+    return stage + 1;
+}
+exports.getNextStage = getNextStage;
+/**
+ * Helper function to get the stage type that a trapdoor or heaven door would take the player to,
+ * based on the current stage, room, and game state flags.
+ *
+ * If you want to account for previous floors visited on The Ascent, use the
+ * `getNextStageTypeUsingHistory` helper function instead (from the stage history feature). Handling
+ * this requires stateful tracking as the player progresses through the run.
+ *
+ * @param upwards Whether the player should go up to Cathedral in the case of being on Womb 2.
+ *                Default is false.
+ */
+function getNextStageType(upwards = false) {
+    const backwardsPath = cachedClasses_1.game.GetStateFlag(isaac_typescript_definitions_1.GameStateFlag.BACKWARDS_PATH);
+    const mausoleumHeartKilled = cachedClasses_1.game.GetStateFlag(isaac_typescript_definitions_1.GameStateFlag.MAUSOLEUM_HEART_KILLED);
+    const level = cachedClasses_1.game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+    const repentanceStage = (0, stage_1.onRepentanceStage)();
+    const roomGridIndex = (0, roomData_1.getRoomGridIndex)();
+    const nextStage = getNextStage();
+    // First, handle the special case of being on the backwards path.
+    if (backwardsPath) {
+        return (0, stage_1.calculateStageType)(nextStage);
+    }
+    // Second, handle the special case of being in a specific off-grid room.
+    if (roomGridIndex === isaac_typescript_definitions_1.GridRoom.SECRET_EXIT) {
+        return (0, stage_1.calculateStageTypeRepentance)(nextStage);
+    }
+    if (repentanceStage &&
+        (stage === isaac_typescript_definitions_1.LevelStage.BASEMENT_1 || // 1
+            stage === isaac_typescript_definitions_1.LevelStage.CAVES_1 || // 3
+            stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_1 || // 5
+            stage === isaac_typescript_definitions_1.LevelStage.WOMB_1) // 7
+    ) {
+        return (0, stage_1.calculateStageTypeRepentance)(nextStage);
+    }
+    if (repentanceStage &&
+        stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_2 &&
+        mausoleumHeartKilled) {
+        return (0, stage_1.calculateStageTypeRepentance)(nextStage);
+    }
+    // 9
+    if (nextStage === isaac_typescript_definitions_1.LevelStage.BLUE_WOMB) {
+        // Blue Womb does not have any alternate floors.
+        return isaac_typescript_definitions_1.StageType.ORIGINAL;
+    }
+    // 10
+    if (nextStage === isaac_typescript_definitions_1.LevelStage.SHEOL_CATHEDRAL) {
+        if (upwards) {
+            // Go to Cathedral (10.1).
+            return isaac_typescript_definitions_1.StageType.WRATH_OF_THE_LAMB;
+        }
+        // Go to Sheol (10.0).
+        return isaac_typescript_definitions_1.StageType.ORIGINAL;
+    }
+    // 11
+    if (nextStage === isaac_typescript_definitions_1.LevelStage.DARK_ROOM_CHEST) {
+        if (stageType === isaac_typescript_definitions_1.StageType.ORIGINAL) {
+            // Sheol (10.0) goes to the Dark Room (11.0).
+            return isaac_typescript_definitions_1.StageType.ORIGINAL;
+        }
+        // Cathedral (10.1) goes to The Chest (11.1).
+        return isaac_typescript_definitions_1.StageType.WRATH_OF_THE_LAMB;
+    }
+    // 12
+    if (nextStage === isaac_typescript_definitions_1.LevelStage.VOID) {
+        // The Void does not have any alternate floors.
+        return isaac_typescript_definitions_1.StageType.ORIGINAL;
+    }
+    // 13
+    if (nextStage === isaac_typescript_definitions_1.LevelStage.HOME) {
+        // Home does not have any alternate floors.
+        return isaac_typescript_definitions_1.StageType.ORIGINAL;
+    }
+    return (0, stage_1.calculateStageType)(nextStage);
+}
+exports.getNextStageType = getNextStageType;

package/dist/functions/npcDataStructures.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHasNPC = exports.setDeleteNPC = exports.setAddNPC = exports.mapSetNPC = exports.mapHasNPC = exports.mapGetNPC = exports.mapDeleteNPC = exports.defaultMapSetNPC = exports.defaultMapGetNPC = void 0;
+/**
+ * Helper function to make using default maps with an index of `PtrHash` easier. Use this instead of
+ * the `DefaultMap.getAndSetDefault` method if you have a default map of this type.
+ *
+ * For example:
+ *
+ * ```ts
+ * const v = {
+ *   run: {
+ *     npcsSpeedBoost: new DefaultMap<PtrHash, int>(0),
+ *   },
+ * };
+ *
+ * function npcUpdate(npc: EntityNPC) {
+ *   const speedBoost = defaultMapGetNPC(v.run.npcsSpeedBoost, npc);
+ *   // Do something with the speed boost.
+ * }
+ * ```
+ *
+ * Note that not all NPCs should be stored in a map with a `PtrHash` as an index, so only use this
+ * in the situations where that would be okay. (For example, Dark Esau should never be stored in a
+ * map like this, because the scope of `PtrHash` is per room and Dark Esau is persistent between
+ * rooms.)
+ */
+function defaultMapGetNPC(map, npc, ...extraArgs) {
+    const ptrHash = GetPtrHash(npc);
+    return map.getAndSetDefault(ptrHash, ...extraArgs);
+}
+exports.defaultMapGetNPC = defaultMapGetNPC;
+/**
+ * Helper function to make using maps with an index of `PtrHash` easier. Use this instead of the
+ * `Map.set` method if you have a map of this type.
+ *
+ * Since `Map` and `DefaultMap` set values in the same way, this function is simply an alias for the
+ * `mapSetNPC` helper function.
+ */
+function defaultMapSetNPC(
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+map, npc, value) {
+    mapSetNPC(map, npc, value);
+}
+exports.defaultMapSetNPC = defaultMapSetNPC;
+/**
+ * Helper function to make using maps with an type of `PtrHash` easier. Use this instead of the
+ * `Map.delete` method if you have a set of this type.
+ */
+function mapDeleteNPC(
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+map, npc) {
+    const ptrHash = GetPtrHash(npc);
+    return map.delete(ptrHash);
+}
+exports.mapDeleteNPC = mapDeleteNPC;
+/**
+ * Helper function to make using maps with an index of `PtrHash` easier. Use this instead of the
+ * `Map.get` method if you have a map of this type.
+ *
+ * For example:
+ *
+ * ```ts
+ * const v = {
+ *   run: {
+ *     npcsSpeedBoost: new Map<PtrHash, int>(),
+ *   },
+ * };
+ *
+ * function incrementSpeedBoost(npc: EntityNPC) {
+ *   const oldSpeedBoost = mapGetNPC(v.run.npcsSpeedBoost, npc);
+ *   const newSpeedBoost = oldSpeedBoost + 0.1;
+ *   mapSetNPC(v.run.npcsSpeedBoost, npc);
+ * }
+ * ```
+ */
+function mapGetNPC(map, npc) {
+    const ptrHash = GetPtrHash(npc);
+    return map.get(ptrHash);
+}
+exports.mapGetNPC = mapGetNPC;
+/**
+ * Helper function to make using maps with an index of `PtrHash` easier. Use this instead of the
+ * `Map.has` method if you have a map of this type.
+ */
+function mapHasNPC(map, npc) {
+    const ptrHash = GetPtrHash(npc);
+    return map.has(ptrHash);
+}
+exports.mapHasNPC = mapHasNPC;
+/**
+ * Helper function to make using maps with an index of `PtrHash` easier. Use this instead of the
+ * `Map.set` method if you have a map of this type.
+ *
+ * For example:
+ *
+ * ```ts
+ * const v = {
+ *   run: {
+ *     npcsSpeedBoost: new Map<PtrHash, int>(),
+ *   },
+ * };
+ *
+ * function incrementSpeedBoost(npc: EntityNPC) {
+ *   const oldSpeedBoost = mapGetNPC(v.run.npcsSpeedBoost, npc);
+ *   const newSpeedBoost = oldSpeedBoost + 0.1;
+ *   mapSetNPC(v.run.npcsSpeedBoost, npc);
+ * }
+ * ```
+ */
+function mapSetNPC(
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+map, npc, value) {
+    const ptrHash = GetPtrHash(npc);
+    map.set(ptrHash, value);
+}
+exports.mapSetNPC = mapSetNPC;
+/**
+ * Helper function to make using sets with an type of `PtrHash` easier. Use this instead of the
+ * `Set.add` method if you have a set of this type.
+ */
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+function setAddNPC(set, npc) {
+    const ptrHash = GetPtrHash(npc);
+    set.add(ptrHash);
+}
+exports.setAddNPC = setAddNPC;
+/**
+ * Helper function to make using sets with an type of `PtrHash` easier. Use this instead of the
+ * `Set.delete` method if you have a set of this type.
+ */
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+function setDeleteNPC(set, npc) {
+    const ptrHash = GetPtrHash(npc);
+    return set.delete(ptrHash);
+}
+exports.setDeleteNPC = setDeleteNPC;
+/**
+ * Helper function to make using sets with an type of `PtrHash` easier. Use this instead of the
+ * `Set.has` method if you have a set of this type.
+ */
+function setHasNPC(set, npc) {
+    const ptrHash = GetPtrHash(npc);
+    return set.has(ptrHash);
+}
+exports.setHasNPC = setHasNPC;