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

package/features/registerHotkey.js

@@ -0,0 +1,91 @@
+import { Keyboard, ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { isKeyboardPressed } from "../functions/input";
+import { isFunction } from "../functions/types";
+const FEATURE_NAME = "registerHotkeys";
+/**
+ * The keys are the keyboard keys that trigger the hotkey. The values are the functions that contain
+ * the arbitrary code to run.
+ */
+const staticHotkeyFunctionMap = new Map();
+/**
+ * The keys are the functions that determine what the hotkey key is. The values are the functions
+ * that contain the arbitrary code to run.
+ */
+const dynamicHotkeyFunctionMap = new Map();
+const keyPressedMap = new DefaultMap(false);
+/** @internal */
+export function registerHotkeyInit(mod) {
+    mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+// ModCallback.POST_RENDER (2)
+function postRender() {
+    for (const [keyboard, triggerFunc] of staticHotkeyFunctionMap.entries()) {
+        checkIfTriggered(keyboard, triggerFunc);
+    }
+    for (const [keyboardFunc, triggerFunc,] of dynamicHotkeyFunctionMap.entries()) {
+        const keyboard = keyboardFunc();
+        if (keyboard !== undefined) {
+            checkIfTriggered(keyboard, triggerFunc);
+        }
+    }
+}
+function checkIfTriggered(keyboard, triggerFunc) {
+    const isPressed = isKeyboardPressed(keyboard);
+    const wasPreviouslyPressed = keyPressedMap.getAndSetDefault(keyboard);
+    keyPressedMap.set(keyboard, isPressed);
+    if (isPressed && !wasPreviouslyPressed) {
+        triggerFunc();
+    }
+}
+/**
+ * Helper function to run arbitrary code when you press and release a specific keyboard key.
+ *
+ * This can be used to easily set up custom hotkeys to facilitate custom game features or to assist
+ * in debugging.
+ *
+ * @param keyboardOrFunc Either the key that you want to trigger the hotkey or a function that
+ *                       returns the key that will trigger the hotkey. Normally, you would just
+ *                       specify the key directly, but you can use a function for situations where
+ *                       the key can change (like if end-users can specify a custom hotkey using Mod
+ *                       Config Menu).
+ * @param triggerFunc A function containing the arbitrary code that you want to execute when the
+ *                    hotkey is triggered.
+ */
+export function registerHotkey(keyboardOrFunc, triggerFunc) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    if (isFunction(keyboardOrFunc)) {
+        if (dynamicHotkeyFunctionMap.has(keyboardOrFunc)) {
+            error("Failed to register a hotkey due to a custom hotkey already being defined for the submitted function.");
+        }
+        dynamicHotkeyFunctionMap.set(keyboardOrFunc, triggerFunc);
+    }
+    else {
+        if (staticHotkeyFunctionMap.has(keyboardOrFunc)) {
+            error(`Failed to register a hotkey due to a hotkey already being defined for key: Keyboard.${Keyboard[keyboardOrFunc]} (${keyboardOrFunc})`);
+        }
+        staticHotkeyFunctionMap.set(keyboardOrFunc, triggerFunc);
+    }
+}
+/**
+ * Helper function to remove a hotkey created with the `registerHotkey` function.
+ *
+ * @param keyboardOrFunc Equal to the value that you passed when initially registering the hotkey.
+ */
+export function unregisterHotkey(keyboardOrFunc) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    if (isFunction(keyboardOrFunc)) {
+        if (!dynamicHotkeyFunctionMap.has(keyboardOrFunc)) {
+            error("Failed to unregister a hotkey since there is no existing hotkey defined for the submitted function.");
+        }
+        dynamicHotkeyFunctionMap.delete(keyboardOrFunc);
+    }
+    else {
+        if (!staticHotkeyFunctionMap.has(keyboardOrFunc)) {
+            error(`Failed to unregister a hotkey since there is no existing hotkey defined for key: Keyboard.${Keyboard[keyboardOrFunc]} (${keyboardOrFunc})`);
+        }
+        staticHotkeyFunctionMap.delete(keyboardOrFunc);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/roomClearFrame.js

@@ -0,0 +1,42 @@
+import { game } from "../cachedClasses";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "roomClearFrame";
+const v = {
+    room: {
+        roomClearGameFrame: undefined,
+        roomClearRoomFrame: undefined,
+    },
+};
+/** @internal */
+export function roomClearFrameInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallbackCustom(ModCallbackCustom.POST_ROOM_CLEAR_CHANGED, postRoomClearChangedTrue, true);
+}
+// ModCallbackCustom.POST_ROOM_CLEAR_CHANGED
+// true
+function postRoomClearChangedTrue() {
+    const gameFrameCount = game.GetFrameCount();
+    const room = game.GetRoom();
+    const roomFrameCount = room.GetFrameCount();
+    v.room.roomClearGameFrame = gameFrameCount;
+    v.room.roomClearRoomFrame = roomFrameCount;
+}
+/**
+ * Helper function to get the game frame (i.e. `Game.GetFrameCount`) of the last time that this room
+ * was cleared. Returns undefined if the room has never been cleared.
+ */
+export function getRoomClearGameFrame() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    return v.room.roomClearGameFrame;
+}
+/**
+ * Helper function to get the room frame (i.e. `Room.GetFrameCount`) of the last time that this room
+ * was cleared. Returns undefined if the room has never been cleared.
+ */
+export function getRoomClearRoomFrame() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    return v.room.roomClearGameFrame;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9vbUNsZWFyRnJhbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2ZlYXR1cmVzL3Jvb21DbGVhckZyYW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUV4QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFNUQsTUFBTSxZQUFZLEdBQUcsZ0JBQWdCLENBQUM7QUFFdEMsTUFBTSxDQUFDLEdBQUc7SUFDUixJQUFJLEVBQUU7UUFDSixrQkFBa0IsRUFBRSxTQUE0QjtRQUNoRCxrQkFBa0IsRUFBRSxTQUE0QjtLQUNqRDtDQUNGLENBQUM7QUFFRixnQkFBZ0I7QUFDaEIsTUFBTSxVQUFVLGtCQUFrQixDQUFDLEdBQWdCO0lBQ2pELGVBQWUsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFFakMsR0FBRyxDQUFDLGlCQUFpQixDQUNuQixpQkFBaUIsQ0FBQyx1QkFBdUIsRUFDekMsd0JBQXdCLEVBQ3hCLElBQUksQ0FDTCxDQUFDO0FBQ0osQ0FBQztBQUVELDRDQUE0QztBQUM1QyxPQUFPO0FBQ1AsU0FBUyx3QkFBd0I7SUFDL0IsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO0lBQzVDLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUM1QixNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7SUFFNUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsR0FBRyxjQUFjLENBQUM7SUFDM0MsQ0FBQyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsR0FBRyxjQUFjLENBQUM7QUFDN0MsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sVUFBVSxxQkFBcUI7SUFDbkMsNkJBQTZCLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDNUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDO0FBQ25DLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUscUJBQXFCO0lBQ25DLDZCQUE2QixDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzVDLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQztBQUNuQyxDQUFDIn0=

