isaacscript-common 6.6.1-dev.1 → 6.6.1-dev.2

package/features/extraConsoleCommands/v.js

@@ -0,0 +1,25 @@
+const v = {
+    persistent: {
+        disableCurses: false,
+    },
+    run: {
+        chaosCardTears: false,
+        spamBloodRights: false,
+        maxDamage: false,
+        maxSpeed: false,
+        maxTears: false,
+        flight: false,
+    },
+};
+export default v;
+/** The contents of the map are initialized in the "init.ts" file. */
+export const extraConsoleCommandsFunctionMap = new Map();
+/**
+ * Most `isaacscript-common` features are turned on via invoking the `upgradeMod` function. However,
+ * this feature is turned on via invoking `enableExtraConsoleCommands`, so we need a separate method
+ * to track whether it is initialized.
+ */
+export function isExtraConsoleCommandsInitialized() {
+    return extraConsoleCommandsFunctionMap.size > 0;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZmVhdHVyZXMvZXh0cmFDb25zb2xlQ29tbWFuZHMvdi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsR0FBRztJQUNSLFVBQVUsRUFBRTtRQUNWLGFBQWEsRUFBRSxLQUFLO0tBQ3JCO0lBRUQsR0FBRyxFQUFFO1FBQ0gsY0FBYyxFQUFFLEtBQUs7UUFDckIsZUFBZSxFQUFFLEtBQUs7UUFDdEIsU0FBUyxFQUFFLEtBQUs7UUFDaEIsUUFBUSxFQUFFLEtBQUs7UUFDZixRQUFRLEVBQUUsS0FBSztRQUNmLE1BQU0sRUFBRSxLQUFLO0tBQ2Q7Q0FDRixDQUFDO0FBQ0YsZUFBZSxDQUFDLENBQUM7QUFFakIscUVBQXFFO0FBQ3JFLE1BQU0sQ0FBQyxNQUFNLCtCQUErQixHQUFHLElBQUksR0FBRyxFQUduRCxDQUFDO0FBRUo7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxpQ0FBaUM7SUFDL0MsT0FBTywrQkFBK0IsQ0FBQyxJQUFJLEdBQUcsQ0FBQyxDQUFDO0FBQ2xELENBQUMifQ==

package/features/fadeInRemover.js

@@ -0,0 +1,51 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "fadeInRemover";
+const FADE_IN_SPEED = 1;
+let enabled = false;
+const v = {
+    run: {
+        removedFadeIn: false,
+    },
+};
+/** @internal */
+export function fadeInRemoverInit(mod) {
+    saveDataManager(FEATURE_NAME, v, () => false);
+    mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+function postRender() {
+    if (!enabled) {
+        return;
+    }
+    if (shouldRemoveFadeIn()) {
+        v.run.removedFadeIn = true;
+        game.Fadein(FADE_IN_SPEED);
+    }
+}
+function shouldRemoveFadeIn() {
+    const gameFrameCount = game.GetFrameCount();
+    return !v.run.removedFadeIn && gameFrameCount === 0;
+}
+/**
+ * Removes the fade-in that occurs at the beginning of a run. If this behavior is desired, call this
+ * function once at the beginning of your mod.
+ *
+ * This is useful for debugging, when you are resetting the game often.
+ *
+ * You can restore the vanilla behavior with the `restoreFadeIn` function.
+ */
+export function removeFadeIn() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    enabled = true;
+}
+/**
+ * Disables the fade-in remover. Only useful if you have previously called the `removeFadeIn`
+ * function.
+ */
+export function restoreFadeIn() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    enabled = false;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFkZUluUmVtb3Zlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZmVhdHVyZXMvZmFkZUluUmVtb3Zlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0QsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3hDLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUU1RCxNQUFNLFlBQVksR0FBRyxlQUFlLENBQUM7QUFDckMsTUFBTSxhQUFhLEdBQUcsQ0FBQyxDQUFDO0FBRXhCLElBQUksT0FBTyxHQUFHLEtBQUssQ0FBQztBQUVwQixNQUFNLENBQUMsR0FBRztJQUNSLEdBQUcsRUFBRTtRQUNILGFBQWEsRUFBRSxLQUFLO0tBQ3JCO0NBQ0YsQ0FBQztBQUVGLGdCQUFnQjtBQUNoQixNQUFNLFVBQVUsaUJBQWlCLENBQUMsR0FBUTtJQUN4QyxlQUFlLENBQUMsWUFBWSxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUU5QyxHQUFHLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJO0FBQzVELENBQUM7QUFFRCxTQUFTLFVBQVU7SUFDakIsSUFBSSxDQUFDLE9BQU8sRUFBRTtRQUNaLE9BQU87S0FDUjtJQUVELElBQUksa0JBQWtCLEVBQUUsRUFBRTtRQUN4QixDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7UUFDM0IsSUFBSSxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztLQUM1QjtBQUNILENBQUM7QUFFRCxTQUFTLGtCQUFrQjtJQUN6QixNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7SUFDNUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsYUFBYSxJQUFJLGNBQWMsS0FBSyxDQUFDLENBQUM7QUFDdEQsQ0FBQztBQUVEOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsWUFBWTtJQUMxQiw2QkFBNkIsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUM1QyxPQUFPLEdBQUcsSUFBSSxDQUFDO0FBQ2pCLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsYUFBYTtJQUMzQiw2QkFBNkIsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUM1QyxPQUFPLEdBQUcsS0FBSyxDQUFDO0FBQ2xCLENBQUMifQ==

package/features/fastReset.js

@@ -0,0 +1,61 @@
+import { ButtonAction, ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { isActionTriggeredOnAnyInput, isModifierKeyPressed, } from "../functions/input";
+import { restart } from "../functions/run";
+const FEATURE_NAME = "fastReset";
+let enabled = false;
+/** @internal */
+export function fastResetInit(mod) {
+    mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+// ModCallback.POST_RENDER (2)
+function postRender() {
+    if (!enabled) {
+        return;
+    }
+    checkResetInput();
+}
+/** Check for fast-reset inputs. */
+function checkResetInput() {
+    const isPaused = game.IsPaused();
+    // Disable the fast-reset feature if the console is open. (This will also disable the feature when
+    // the game is paused, but that's okay as well.)
+    if (isPaused) {
+        return;
+    }
+    // Disable the fast-reset feature if the custom console is open.
+    if (AwaitingTextInput) {
+        return;
+    }
+    // Don't fast-reset if any modifiers are pressed.
+    if (isModifierKeyPressed()) {
+        return;
+    }
+    // Check to see if the player has pressed the restart input. (We check all inputs instead of
+    // `player.ControllerIndex` because a controller player might be using the keyboard to reset.)
+    if (isActionTriggeredOnAnyInput(ButtonAction.RESTART)) {
+        restart();
+    }
+}
+/**
+ * Enables the fast-reset feature, which allows you to restart the game instantaneously. If this
+ * behavior is desired, call this function once at the beginning of your mod.
+ *
+ * This is useful for debugging, when you are resetting the game often.
+ *
+ * You can disable the fast-reset feature with the `disableFastReset` function.
+ */
+export function enableFastReset() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    enabled = true;
+}
+/**
+ * Disables the fast-reset feature. Only useful if you have previously called the `enableFastReset`
+ * function.
+ */
+export function disableFastReset() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    enabled = false;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFzdFJlc2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mZWF0dXJlcy9mYXN0UmVzZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUN6RSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDeEMsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkUsT0FBTyxFQUNMLDJCQUEyQixFQUMzQixvQkFBb0IsR0FDckIsTUFBTSxvQkFBb0IsQ0FBQztBQUM1QixPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFM0MsTUFBTSxZQUFZLEdBQUcsV0FBVyxDQUFDO0FBRWpDLElBQUksT0FBTyxHQUFHLEtBQUssQ0FBQztBQUVwQixnQkFBZ0I7QUFDaEIsTUFBTSxVQUFVLGFBQWEsQ0FBQyxHQUFRO0lBQ3BDLEdBQUcsQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLFdBQVcsRUFBRSxVQUFVLENBQUMsQ0FBQyxDQUFDLElBQUk7QUFDNUQsQ0FBQztBQUVELDhCQUE4QjtBQUM5QixTQUFTLFVBQVU7SUFDakIsSUFBSSxDQUFDLE9BQU8sRUFBRTtRQUNaLE9BQU87S0FDUjtJQUVELGVBQWUsRUFBRSxDQUFDO0FBQ3BCLENBQUM7QUFFRCxtQ0FBbUM7QUFDbkMsU0FBUyxlQUFlO0lBQ3RCLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUVqQyxrR0FBa0c7SUFDbEcsZ0RBQWdEO0lBQ2hELElBQUksUUFBUSxFQUFFO1FBQ1osT0FBTztLQUNSO0lBRUQsZ0VBQWdFO0lBQ2hFLElBQUksaUJBQWlCLEVBQUU7UUFDckIsT0FBTztLQUNSO0lBRUQsaURBQWlEO0lBQ2pELElBQUksb0JBQW9CLEVBQUUsRUFBRTtRQUMxQixPQUFPO0tBQ1I7SUFFRCw0RkFBNEY7SUFDNUYsOEZBQThGO0lBQzlGLElBQUksMkJBQTJCLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxFQUFFO1FBQ3JELE9BQU8sRUFBRSxDQUFDO0tBQ1g7QUFDSCxDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxlQUFlO0lBQzdCLDZCQUE2QixDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzVDLE9BQU8sR0FBRyxJQUFJLENBQUM7QUFDakIsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sVUFBVSxnQkFBZ0I7SUFDOUIsNkJBQTZCLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDNUMsT0FBTyxHQUFHLEtBQUssQ0FBQztBQUNsQixDQUFDIn0=

package/features/forgottenSwitch.js

@@ -0,0 +1,33 @@
+import { ButtonAction, InputHook, ModCallback, } from "isaac-typescript-definitions";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "forgottenSwitch";
+const v = {
+    run: {
+        shouldSwitch: false,
+    },
+};
+/** @internal */
+export function forgottenSwitchInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.INPUT_ACTION, // 13
+    isActionTriggered, InputHook.IS_ACTION_TRIGGERED);
+}
+// ModCallback.INPUT_ACTION (13)
+// InputHook.IS_ACTION_TRIGGERED (1)
+function isActionTriggered(_entity, _inputHook, buttonAction) {
+    if (buttonAction === ButtonAction.DROP && v.run.shouldSwitch) {
+        v.run.shouldSwitch = false;
+        return true;
+    }
+    return undefined;
+}
+/**
+ * When used on The Forgotten, switches to The Soul. When used on The Soul, switches to The
+ * Forgotten. This takes 1 game frame to take effect.
+ */
+export function forgottenSwitch() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    v.run.shouldSwitch = true;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yZ290dGVuU3dpdGNoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mZWF0dXJlcy9mb3Jnb3R0ZW5Td2l0Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFlBQVksRUFDWixTQUFTLEVBQ1QsV0FBVyxHQUNaLE1BQU0sOEJBQThCLENBQUM7QUFDdEMsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRTVELE1BQU0sWUFBWSxHQUFHLGlCQUFpQixDQUFDO0FBRXZDLE1BQU0sQ0FBQyxHQUFHO0lBQ1IsR0FBRyxFQUFFO1FBQ0gsWUFBWSxFQUFFLEtBQUs7S0FDcEI7Q0FDRixDQUFDO0FBRUYsZ0JBQWdCO0FBQ2hCLE1BQU0sVUFBVSxtQkFBbUIsQ0FBQyxHQUFRO0lBQzFDLGVBQWUsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFFakMsR0FBRyxDQUFDLFdBQVcsQ0FDYixXQUFXLENBQUMsWUFBWSxFQUFFLEtBQUs7SUFDL0IsaUJBQWlCLEVBQ2pCLFNBQVMsQ0FBQyxtQkFBbUIsQ0FDOUIsQ0FBQztBQUNKLENBQUM7QUFFRCxnQ0FBZ0M7QUFDaEMsb0NBQW9DO0FBQ3BDLFNBQVMsaUJBQWlCLENBQ3hCLE9BQTJCLEVBQzNCLFVBQXFCLEVBQ3JCLFlBQTBCO0lBRTFCLElBQUksWUFBWSxLQUFLLFlBQVksQ0FBQyxJQUFJLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxZQUFZLEVBQUU7UUFDNUQsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxZQUFZLEdBQUcsS0FBSyxDQUFDO1FBQzNCLE9BQU8sSUFBSSxDQUFDO0tBQ2I7SUFFRCxPQUFPLFNBQVMsQ0FBQztBQUNuQixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLGVBQWU7SUFDN0IsNkJBQTZCLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDNUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDO0FBQzVCLENBQUMifQ==