package/features/runInNFrames.js

@@ -0,0 +1,189 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { arrayRemoveInPlace } from "../functions/array";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "runInNFrames";
+const v = {
+    run: {
+        queuedGameFunctionTuples: [],
+        queuedRenderFunctionTuples: [],
+        intervalGameFunctionTuples: [],
+        intervalRenderFunctionTuples: [],
+    },
+};
+/** @internal */
+export function runInNFramesInit(mod) {
+    saveDataManager(FEATURE_NAME, v, () => false); // Functions are not serializable.
+    mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+    mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+    const gameFrameCount = game.GetFrameCount();
+    checkExecuteQueuedFunctions(gameFrameCount, v.run.queuedGameFunctionTuples);
+    checkExecuteIntervalFunctions(gameFrameCount, v.run.intervalGameFunctionTuples);
+}
+// ModCallback.POST_RENDER (2)
+function postRender() {
+    const renderFrameCount = Isaac.GetFrameCount();
+    checkExecuteQueuedFunctions(renderFrameCount, v.run.queuedRenderFunctionTuples);
+    checkExecuteIntervalFunctions(renderFrameCount, v.run.intervalRenderFunctionTuples);
+}
+function checkExecuteQueuedFunctions(frameCount, functionTuples) {
+    const firingFunctions = functionTuples.filter(([frameCountToFire]) => frameCount >= frameCountToFire);
+    for (const tuple of firingFunctions) {
+        const [_frameCountToFire, func] = tuple;
+        func();
+        arrayRemoveInPlace(functionTuples, tuple);
+    }
+}
+function checkExecuteIntervalFunctions(frameCount, functionTuples) {
+    const firingFunctions = functionTuples.filter(([frameCountToFire]) => frameCount >= frameCountToFire);
+    for (const tuple of firingFunctions) {
+        const [_frameCountToFire, func, numIntervalFrames] = tuple;
+        const returnValue = func();
+        arrayRemoveInPlace(functionTuples, tuple);
+        // Queue the next interval (as long as the function did not return false).
+        if (returnValue) {
+            const nextFireFrame = frameCount + numIntervalFrames;
+            const newTuple = [
+                nextFireFrame,
+                func,
+                numIntervalFrames,
+            ];
+            functionTuples.push(newTuple);
+        }
+    }
+}
+/**
+ * Supply a function to run N game frames from now in the `POST_UPDATE` callback.
+ *
+ * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
+ * way.
+ *
+ * Note that this function will not handle saving and quitting. If a player saving and quitting
+ * before the deferred function fires would cause a bug in your mod, then you should handle deferred
+ * functions manually using serializable data.
+ */
+export function runInNGameFrames(func, gameFrames) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const gameFrameCount = game.GetFrameCount();
+    const functionFireFrame = gameFrameCount + gameFrames;
+    const tuple = [functionFireFrame, func];
+    v.run.queuedGameFunctionTuples.push(tuple);
+}
+/**
+ * Supply a function to run N render frames from now in the `POST_RENDER` callback.
+ *
+ * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
+ * way.
+ *
+ * Note that this function will not handle saving and quitting. If a player saving and quitting
+ * before the deferred function fires would cause a bug in your mod, then you should handle deferred
+ * functions manually using serializable data.
+ */
+export function runInNRenderFrames(func, renderFrames) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const renderFrameCount = Isaac.GetFrameCount();
+    const functionFireFrame = renderFrameCount + renderFrames;
+    const tuple = [functionFireFrame, func];
+    v.run.queuedRenderFunctionTuples.push(tuple);
+}
+/**
+ * Supply a function to run on the next `POST_UPDATE` callback.
+ *
+ * For example:
+ *
+ * ```ts
+ * const NUM_EXPLODER_EXPLOSIONS = 5;
+ *
+ * function useItemExploder(player: EntityPlayer) {
+ *   playSound("exploderBegin");
+ *   explode(player, NUM_EXPLODER_EXPLOSIONS);
+ * }
+ *
+ * function explode(player: EntityPlayer, numFramesLeft: int) {
+ *   Isaac.Explode(player, undefined, 1);
+ *   numFramesLeft -= 1;
+ *   if (numFramesLeft === 0) {
+ *     runNextFrame(() => {
+ *       explode(player, numFramesLeft);
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * Note that this function will not handle saving and quitting. If a player saving and quitting
+ * before the deferred function fires would cause a bug in your mod, then you should handle deferred
+ * functions manually using serializable data.
+ */
+export function runNextGameFrame(func) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    runInNGameFrames(func, 1);
+}
+/**
+ * Supply a function to run on the next `POST_RENDER` callback.
+ *
+ * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
+ * way.
+ *
+ * Note that this function will not handle saving and quitting.
+ */
+export function runNextRenderFrame(func) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    runInNRenderFrames(func, 1);
+}
+/**
+ * Supply a function to be repeatedly run on an interval of N game frames in the `POST_UPDATE`
+ * callback. The function will continue to be fired until `false` is returned from the function.
+ *
+ * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+ * corresponding `clearInterval` function. (Instead, the return value from the supplied function is
+ * used to stop the interval.)
+ *
+ * Note that this function will not handle saving and quitting. You must manually restart any
+ * intervals if the player saves and quits in the middle of a run.
+ *
+ * @param func The function to repeatedly run on an interval.
+ * @param gameFrames The amount of game frames to wait between each run.
+ * @param runImmediately Whether or not to execute the function right now before waiting for the
+ *                       interval.
+ */
+export function setIntervalGameFrames(func, gameFrames, runImmediately) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const gameFrameCount = game.GetFrameCount();
+    const functionFireFrame = gameFrameCount + gameFrames;
+    const tuple = [functionFireFrame, func, gameFrames];
+    v.run.intervalGameFunctionTuples.push(tuple);
+    if (runImmediately) {
+        func();
+    }
+}
+/**
+ * Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
+ * callback. The function will continue to be fired until `false` is returned from the function.
+ *
+ * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+ * corresponding `clearInterval` function. (Instead, the return value from the supplied function is
+ * used to stop the interval.)
+ *
+ * Note that this function will not handle saving and quitting. You must manually restart any
+ * intervals if the player saves and quits in the middle of a run.
+ *
+ * @param func The function to repeatedly run on an interval.
+ * @param renderFrames The amount of game frames to wait between each run.
+ * @param runImmediately Whether or not to execute the function right now before waiting for the
+ *                       interval.
+ */
+export function setIntervalRenderFrames(func, renderFrames, runImmediately) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const renderFrameCount = Isaac.GetFrameCount();
+    const functionFireFrame = renderFrameCount + renderFrames;
+    const tuple = [functionFireFrame, func, renderFrames];
+    v.run.intervalGameFunctionTuples.push(tuple);
+    if (runImmediately) {
+        func();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/runNextRoom.js

@@ -0,0 +1,34 @@
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { emptyArray } from "../functions/array";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "runNextRoom";
+const v = {
+    run: {
+        queuedFunctions: [],
+    },
+};
+/** @internal */
+export function runNextRoomInit(mod) {
+    saveDataManager(FEATURE_NAME, v, () => false); // Functions are not serializable.
+    mod.AddCallbackCustom(ModCallbackCustom.POST_NEW_ROOM_REORDERED, postNewRoomReordered);
+}
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+    for (const func of v.run.queuedFunctions) {
+        func();
+    }
+    emptyArray(v.run.queuedFunctions);
+}
+/**
+ * Supply a function to run on the next `POST_NEW_ROOM` callback.
+ *
+ * Note that this function will not handle saving and quitting. If a player saving and quitting
+ * before the deferred function fires would cause a bug in your mod, then you should handle deferred
+ * functions manually using serializable data.
+ */
+export function runNextRoom(func) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    v.run.queuedFunctions.push(func);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuTmV4dFJvb20uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2ZlYXR1cmVzL3J1bk5leHRSb29tLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQy9ELE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNoRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFNUQsTUFBTSxZQUFZLEdBQUcsYUFBYSxDQUFDO0FBRW5DLE1BQU0sQ0FBQyxHQUFHO0lBQ1IsR0FBRyxFQUFFO1FBQ0gsZUFBZSxFQUFFLEVBQXVCO0tBQ3pDO0NBQ0YsQ0FBQztBQUVGLGdCQUFnQjtBQUNoQixNQUFNLFVBQVUsZUFBZSxDQUFDLEdBQWdCO0lBQzlDLGVBQWUsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsa0NBQWtDO0lBRWpGLEdBQUcsQ0FBQyxpQkFBaUIsQ0FDbkIsaUJBQWlCLENBQUMsdUJBQXVCLEVBQ3pDLG9CQUFvQixDQUNyQixDQUFDO0FBQ0osQ0FBQztBQUVELDRDQUE0QztBQUM1QyxTQUFTLG9CQUFvQjtJQUMzQixLQUFLLE1BQU0sSUFBSSxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsZUFBZSxFQUFFO1FBQ3hDLElBQUksRUFBRSxDQUFDO0tBQ1I7SUFFRCxVQUFVLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQztBQUNwQyxDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FBQyxJQUFnQjtJQUMxQyw2QkFBNkIsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUM1QyxDQUFDLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDbkMsQ0FBQyJ9

package/features/saveDataManager/exports.js

@@ -0,0 +1,183 @@
+import { SerializationType } from "../../enums/SerializationType";
+import { errorIfFeaturesNotInitialized } from "../../featuresInitialized";
+import { deepCopy } from "../../functions/deepCopy";
+import { isString } from "../../functions/types";
+import { forceSaveDataManagerLoad, forceSaveDataManagerSave, restoreDefaultSaveData, } from "./main";
+import { saveDataConditionalFuncMap, saveDataDefaultsMap, saveDataMap, } from "./maps";
+import { SAVE_DATA_MANAGER_FEATURE_NAME } from "./saveDataManagerConstants";
+/**
+ * This is the entry point to the save data manager, a system which provides two major features:
+ *
+ * 1. automatic resetting of variables on a new run, on a new level, or on a new room (as desired)
+ * 2. automatic saving and loading of all tracked data to the "save#.dat" file
+ *
+ * You feed this function with an anonymous object containing your variables, and then it will
+ * automatically manage them for you. (See below for an example.)
+ *
+ * The save data manager is meant to be called once for each feature of your mod. In other words,
+ * you should not put all of the data for your mod on the same object. Instead, scope your variables
+ * locally to a single file that contains a mod feature, and then call this function to register
+ * them. For example:
+ *
+ * ```ts
+ * // in file: feature1.ts
+ * import { saveDataManager } from "isaacscript-common";
+ *
+ * // Declare local variables for this file or feature.
+ * const v = {
+ *   // These variables are never reset; manage them yourself at will.
+ *   persistent: {
+ *     foo1: 0,
+ *   },
+ *
+ *   // These variables are reset at the beginning of every run.
+ *   run: {
+ *     foo2: 0,
+ *   },
+ *
+ *   // These variables are reset at the beginning of every level.
+ *   level: {
+ *     foo3: 0,
+ *   },
+ *
+ *   // These variables are reset at the beginning of every room.
+ *   room: {
+ *     foo4: 0,
+ *   },
+ * };
+ * // Every child object is optional; only create the ones that you need.
+ *
+ * // Register the variables with the save data manager. (We need to provide a string key that
+ * // matches the name of this file.)
+ * function feature1Init() {
+ *   saveDataManager("feature1", v);
+ * }
+ *
+ * // Elsewhere in the file, use your variables.
+ * function feature1Function() {
+ *   if (v.run.foo1 > 0) {
+ *     // Insert code here.
+ *   }
+ * }
+ * ```
+ *
+ * - Save data is loaded from disk in the `POST_PLAYER_INIT` callback (i.e. the first callback that
+ *   can possibly run).
+ * - Save data is recorded to disk in the `PRE_GAME_EXIT` callback.
+ *
+ * Note that before using the save data manager, you must call the `upgradeMod` function. (Upgrade
+ * your mod before registering any of your own callbacks so that the save data manager will run
+ * before any of your code does.)
+ *
+ * If you want the save data manager to load data before the `POST_PLAYER_INIT` callback (i.e. in
+ * the main menu), then you should explicitly call the `saveDataManagerLoad` function. (The save
+ * data manager cannot do this on its own because it cannot know when your mod features are finished
+ * initializing.)
+ *
+ * Finally, some features may have variables that need to be automatically reset per run/level, but
+ * not saved to disk on game exit. (For example, if they contain functions or other non-serializable
+ * data.) For these cases, set the second argument to `() => false`.
+ *
+ * @param key The name of the file or feature that is submitting data to be managed by the save data
+ *            manager. The save data manager will throw an error if the key is already registered.
+ * @param v An object that corresponds to the `SaveData` interface. The object is conventionally
+ *          called "v" for brevity. ("v" is short for "local variables").
+ * @param conditionalFunc An optional function to run upon saving this key to disk. For example,
+ *                        this allows features to only save data to disk if the feature is enabled.
+ *                        Specify a value of `() => false` to completely disable saving this feature
+ *                        to disk. Disabling saving to disk is useful if you are using data that is
+ *                        not serializable. Alternatively, it could be useful if you want to use the
+ *                        save data manager to automatically reset variables on run/level/room, but
+ *                        not clutter the the "save#.dat" file with unnecessary keys.
+ */
+export function saveDataManager(key, v, conditionalFunc) {
+    errorIfFeaturesNotInitialized(SAVE_DATA_MANAGER_FEATURE_NAME);
+    if (!isString(key)) {
+        error(`The ${SAVE_DATA_MANAGER_FEATURE_NAME} requires that keys are strings. You tried to use a key of type: ${typeof key}`);
+    }
+    if (saveDataMap.has(key)) {
+        error(`The ${SAVE_DATA_MANAGER_FEATURE_NAME} is already managing save data for a key of: ${key}`);
+    }
+    // Add the new save data to the map.
+    saveDataMap.set(key, v);
+    // If the only key in the save data is "room", then we don't have to worry about saving this data
+    // to disk (because the room would be reloaded upon resuming a continued run).
+    const saveDataKeys = Object.keys(v);
+    if (saveDataKeys.length === 1 && saveDataKeys[0] === "room") {
+        conditionalFunc = () => false;
+    }
+    // Make a copy of the initial save data so that we can use it to restore the default values later
+    // on.
+    const saveDataTable = v;
+    const saveDataCopy = deepCopy(saveDataTable, SerializationType.NONE, key);
+    saveDataDefaultsMap.set(key, saveDataCopy);
+    // Store the conditional function for later, if present.
+    if (conditionalFunc !== undefined) {
+        saveDataConditionalFuncMap.set(key, conditionalFunc);
+    }
+}
+/**
+ * The save data manager will automatically load variables from disk at the appropriate times (i.e.
+ * when a new run is started). Use this function to explicitly force the save data manager to load
+ * all of its variables from disk immediately.
+ *
+ * Obviously, doing this will overwrite the current data, so using this function can potentially
+ * result in lost state.
+ */
+export function saveDataManagerLoad() {
+    errorIfFeaturesNotInitialized(SAVE_DATA_MANAGER_FEATURE_NAME);
+    forceSaveDataManagerLoad();
+}
+/**
+ * The save data manager will automatically save variables to disk at the appropriate times (i.e.
+ * when the run is exited). Use this function to explicitly force the save data manager to write all
+ * of its variables to disk immediately.
+ */
+export function saveDataManagerSave() {
+    errorIfFeaturesNotInitialized(SAVE_DATA_MANAGER_FEATURE_NAME);
+    forceSaveDataManagerSave();
+}
+/**
+ * - Sets the global variable of "g" equal to all of the save data variables for this mod.
+ * - Sets the global variable of "gd" equal to all of the save data default variables for this mod.
+ *
+ * This can make debugging easier, as you can access the variables from the game's debug console.
+ * e.g. `l print(g.feature1.foo)`
+ */
+export function saveDataManagerSetGlobal() {
+    errorIfFeaturesNotInitialized(SAVE_DATA_MANAGER_FEATURE_NAME);
+    g = saveDataMap; // eslint-disable-line @typescript-eslint/no-unused-vars
+    gd = saveDataDefaultsMap; // eslint-disable-line @typescript-eslint/no-unused-vars
+}
+/**
+ * The save data manager will automatically reset variables at the appropriate times (i.e. when a
+ * player enters a new room). Use this function to explicitly force the save data manager to reset a
+ * specific variable group.
+ *
+ * For example:
+ *
+ * ```ts
+ * const v = {
+ *   room: {
+ *     foo: 123,
+ *   },
+ * };
+ *
+ * saveDataManager("file1", v);
+ *
+ * // Then, later on, to explicit reset all of the "room" variables:
+ * saveDataManagerReset("file1", "room");
+ * ```
+ */
+export function saveDataManagerReset(key, childObjectKey) {
+    errorIfFeaturesNotInitialized(SAVE_DATA_MANAGER_FEATURE_NAME);
+    if (!isString(key)) {
+        error(`The ${SAVE_DATA_MANAGER_FEATURE_NAME} requires that keys are strings. You tried to use a key of type: ${typeof key}`);
+    }
+    const saveData = saveDataMap.get(key);
+    if (saveData === undefined) {
+        error(`The ${SAVE_DATA_MANAGER_FEATURE_NAME} is not managing save data for a key of: ${key}`);
+    }
+    restoreDefaultSaveData(key, saveData, childObjectKey);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/saveDataManager/load.js

@@ -0,0 +1,69 @@
+import { jsonDecode } from "../../functions/jsonHelpers";
+import { log, logError } from "../../functions/log";
+import { iterateTableInOrder } from "../../functions/table";
+import { isString, isTable } from "../../functions/types";
+import { merge } from "./merge";
+import { SAVE_DATA_MANAGER_DEBUG, SAVE_DATA_MANAGER_FEATURE_NAME, } from "./saveDataManagerConstants";
+const DEFAULT_MOD_DATA = "{}";
+export function loadFromDisk(mod, oldSaveData) {
+    if (!mod.HasData()) {
+        // There is no "save#.dat" file for this save slot.
+        return;
+    }
+    // First, read the "save#.dat" file into a Lua table.
+    const jsonString = readSaveDatFile(mod);
+    const newSaveData = jsonDecode(jsonString);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log('Converted data from the "save#.dat" to a Lua table.');
+    }
+    // Second, iterate over all the fields of the new table.)
+    iterateTableInOrder(newSaveData, (key, value) => {
+        // All elements of loaded save data should have keys that are strings equal to the name of the
+        // subscriber/feature. Ignore elements with other types of keys.
+        if (!isString(key)) {
+            return;
+        }
+        // All elements of loaded save data should be tables that contain fields corresponding to the
+        // SaveData interface. Ignore elements that are not tables.
+        if (!isTable(value)) {
+            return;
+        }
+        // Ignore elements that represent subscriptions that no longer exist in the current save data.
+        const oldSaveDataForSubscriber = oldSaveData.get(key);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (oldSaveDataForSubscriber === undefined) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (SAVE_DATA_MANAGER_DEBUG) {
+            log(`Merging in stored data for feature: ${key}`);
+        }
+        // We do not want to blow away the child tables of the existing map, because save data could
+        // contain out-of-date fields. Instead, merge it one field at a time in a recursive way (and
+        // convert Lua tables back to TypeScriptToLua Maps, if necessary).
+        merge(oldSaveDataForSubscriber, value, key);
+    }, SAVE_DATA_MANAGER_DEBUG);
+    log(`The ${SAVE_DATA_MANAGER_FEATURE_NAME} loaded data from the "save#.dat" file.`);
+}
+function readSaveDatFile(mod) {
+    const renderFrameCount = Isaac.GetFrameCount();
+    const [ok, jsonStringOrErrMsg] = pcall(tryLoadModData, mod);
+    if (!ok) {
+        logError(`Failed to read from the "save#.dat" file on render frame ${renderFrameCount}: ${jsonStringOrErrMsg}`);
+        return DEFAULT_MOD_DATA;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (jsonStringOrErrMsg === undefined) {
+        return DEFAULT_MOD_DATA;
+    }
+    const jsonStringTrimmed = jsonStringOrErrMsg.trim();
+    if (jsonStringTrimmed === "") {
+        return DEFAULT_MOD_DATA;
+    }
+    return jsonStringTrimmed;
+}
+function tryLoadModData(mod) {
+    return mod.LoadData();
+}
+//# sourceMappingURL=data:application/json;base64,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