package/features/pause.js

@@ -0,0 +1,68 @@
+import { ButtonAction, CollectibleType, InputHook, ModCallback, } from "isaac-typescript-definitions";
+import { logError } from "../functions/log";
+import { useActiveItemTemp } from "../functions/player";
+import { disableAllInputsExceptFor, enableAllInputs } from "./disableInputs";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "pause";
+const v = {
+    run: {
+        isPseudoPaused: false,
+        shouldUnpause: false,
+    },
+};
+/** @internal */
+export function pauseInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+    mod.AddCallback(ModCallback.INPUT_ACTION, inputActionGetActionValue, InputHook.GET_ACTION_VALUE); // 13
+}
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+    if (!v.run.isPseudoPaused) {
+        return;
+    }
+    const player = Isaac.GetPlayer();
+    useActiveItemTemp(player, CollectibleType.PAUSE);
+}
+// ModCallback.INPUT_ACTION (13)
+// InputHook.GET_ACTION_VALUE (2)
+function inputActionGetActionValue(_entity, _inputHook, buttonAction) {
+    if (buttonAction !== ButtonAction.SHOOT_RIGHT) {
+        return;
+    }
+    if (!v.run.shouldUnpause) {
+        return;
+    }
+    v.run.shouldUnpause = false;
+    // Returning a value of 1 for a single 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 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`)
+ */
+export function pause() {
+    if (v.run.isPseudoPaused) {
+        logError("Failed to pseudo-pause the game, since it was already pseudo-paused.");
+        return;
+    }
+    v.run.isPseudoPaused = true;
+    const whitelist = new Set([ButtonAction.MENU_CONFIRM]);
+    disableAllInputsExceptFor(FEATURE_NAME, whitelist);
+}
+/** Helper function to put things back to normal after the `pause` function was used. */
+export function unpause() {
+    if (!v.run.isPseudoPaused) {
+        logError("Failed to pseudo-unpause the game, since it was not already pseudo-paused.");
+        return;
+    }
+    v.run.isPseudoPaused = false;
+    enableAllInputs(FEATURE_NAME);
+    v.run.shouldUnpause = true;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/persistentEntities.js

@@ -0,0 +1,120 @@
+import { EntityFlag, ModCallback, } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { spawn } from "../functions/entity";
+import { getRoomListIndex } from "../functions/roomData";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "persistentEntities";
+/** Iterates upward as new persistent entities are created. */
+let persistentEntityIndexCounter = 0;
+const v = {
+    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(),
+    },
+};
+/** @internal */
+export function persistentEntitiesInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.POST_ENTITY_REMOVE, postEntityRemove); // 67
+    mod.AddCallbackCustom(ModCallbackCustom.POST_NEW_ROOM_REORDERED, postNewRoomReordered);
+}
+// ModCallback.POST_ENTITY_REMOVE (67)
+function postEntityRemove(entity) {
+    const ptrHash = GetPtrHash(entity);
+    const tuple = v.room.spawnedPersistentEntities.get(ptrHash);
+    if (tuple === undefined) {
+        return;
+    }
+    const index = tuple[0];
+    // The persistent entity is despawning, presumably because the player is in the process of leaving
+    // the room. Keep track of the position for later. We use the previous room list index because at
+    // this point, the PostNewRoom callback has already fired and we are in a new room.
+    const level = game.GetLevel();
+    const previousRoomGridIndex = level.GetPreviousRoomIndex();
+    const previousRoomListIndex = getRoomListIndex(previousRoomGridIndex);
+    v.level.persistentEntities.set(index, {
+        entityType: entity.Type,
+        variant: entity.Variant,
+        subType: entity.SubType,
+        roomListIndex: previousRoomListIndex,
+        position: entity.Position,
+    });
+}
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+    const roomListIndex = getRoomListIndex();
+    for (const [index, description] of v.level.persistentEntities.entries()) {
+        if (roomListIndex !== description.roomListIndex) {
+            continue;
+        }
+        v.level.persistentEntities.delete(index);
+        spawnAndTrack(description.entityType, description.variant, description.subType, description.position, index, true);
+    }
+}
+/**
+ * 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.
+ *
+ * @returns A tuple containing the entity and the persistent entity index. You can use the index
+ *          with the `removePersistentEntity` function.
+ */
+export function spawnPersistentEntity(entityType, variant, subType, position) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    persistentEntityIndexCounter += 1;
+    const entity = spawnAndTrack(entityType, variant, subType, position, persistentEntityIndexCounter);
+    return [entity, persistentEntityIndexCounter];
+}
+function spawnAndTrack(entityType, variant, subType, position, index, respawning = false) {
+    const entity = spawn(entityType, variant, subType, position);
+    if (respawning) {
+        entity.ClearEntityFlags(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.
+ *
+ * @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.
+ */
+export function removePersistentEntity(persistentEntityIndex, removeEntity = true) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    v.level.persistentEntities.delete(persistentEntityIndex);
+    for (const [ptrHash, tuple] of v.room.spawnedPersistentEntities.entries()) {
+        const [index, entityPtr] = tuple;
+        if (index !== persistentEntityIndex) {
+            continue;
+        }
+        v.room.spawnedPersistentEntities.delete(ptrHash);
+        if (removeEntity && entityPtr.Ref !== undefined) {
+            entityPtr.Ref.Remove();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/playerInventory.js

@@ -0,0 +1,89 @@
+import { CollectibleType, ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { arrayRemoveInPlace, copyArray } from "../functions/array";
+import { isActiveCollectible } from "../functions/collectibles";
+import { getCollectibleSet } from "../functions/collectibleSet";
+import { defaultMapGetPlayer, mapSetPlayer, } from "../functions/playerDataStructures";
+import { getAllPlayers, getPlayerIndex } from "../functions/playerIndex";
+import { repeat } from "../functions/utils";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "playerInventory";
+const v = {
+    run: {
+        playersInventory: new DefaultMap((player) => newPlayerInventory(player)),
+    },
+};
+function newPlayerInventory(player) {
+    const inventory = [];
+    const collectibleSet = getCollectibleSet();
+    for (const collectibleType of collectibleSet.values()) {
+        const numCollectibles = player.GetCollectibleNum(collectibleType, true);
+        repeat(numCollectibles, () => {
+            inventory.push(collectibleType);
+        });
+    }
+    return inventory;
+}
+function resetInventory(player) {
+    const inventory = newPlayerInventory(player);
+    mapSetPlayer(v.run.playersInventory, player, inventory);
+}
+/** @internal */
+export function playerInventoryInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.POST_USE_ITEM, useItemD4, CollectibleType.D4); // 3
+    mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
+    mod.AddCallbackCustom(ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED, postCollectibleAdded);
+    mod.AddCallbackCustom(ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED, postCollectibleRemoved);
+}
+// ModCallback.POST_USE_ITEM (3)
+// CollectibleType.D4 (284)
+function useItemD4(_collectibleType, _rng, player) {
+    resetInventory(player);
+    return undefined;
+}
+// ModCallback.POST_GAME_STARTED (15)
+function postGameStarted() {
+    // We don't use the PostPlayerInit callback because some items are not given to the player at that
+    // point.
+    for (const player of getAllPlayers()) {
+        const playerIndex = getPlayerIndex(player);
+        if (!v.run.playersInventory.has(playerIndex)) {
+            resetInventory(player);
+        }
+    }
+}
+// ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED
+function postCollectibleAdded(player, collectibleType) {
+    const inventory = defaultMapGetPlayer(v.run.playersInventory, player, player);
+    inventory.push(collectibleType);
+}
+// ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED
+function postCollectibleRemoved(player, collectibleType) {
+    const inventory = defaultMapGetPlayer(v.run.playersInventory, player, player);
+    arrayRemoveInPlace(inventory, collectibleType);
+}
+/**
+ * Helper function to get all of the collectibles that the player has gotten so far on this run, in
+ * order.
+ *
+ * Note that this does not include active collectibles that have since been dropped for other
+ * collectibles.
+ *
+ * In the case of inventory initialization or the case where the player rerolls their build in the
+ * middle of the run (e.g. with D4), the order of the inventory will not correspond to the order
+ * that the items were actually given to the player. In this case, the inventory will be in the
+ * order of the lowest `CollectibleType` to the highest.
+ */
+export function getPlayerInventory(player, includeActiveCollectibles = true) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const inventory = defaultMapGetPlayer(v.run.playersInventory, player, player);
+    const copiedInventory = copyArray(inventory);
+    if (includeActiveCollectibles) {
+        return copiedInventory;
+    }
+    return copiedInventory.filter((collectibleType) => !isActiveCollectible(collectibleType));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxheWVySW52ZW50b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mZWF0dXJlcy9wbGF5ZXJJbnZlbnRvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxXQUFXLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUM1RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDL0QsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ25FLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFDTCxtQkFBbUIsRUFDbkIsWUFBWSxHQUNiLE1BQU0sbUNBQW1DLENBQUM7QUFDM0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxjQUFjLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN6RSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFNUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRTVELE1BQU0sWUFBWSxHQUFHLGlCQUFpQixDQUFDO0FBRXZDLE1BQU0sQ0FBQyxHQUFHO0lBQ1IsR0FBRyxFQUFFO1FBQ0gsZ0JBQWdCLEVBQUUsSUFBSSxVQUFVLENBSTlCLENBQUMsTUFBb0IsRUFBRSxFQUFFLENBQUMsa0JBQWtCLENBQUMsTUFBTSxDQUFDLENBQUM7S0FDeEQ7Q0FDRixDQUFDO0FBRUYsU0FBUyxrQkFBa0IsQ0FBQyxNQUFvQjtJQUM5QyxNQUFNLFNBQVMsR0FBc0IsRUFBRSxDQUFDO0lBRXhDLE1BQU0sY0FBYyxHQUFHLGlCQUFpQixFQUFFLENBQUM7SUFDM0MsS0FBSyxNQUFNLGVBQWUsSUFBSSxjQUFjLENBQUMsTUFBTSxFQUFFLEVBQUU7UUFDckQsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDLGlCQUFpQixDQUFDLGVBQWUsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUN4RSxNQUFNLENBQUMsZUFBZSxFQUFFLEdBQUcsRUFBRTtZQUMzQixTQUFTLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ2xDLENBQUMsQ0FBQyxDQUFDO0tBQ0o7SUFFRCxPQUFPLFNBQVMsQ0FBQztBQUNuQixDQUFDO0FBRUQsU0FBUyxjQUFjLENBQUMsTUFBb0I7SUFDMUMsTUFBTSxTQUFTLEdBQUcsa0JBQWtCLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDN0MsWUFBWSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0FBQzFELENBQUM7QUFFRCxnQkFBZ0I7QUFDaEIsTUFBTSxVQUFVLG1CQUFtQixDQUFDLEdBQWdCO0lBQ2xELGVBQWUsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFFakMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsYUFBYSxFQUFFLFNBQVMsRUFBRSxlQUFlLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJO0lBQy9FLEdBQUcsQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLGlCQUFpQixFQUFFLGVBQWUsQ0FBQyxDQUFDLENBQUMsS0FBSztJQUN0RSxHQUFHLENBQUMsaUJBQWlCLENBQ25CLGlCQUFpQixDQUFDLDZCQUE2QixFQUMvQyxvQkFBb0IsQ0FDckIsQ0FBQztJQUNGLEdBQUcsQ0FBQyxpQkFBaUIsQ0FDbkIsaUJBQWlCLENBQUMsK0JBQStCLEVBQ2pELHNCQUFzQixDQUN2QixDQUFDO0FBQ0osQ0FBQztBQUVELGdDQUFnQztBQUNoQywyQkFBMkI7QUFDM0IsU0FBUyxTQUFTLENBQ2hCLGdCQUFpQyxFQUNqQyxJQUFTLEVBQ1QsTUFBb0I7SUFFcEIsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXZCLE9BQU8sU0FBUyxDQUFDO0FBQ25CLENBQUM7QUFFRCxxQ0FBcUM7QUFDckMsU0FBUyxlQUFlO0lBQ3RCLGtHQUFrRztJQUNsRyxTQUFTO0lBQ1QsS0FBSyxNQUFNLE1BQU0sSUFBSSxhQUFhLEVBQUUsRUFBRTtRQUNwQyxNQUFNLFdBQVcsR0FBRyxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDM0MsSUFBSSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxFQUFFO1lBQzVDLGNBQWMsQ0FBQyxNQUFNLENBQUMsQ0FBQztTQUN4QjtLQUNGO0FBQ0gsQ0FBQztBQUVELGtEQUFrRDtBQUNsRCxTQUFTLG9CQUFvQixDQUMzQixNQUFvQixFQUNwQixlQUFnQztJQUVoQyxNQUFNLFNBQVMsR0FBRyxtQkFBbUIsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUM5RSxTQUFTLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDO0FBQ2xDLENBQUM7QUFFRCxvREFBb0Q7QUFDcEQsU0FBUyxzQkFBc0IsQ0FDN0IsTUFBb0IsRUFDcEIsZUFBZ0M7SUFFaEMsTUFBTSxTQUFTLEdBQUcsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDOUUsa0JBQWtCLENBQUMsU0FBUyxFQUFFLGVBQWUsQ0FBQyxDQUFDO0FBQ2pELENBQUM7QUFFRDs7Ozs7Ozs7Ozs7R0FXRztBQUNILE1BQU0sVUFBVSxrQkFBa0IsQ0FDaEMsTUFBb0IsRUFDcEIseUJBQXlCLEdBQUcsSUFBSTtJQUVoQyw2QkFBNkIsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUU1QyxNQUFNLFNBQVMsR0FBRyxtQkFBbUIsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUU5RSxNQUFNLGVBQWUsR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDN0MsSUFBSSx5QkFBeUIsRUFBRTtRQUM3QixPQUFPLGVBQWUsQ0FBQztLQUN4QjtJQUVELE9BQU8sZUFBZSxDQUFDLE1BQU0sQ0FDM0IsQ0FBQyxlQUFlLEVBQUUsRUFBRSxDQUFDLENBQUMsbUJBQW1CLENBQUMsZUFBZSxDQUFDLENBQzNELENBQUM7QUFDSixDQUFDIn0=

package/features/ponyDetection.js

@@ -0,0 +1,63 @@
+// Detecting whether or not A Pony or White Pony is active is difficult with the vanilla API.
+// Normally, activation will cause the player to have the respective temporary collectible effect
+// However, this effect is lost if the player enters a new room (but the effect will still be
+// active). When the effect is active, the player will have some specific entity flags. Thus, we can
+// work around the problem by checking to see if the player has these entity flags and has had a
+// collectible effect on a previous frame.
+import { CollectibleType, EntityFlag } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { hasFlag } from "../functions/flag";
+import { setAddPlayer, setDeletePlayer, setHasPlayer, } from "../functions/playerDataStructures";
+import { getPlayers } from "../functions/playerIndex";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "ponyDetection";
+const FLAGS_WHEN_PONY_IS_ACTIVE = [
+    EntityFlag.NO_KNOCKBACK,
+    EntityFlag.NO_PHYSICS_KNOCKBACK,
+    EntityFlag.NO_DAMAGE_BLINK, // 1 << 36
+];
+const v = {
+    run: {
+        playersIsPonyActive: new Set(),
+    },
+};
+/** @internal */
+export function ponyDetectionInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallbackCustom(ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED, postPEffectUpdateReordered);
+}
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player) {
+    const effects = player.GetEffects();
+    const entityFlags = player.GetEntityFlags();
+    const hasPonyCollectibleEffect = effects.HasCollectibleEffect(CollectibleType.PONY) ||
+        effects.HasCollectibleEffect(CollectibleType.WHITE_PONY);
+    const isPonyActiveOnPreviousFrame = setHasPlayer(v.run.playersIsPonyActive, player);
+    const hasPonyFlags = hasFlag(entityFlags, ...FLAGS_WHEN_PONY_IS_ACTIVE);
+    const isPonyActiveNow = hasPonyCollectibleEffect || (isPonyActiveOnPreviousFrame && hasPonyFlags);
+    if (isPonyActiveNow) {
+        setAddPlayer(v.run.playersIsPonyActive, player);
+    }
+    else {
+        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.
+ */
+export function isPlayerUsingPony(player) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    return 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.
+ */
+export function anyPlayerUsingPony() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const players = getPlayers();
+    return players.some((player) => isPlayerUsingPony(player));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/preventCollectibleRotation.js

@@ -0,0 +1,81 @@
+// Keep specific items from being affected by the Glitched Crown, Binge Eater, and the Tainted Isaac
+// switching mechanic.
+import { Card, CollectibleType, ModCallback, PickupVariant, } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { setCollectibleSubType } from "../functions/collectibles";
+import { getEntityID } from "../functions/entity";
+import { isCollectible } from "../functions/pickupVariants";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "preventCollectibleRotation";
+const v = {
+    room: {
+        /**
+         * Index is a string containing the grid index and the InitSeed of the collectible.
+         * (e.g. "12,1123579202")
+         *
+         * (We cannot simply use the InitSeed of the collectible because Diplopia can cause multiple
+         * collectibles in the room to have the same InitSeed. However, no two collectibles should ever
+         * be on the same grid index.)
+         *
+         * (We cannot use PtrHash as an index because that stays the same when the item is rolled.)
+         */
+        trackedCollectibles: new Map(),
+    },
+};
+/** @internal */
+export function preventCollectibleRotationInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.POST_USE_CARD, useCardSoulOfIsaac, Card.SOUL_ISAAC); // 5
+    mod.AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdateCollectible, PickupVariant.COLLECTIBLE); // 35
+}
+// ModCallback.POST_USE_CARD (5)
+// Card.SOUL_ISAAC (81)
+function useCardSoulOfIsaac() {
+    // Soul of Isaac causes items to flip. Delete all tracked items (assuming that the player
+    // deliberately wants to roll a quest item).
+    v.room.trackedCollectibles.clear();
+}
+// ModCallback.POST_PICKUP_UPDATE (35)
+// PickupVariant.COLLECTIBLE (100)
+function postPickupUpdateCollectible(pickup) {
+    const collectible = pickup;
+    // Ignore empty pedestals (i.e. items that have already been taken by the player).
+    if (collectible.SubType === CollectibleType.NULL) {
+        return;
+    }
+    const index = getMapIndex(collectible);
+    const trackedCollectibleType = v.room.trackedCollectibles.get(index);
+    if (trackedCollectibleType !== undefined &&
+        collectible.SubType !== trackedCollectibleType) {
+        // This item has switched, so restore it back to the way it was.
+        setCollectibleSubType(collectible, trackedCollectibleType);
+    }
+}
+/**
+ * Helper function to prevent a collectible from being affected by Tainted Isaac's rotation
+ * mechanic. (This mechanic also happens from Glitched Crown and Binge Eater.) This is useful
+ * because quest items that are manually spawned by mods will be automatically be affected by this
+ * mechanic.
+ *
+ * It is required to pass the intended collectible type to this function since it is possible for
+ * collectibles to rotate on the first frame that they are spawned.
+ */
+export function preventCollectibleRotation(collectible, collectibleType) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    if (!isCollectible(collectible)) {
+        const entityID = getEntityID(collectible);
+        error(`The "preventCollectibleRotate" function was given a non-collectible: ${entityID}`);
+    }
+    const index = getMapIndex(collectible);
+    v.room.trackedCollectibles.set(index, collectibleType);
+    // The item might have already shifted on the first frame that it spawns, so change it back if
+    // necessary.
+    postPickupUpdateCollectible(collectible);
+}
+function getMapIndex(collectible) {
+    const room = game.GetRoom();
+    const gridIndex = room.GetGridIndex(collectible.Position);
+    return `${gridIndex},${collectible.InitSeed}`;
+}
+//# sourceMappingURL=data:application/json;base64,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