isaacscript-common 14.1.3 → 15.0.0

package/dist/src/classes/features/other/RoomHistory.lua

@@ -0,0 +1,98 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Decorate = ____lualib.__TS__Decorate
+local ____exports = {}
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
+local ____ModCallbackCustom = require("src.enums.ModCallbackCustom")
+local ModCallbackCustom = ____ModCallbackCustom.ModCallbackCustom
+local ____array = require("src.functions.array")
+local getLastElement = ____array.getLastElement
+local ____dimensions = require("src.functions.dimensions")
+local getDimension = ____dimensions.getDimension
+local ____roomData = require("src.functions.roomData")
+local getRoomGridIndex = ____roomData.getRoomGridIndex
+local getRoomListIndex = ____roomData.getRoomListIndex
+local getRoomName = ____roomData.getRoomName
+local getRoomStageID = ____roomData.getRoomStageID
+local getRoomSubType = ____roomData.getRoomSubType
+local getRoomVariant = ____roomData.getRoomVariant
+local getRoomVisitedCount = ____roomData.getRoomVisitedCount
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+____exports.RoomHistory = __TS__Class()
+local RoomHistory = ____exports.RoomHistory
+RoomHistory.name = "RoomHistory"
+__TS__ClassExtends(RoomHistory, Feature)
+function RoomHistory.prototype.____constructor(self)
+    Feature.prototype.____constructor(self)
+    self.v = {run = {roomHistory = {}}}
+    self.postNewRoomEarly = function()
+        local level = game:GetLevel()
+        local stage = level:GetStage()
+        local stageType = level:GetStageType()
+        local room = game:GetRoom()
+        local roomType = room:GetType()
+        local stageID = getRoomStageID(nil)
+        local dimension = getDimension(nil)
+        local roomVariant = getRoomVariant(nil)
+        local roomSubType = getRoomSubType(nil)
+        local roomName = getRoomName(nil)
+        local roomGridIndex = getRoomGridIndex(nil)
+        local roomListIndex = getRoomListIndex(nil)
+        local roomVisitedCount = getRoomVisitedCount(nil)
+        local roomDescription = {
+            stage = stage,
+            stageType = stageType,
+            stageID = stageID,
+            dimension = dimension,
+            roomType = roomType,
+            roomVariant = roomVariant,
+            roomSubType = roomSubType,
+            roomName = roomName,
+            roomGridIndex = roomGridIndex,
+            roomListIndex = roomListIndex,
+            roomVisitedCount = roomVisitedCount
+        }
+        local ____self_v_run_roomHistory_0 = self.v.run.roomHistory
+        ____self_v_run_roomHistory_0[#____self_v_run_roomHistory_0 + 1] = roomDescription
+    end
+    self.customCallbacksUsed = {{ModCallbackCustom.POST_NEW_ROOM_EARLY, {self.postNewRoomEarly}}}
+end
+function RoomHistory.prototype.getRoomHistory(self)
+    return self.v.run.roomHistory
+end
+function RoomHistory.prototype.getPreviousRoomDescription(self)
+    local previousRoomDescription = self.v.run.roomHistory[#self.v.run.roomHistory - 2 + 1]
+    if previousRoomDescription ~= nil then
+        return previousRoomDescription
+    end
+    local startingRoomDescription = self.v.run.roomHistory[1]
+    if startingRoomDescription ~= nil then
+        return startingRoomDescription
+    end
+    error("Failed to find a room description for any rooms thus far on this run.")
+end
+function RoomHistory.prototype.getLatestRoomDescription(self)
+    return getLastElement(nil, self.v.run.roomHistory)
+end
+function RoomHistory.prototype.isLeavingRoom(self)
+    local level = game:GetLevel()
+    local stage = level:GetStage()
+    local stageType = level:GetStageType()
+    local roomListIndex = getRoomListIndex(nil)
+    local roomVisitedCount = getRoomVisitedCount(nil)
+    local latestRoomDescription = self:getLatestRoomDescription()
+    if latestRoomDescription == nil then
+        return false
+    end
+    return stage ~= latestRoomDescription.stage or stageType ~= latestRoomDescription.stageType or roomListIndex ~= latestRoomDescription.roomListIndex or roomVisitedCount ~= latestRoomDescription.roomVisitedCount
+end
+__TS__Decorate({Exported}, RoomHistory.prototype, "getRoomHistory", true)
+__TS__Decorate({Exported}, RoomHistory.prototype, "getPreviousRoomDescription", true)
+__TS__Decorate({Exported}, RoomHistory.prototype, "getLatestRoomDescription", true)
+__TS__Decorate({Exported}, RoomHistory.prototype, "isLeavingRoom", true)
+return ____exports

package/dist/src/classes/features/other/RunInNFrames.d.ts

@@ -1,29 +1,16 @@
-/// <reference types="isaac-typescript-definitions" />
+import { PlayerType } from "isaac-typescript-definitions";
 import { Feature } from "../../private/Feature";
-/** Used for `runInNFrames` functions. */
-declare type QueuedFunctionTuple = [frameCountToFire: int, func: () => void];
-/**
- * Used for `setInterval` functions.
- *
- * The return value is whether or not to continue the function from firing.
- */
-declare type IntervalFunctionTuple = [
-    frameCountToFire: int,
-    func: () => boolean,
-    numIntervalFrames: int
-];
 export declare class RunInNFrames extends Feature {
-    v: {
-        run: {
-            queuedGameFunctionTuples: QueuedFunctionTuple[];
-            queuedRenderFunctionTuples: QueuedFunctionTuple[];
-            intervalGameFunctionTuples: IntervalFunctionTuple[];
-            intervalRenderFunctionTuples: IntervalFunctionTuple[];
-        };
-    };
-    constructor();
     private postUpdate;
     private postRender;
+    /**
+     * Helper function to restart on the next render frame. Useful because it is impossible to restart
+     * the game inside of the `POST_NEW_ROOM`, `POST_NEW_LEVEL`, or `POST_GAME_STARTED` callbacks when
+     * a run is first starting.
+     *
+     * You can optionally specify a `PlayerType` to restart the game as that character.
+     */
+    restartNextRenderFrame(character?: PlayerType): void;
     /**
      * Supply a function to run N game frames from now in the `POST_UPDATE` callback.
      *
@@ -119,5 +106,4 @@ export declare class RunInNFrames extends Feature {
      */
     setIntervalRenderFrames(func: () => boolean, renderFrames: int, runImmediately: boolean): void;
 }
-export {};
 //# sourceMappingURL=RunInNFrames.d.ts.map

package/dist/src/classes/features/other/RunInNFrames.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RunInNFrames.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunInNFrames.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,yCAAyC;AACzC,aAAK,mBAAmB,GAAG,CAAC,gBAAgB,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC;AAErE;;;;GAIG;AACH,aAAK,qBAAqB,GAAG;IAC3B,gBAAgB,EAAE,GAAG;IACrB,IAAI,EAAE,MAAM,OAAO;IACnB,iBAAiB,EAAE,GAAG;CACvB,CAAC;AAEF,qBAAa,YAAa,SAAQ,OAAO;IACvB,CAAC;;;;;;;MAQf;;IAYF,OAAO,CAAC,UAAU,CAWhB;IAGF,OAAO,CAAC,UAAU,CAWhB;IAMF;;;;;;;;;OASG;IACI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,GAAG,GAAG,IAAI;IAOhE;;;;;;;;;OASG;IACI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,YAAY,EAAE,GAAG,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAI/C;;;;;;;OAOG;IACI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAIjD;;;;;;;;;;;;;;;OAeG;IACI,qBAAqB,CAC1B,IAAI,EAAE,MAAM,OAAO,EACnB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,OAAO,GACtB,IAAI;IAWP;;;;;;;;;;;;;;;OAeG;IACI,uBAAuB,CAC5B,IAAI,EAAE,MAAM,OAAO,EACnB,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,OAAO,GACtB,IAAI;CAcR"}
+{"version":3,"file":"RunInNFrames.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunInNFrames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAKvE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAgBhD,qBAAa,YAAa,SAAQ,OAAO;IAuBvC,OAAO,CAAC,UAAU,CAWhB;IAGF,OAAO,CAAC,UAAU,CAWhB;IAEF;;;;;;OAMG;IAEI,sBAAsB,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,IAAI;IAM3D;;;;;;;;;OASG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,GAAG,GAAG,IAAI;IAOhE;;;;;;;;;OASG;IAEI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,YAAY,EAAE,GAAG,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAI/C;;;;;;;OAOG;IAEI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAIjD;;;;;;;;;;;;;;;OAeG;IAEI,qBAAqB,CAC1B,IAAI,EAAE,MAAM,OAAO,EACnB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,OAAO,GACtB,IAAI;IAWP;;;;;;;;;;;;;;;OAeG;IAEI,uBAAuB,CAC5B,IAAI,EAAE,MAAM,OAAO,EACnB,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,OAAO,GACtB,IAAI;CAcR"}

package/dist/src/classes/features/other/RunInNFrames.lua

@@ -1,6 +1,7 @@
 local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
 local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Decorate = ____lualib.__TS__Decorate
 local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
 local ____exports = {}
 local checkExecuteQueuedFunctions, checkExecuteIntervalFunctions
@@ -8,8 +9,12 @@ local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitio
 local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
 local ____cachedClasses = require("src.core.cachedClasses")
 local game = ____cachedClasses.game
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
 local ____array = require("src.functions.array")
 local arrayRemoveInPlace = ____array.arrayRemoveInPlace
+local ____run = require("src.functions.run")
+local restart = ____run.restart
 local ____Feature = require("src.classes.private.Feature")
 local Feature = ____Feature.Feature
 function checkExecuteQueuedFunctions(self, frameCount, functionTuples)
@@ -66,6 +71,11 @@ function RunInNFrames.prototype.____constructor(self)
     end
     self.callbacksUsed = {{ModCallback.POST_UPDATE, {self.postUpdate}}, {ModCallback.POST_RENDER, {self.postRender}}}
 end
+function RunInNFrames.prototype.restartNextRenderFrame(self, character)
+    self:runNextRenderFrame(function()
+        restart(nil, character)
+    end)
+end
 function RunInNFrames.prototype.runInNGameFrames(self, func, gameFrames)
     local gameFrameCount = game:GetFrameCount()
     local functionFireFrame = gameFrameCount + gameFrames
@@ -106,4 +116,11 @@ function RunInNFrames.prototype.setIntervalRenderFrames(self, func, renderFrames
         func(nil)
     end
 end
+__TS__Decorate({Exported}, RunInNFrames.prototype, "restartNextRenderFrame", true)
+__TS__Decorate({Exported}, RunInNFrames.prototype, "runInNGameFrames", true)
+__TS__Decorate({Exported}, RunInNFrames.prototype, "runInNRenderFrames", true)
+__TS__Decorate({Exported}, RunInNFrames.prototype, "runNextGameFrame", true)
+__TS__Decorate({Exported}, RunInNFrames.prototype, "runNextRenderFrame", true)
+__TS__Decorate({Exported}, RunInNFrames.prototype, "setIntervalGameFrames", true)
+__TS__Decorate({Exported}, RunInNFrames.prototype, "setIntervalRenderFrames", true)
 return ____exports

package/dist/src/classes/features/other/RunNextRoom.d.ts

@@ -0,0 +1,18 @@
+import { Feature } from "../../private/Feature";
+/**
+ * Using the "luamod" console command with a mod that has custom shaders can crash the game. A
+ * simple fix for this is automatically applied to any upgraded mods. This method was originally
+ * discovered by AgentCucco.
+ */
+export declare class RunNextRoom extends Feature {
+    private postNewRoomReordered;
+    /**
+     * 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.
+     */
+    runNextRoom(func: () => void): void;
+}
+//# sourceMappingURL=RunNextRoom.d.ts.map

package/dist/src/classes/features/other/RunNextRoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunNextRoom.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunNextRoom.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD;;;;GAIG;AACH,qBAAa,WAAY,SAAQ,OAAO;IAkBtC,OAAO,CAAC,oBAAoB,CAM1B;IAEF;;;;;;OAMG;IAEI,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;CAG3C"}

package/dist/src/classes/features/other/RunNextRoom.lua

@@ -0,0 +1,37 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Decorate = ____lualib.__TS__Decorate
+local ____exports = {}
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
+local ____ModCallbackCustom = require("src.enums.ModCallbackCustom")
+local ModCallbackCustom = ____ModCallbackCustom.ModCallbackCustom
+local ____array = require("src.functions.array")
+local emptyArray = ____array.emptyArray
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+--- Using the "luamod" console command with a mod that has custom shaders can crash the game. A
+-- simple fix for this is automatically applied to any upgraded mods. This method was originally
+-- discovered by AgentCucco.
+____exports.RunNextRoom = __TS__Class()
+local RunNextRoom = ____exports.RunNextRoom
+RunNextRoom.name = "RunNextRoom"
+__TS__ClassExtends(RunNextRoom, Feature)
+function RunNextRoom.prototype.____constructor(self)
+    Feature.prototype.____constructor(self)
+    self.v = {run = {queuedFunctions = {}}}
+    self.postNewRoomReordered = function()
+        for ____, func in ipairs(self.v.run.queuedFunctions) do
+            func(nil)
+        end
+        emptyArray(nil, self.v.run.queuedFunctions)
+    end
+    self.customCallbacksUsed = {{ModCallbackCustom.POST_NEW_ROOM_REORDERED, {self.postNewRoomReordered}}}
+end
+function RunNextRoom.prototype.runNextRoom(self, func)
+    local ____self_v_run_queuedFunctions_0 = self.v.run.queuedFunctions
+    ____self_v_run_queuedFunctions_0[#____self_v_run_queuedFunctions_0 + 1] = func
+end
+__TS__Decorate({Exported}, RunNextRoom.prototype, "runNextRoom", true)
+return ____exports

package/dist/src/classes/features/other/SaveDataManager.d.ts

@@ -0,0 +1,213 @@
+import { SaveDataKey } from "../../../enums/SaveDataKey";
+import { SaveData } from "../../../interfaces/SaveData";
+import { AnyClass } from "../../../types/AnyClass";
+import { Feature } from "../../private/Feature";
+export declare class SaveDataManager extends Feature {
+    /**
+     * We store a local reference to the mod object so that we can access the corresponding methods
+     * that read and write to the "save#.dat" file.
+     */
+    private mod;
+    /**
+     * The save data map is indexed by subscriber name. We use Lua tables instead of TypeScriptToLua
+     * Maps for the master map so that we can access the variables via the in-game console when
+     * debugging. (TSTL Maps don't expose the map keys as normal keys.)
+     */
+    private saveDataMap;
+    /**
+     * When mod feature data is initialized, we copy the initial values into a separate map so that we
+     * can restore them later on.
+     */
+    private saveDataDefaultsMap;
+    /**
+     * Each mod feature can optionally provide a function that can control whether or not the save
+     * data is written to disk.
+     */
+    private saveDataConditionalFuncMap;
+    /**
+     * We backup some save data keys on every new room for the purposes of restoring it when Glowing
+     * Hour Glass is used.
+     *
+     * Note that the save data is backed up in serialized form so that we can use the `merge` function
+     * to restore it.
+     */
+    private saveDataGlowingHourGlassMap;
+    /**
+     * End-users can register their classes with the save data manager for proper serialization when
+     * contained in nested maps, sets, and arrays.
+     */
+    private classConstructors;
+    private loadedDataOnThisRun;
+    private restoreGlowingHourGlassDataOnNextRoom;
+    private postUseItemGlowingHourGlass;
+    private postPlayerInit;
+    private preGameExit;
+    private postNewLevel;
+    private postNewRoomEarly;
+    /**
+     * 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 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.
+     *
+     * You can use many different variable types on your variable object, but not everything is
+     * supported. For the specific things that are supported, see the documentation for the `deepCopy`
+     * helper function.
+     *
+     * 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.)
+     *
+     * 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`.
+     *
+     * Note that when the player uses Glowing Hour Glass, the save data manager will automatically
+     * restore any variables on a "run" or "level" object with a backup that was created when the room
+     * was entered. Thus, you should not have to explicitly program support for Glowing Hour Glass
+     * into your mod features that use the save data manager. If this is undesired for your specific
+     * use-case, then add a key of `__ignoreGlowingHourGlass: true` to your "run" or "level" object.
+     *
+     * @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 Optional. A function to run to check if this save data should be written
+     *                        to disk. Default is `() => true`, meaning that this save data will
+     *                        always be written to disk. Use a conditional function for the situations
+     *                        when the local variables are for a feature that the end-user can
+     *                        disable. (If the feature is disabled, then there would be no point in
+     *                        writing any of the variables to the "save#.dat" file.) You can also
+     *                        specify `false` to this argument in order to completely disable saving
+     *                        data. (Specifying `false` will allow you to use non-serializable objects
+     *                        in your save data, such as `EntityPtr`.
+     */
+    saveDataManager<Persistent, Run, Level>(key: string, // This is the overload for the standard case with serializable data.
+    v: SaveData<Persistent, Run, Level>, conditionalFunc?: () => boolean): void;
+    saveDataManager(key: string, // This is the overload for the case when saving data is disabled.
+    v: SaveData, conditionalFunc: false): void;
+    /**
+     * Recursively traverses an object, collecting all of the class constructors that it encounters.
+     */
+    private storeClassConstructorsFromObject;
+    /**
+     * 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.
+     */
+    saveDataManagerLoad(): void;
+    /**
+     * 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.
+     */
+    saveDataManagerSave(): void;
+    /**
+     * Sets the global variable of "g" equal to all of the save data 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.run.foo)`
+     */
+    saveDataManagerSetGlobal(): void;
+    /**
+     * By default, the save data manager will not be able to serialize/deserialize classes that are
+     * nested inside of maps, sets, and arrays, because it does not have access to the corresponding
+     * class constructor. If you want to use nested classes in this way, then use this function to
+     * register the class constructor with the save data manager. Once registered, the save data
+     * manager will automatically run the constructor when deserializing (in addition to copying over
+     * the data fields).
+     *
+     * This function is variadic, which means you can pass as many classes as you want to register.
+     */
+    saveDataManagerRegisterClass(...tstlClasses: AnyClass[]): void;
+    /**
+     * Removes a previously registered key from the save data manager. This is the opposite of the
+     * "saveDataManager" method.
+     */
+    saveDataManagerRemove(key: string): void;
+    /**
+     * The save data manager will automatically reset variables at the appropriate times, like 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,
+     *   },
+     * };
+     *
+     * mod.saveDataManager("file1", v);
+     *
+     * // Then, later on, to explicit reset all of the "room" variables:
+     * mod.saveDataManagerReset("file1", "room");
+     * ```
+     */
+    saveDataManagerReset(key: string, childObjectKey: SaveDataKey): void;
+}
+//# sourceMappingURL=SaveDataManager.d.ts.map

package/dist/src/classes/features/other/SaveDataManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaveDataManager.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/SaveDataManager.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAMzD,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAsBhD,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;IACH,OAAO,CAAC,GAAG,CAAM;IAEjB;;;;OAIG;IACH,OAAO,CAAC,WAAW,CAAkC;IAErD;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAkC;IAE7D;;;OAGG;IACH,OAAO,CAAC,0BAA0B,CAAuC;IAEzE;;;;;;OAMG;IACH,OAAO,CAAC,2BAA2B,CAAkC;IAErE;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAkC;IAG3D,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,qCAAqC,CAAS;IAyBtD,OAAO,CAAC,2BAA2B,CAUjC;IAGF,OAAO,CAAC,cAAc,CA0BpB;IAGF,OAAO,CAAC,WAAW,CAUjB;IAGF,OAAO,CAAC,YAAY,CAYlB;IAGF,OAAO,CAAC,gBAAgB,CAuBtB;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiGG;IACI,eAAe,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAC3C,GAAG,EAAE,MAAM,EAAE,qEAAqE;IAClF,CAAC,EAAE,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,EACnC,eAAe,CAAC,EAAE,MAAM,OAAO,GAC9B,IAAI;IACA,eAAe,CACpB,GAAG,EAAE,MAAM,EAAE,kEAAkE;IAC/E,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,KAAK,GACrB,IAAI;IAkDP;;OAEG;IACH,OAAO,CAAC,gCAAgC;IAgBxC;;;;;;;OAOG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;OAIG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;;OAKG;IAEI,wBAAwB,IAAI,IAAI;IAIvC;;;;;;;;;OASG;IAEI,4BAA4B,CAAC,GAAG,WAAW,EAAE,QAAQ,EAAE,GAAG,IAAI;IAcrE;;;OAGG;IAEI,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAoB/C;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,GAAG,IAAI;CAqB5E"}

package/dist/src/classes/features/other/SaveDataManager.lua

@@ -0,0 +1,193 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__TypeOf = ____lualib.__TS__TypeOf
+local __TS__ObjectKeys = ____lualib.__TS__ObjectKeys
+local __TS__Decorate = ____lualib.__TS__Decorate
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
+local ____ModCallbackCustom = require("src.enums.ModCallbackCustom")
+local ModCallbackCustom = ____ModCallbackCustom.ModCallbackCustom
+local ____SaveDataKey = require("src.enums.SaveDataKey")
+local SaveDataKey = ____SaveDataKey.SaveDataKey
+local ____SerializationType = require("src.enums.SerializationType")
+local SerializationType = ____SerializationType.SerializationType
+local ____deepCopy = require("src.functions.deepCopy")
+local deepCopy = ____deepCopy.deepCopy
+local ____stage = require("src.functions.stage")
+local onFirstFloor = ____stage.onFirstFloor
+local ____tstlClass = require("src.functions.tstlClass")
+local getTSTLClassName = ____tstlClass.getTSTLClassName
+local ____types = require("src.functions.types")
+local isString = ____types.isString
+local isTable = ____types.isTable
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+local ____glowingHourGlass = require("src.classes.features.other.saveDataManager.glowingHourGlass")
+local makeGlowingHourGlassBackup = ____glowingHourGlass.makeGlowingHourGlassBackup
+local restoreGlowingHourGlassBackup = ____glowingHourGlass.restoreGlowingHourGlassBackup
+local ____loadFromDisk = require("src.classes.features.other.saveDataManager.loadFromDisk")
+local loadFromDisk = ____loadFromDisk.loadFromDisk
+local ____restoreDefaults = require("src.classes.features.other.saveDataManager.restoreDefaults")
+local restoreDefaultForFeatureKey = ____restoreDefaults.restoreDefaultForFeatureKey
+local restoreDefaultsForAllFeaturesAndKeys = ____restoreDefaults.restoreDefaultsForAllFeaturesAndKeys
+local restoreDefaultsForAllFeaturesKey = ____restoreDefaults.restoreDefaultsForAllFeaturesKey
+local ____saveToDisk = require("src.classes.features.other.saveDataManager.saveToDisk")
+local saveToDisk = ____saveToDisk.saveToDisk
+local NON_USER_DEFINED_CLASS_NAMES = __TS__New(Set, {"Map", "Set", "DefaultMap"})
+____exports.SaveDataManager = __TS__Class()
+local SaveDataManager = ____exports.SaveDataManager
+SaveDataManager.name = "SaveDataManager"
+__TS__ClassExtends(SaveDataManager, Feature)
+function SaveDataManager.prototype.____constructor(self, mod)
+    Feature.prototype.____constructor(self)
+    self.saveDataMap = {}
+    self.saveDataDefaultsMap = {}
+    self.saveDataConditionalFuncMap = {}
+    self.saveDataGlowingHourGlassMap = {}
+    self.classConstructors = {}
+    self.loadedDataOnThisRun = false
+    self.restoreGlowingHourGlassDataOnNextRoom = false
+    self.postUseItemGlowingHourGlass = function(____, _collectibleType, _rng, _player, _useFlags, _activeSlot, _customVarData)
+        self.restoreGlowingHourGlassDataOnNextRoom = true
+        return nil
+    end
+    self.postPlayerInit = function(____, _player)
+        if self.loadedDataOnThisRun then
+            return
+        end
+        self.loadedDataOnThisRun = true
+        self.restoreGlowingHourGlassDataOnNextRoom = false
+        loadFromDisk(nil, self.mod, self.saveDataMap, self.classConstructors)
+        local gameFrameCount = game:GetFrameCount()
+        local isContinued = gameFrameCount ~= 0
+        if not isContinued then
+            restoreDefaultsForAllFeaturesAndKeys(nil, self.saveDataMap, self.saveDataDefaultsMap)
+        end
+    end
+    self.preGameExit = function()
+        saveToDisk(nil, self.mod, self.saveDataMap, self.saveDataConditionalFuncMap)
+        restoreDefaultsForAllFeaturesAndKeys(nil, self.saveDataMap, self.saveDataDefaultsMap)
+        self.loadedDataOnThisRun = false
+    end
+    self.postNewLevel = function()
+        restoreDefaultsForAllFeaturesKey(nil, self.saveDataMap, self.saveDataDefaultsMap, SaveDataKey.LEVEL)
+        if not onFirstFloor(nil) then
+            saveToDisk(nil, self.mod, self.saveDataMap, self.saveDataConditionalFuncMap)
+        end
+    end
+    self.postNewRoomEarly = function()
+        restoreDefaultsForAllFeaturesKey(nil, self.saveDataMap, self.saveDataDefaultsMap, SaveDataKey.ROOM)
+        if self.restoreGlowingHourGlassDataOnNextRoom then
+            self.restoreGlowingHourGlassDataOnNextRoom = false
+            restoreGlowingHourGlassBackup(
+                nil,
+                self.saveDataMap,
+                self.saveDataConditionalFuncMap,
+                self.saveDataGlowingHourGlassMap,
+                self.classConstructors
+            )
+        else
+            makeGlowingHourGlassBackup(nil, self.saveDataMap, self.saveDataConditionalFuncMap, self.saveDataGlowingHourGlassMap)
+        end
+    end
+    self.callbacksUsed = {{ModCallback.POST_USE_ITEM, {self.postUseItemGlowingHourGlass, CollectibleType.GLOWING_HOUR_GLASS}}, {ModCallback.POST_PLAYER_INIT, {self.postPlayerInit}}, {ModCallback.PRE_GAME_EXIT, {self.preGameExit}}, {ModCallback.POST_NEW_LEVEL, {self.postNewLevel}}}
+    self.customCallbacksUsed = {{ModCallbackCustom.POST_NEW_ROOM_EARLY, {self.postNewRoomEarly}}}
+    self.mod = mod
+end
+function SaveDataManager.prototype.saveDataManager(self, key, v, conditionalFunc)
+    if not isString(nil, key) then
+        error("The save data manager requires that keys are strings. You tried to use a key of type: " .. __TS__TypeOf(key))
+    end
+    if self.saveDataMap[key] ~= nil then
+        error("The save data manager is already managing save data for a key of: " .. key)
+    end
+    self:storeClassConstructorsFromObject(v)
+    self.saveDataMap[key] = v
+    if conditionalFunc == false then
+        conditionalFunc = function() return false end
+    end
+    local saveDataKeys = __TS__ObjectKeys(v)
+    if #saveDataKeys == 1 and saveDataKeys[1] == "room" then
+        conditionalFunc = function() return false end
+    end
+    local saveDataCopy = deepCopy(nil, v, SerializationType.NONE, key)
+    self.saveDataDefaultsMap[key] = saveDataCopy
+    if conditionalFunc ~= nil then
+        self.saveDataConditionalFuncMap[key] = conditionalFunc
+    end
+end
+function SaveDataManager.prototype.storeClassConstructorsFromObject(self, luaMap)
+    local tstlClassName = getTSTLClassName(nil, luaMap)
+    if tstlClassName ~= nil and not NON_USER_DEFINED_CLASS_NAMES:has(tstlClassName) then
+        self.classConstructors[tstlClassName] = luaMap
+    end
+    for _key, value in pairs(luaMap) do
+        if isTable(nil, value) then
+            self:storeClassConstructorsFromObject(value)
+        end
+    end
+end
+function SaveDataManager.prototype.saveDataManagerLoad(self)
+    loadFromDisk(nil, self.mod, self.saveDataMap, self.classConstructors)
+end
+function SaveDataManager.prototype.saveDataManagerSave(self)
+    saveToDisk(nil, self.mod, self.saveDataMap, self.saveDataConditionalFuncMap)
+end
+function SaveDataManager.prototype.saveDataManagerSetGlobal(self)
+    g = self.saveDataMap
+end
+function SaveDataManager.prototype.saveDataManagerRegisterClass(self, ...)
+    local tstlClasses = {...}
+    for ____, tstlClass in ipairs(tstlClasses) do
+        local name = tstlClass.name
+        if name == nil then
+            error("Failed to register a class with the save data manager due to not being able to derive the name of the class.")
+        end
+        self.classConstructors[name] = tstlClass
+    end
+end
+function SaveDataManager.prototype.saveDataManagerRemove(self, key)
+    if not isString(nil, key) then
+        error("The save data manager requires that keys are strings. You tried to use a key of type: " .. __TS__TypeOf(key))
+    end
+    if not (self.saveDataMap[key] ~= nil) then
+        error("The save data manager is not managing save data for a key of: " .. key)
+    end
+    self.saveDataMap[key] = nil
+    self.saveDataDefaultsMap[key] = nil
+    self.saveDataConditionalFuncMap[key] = nil
+    self.saveDataGlowingHourGlassMap[key] = nil
+end
+function SaveDataManager.prototype.saveDataManagerReset(self, key, childObjectKey)
+    if not isString(nil, key) then
+        error("The save data manager requires that keys are strings. You tried to use a key of type: " .. __TS__TypeOf(key))
+    end
+    local saveData = self.saveDataMap[key]
+    if saveData == nil then
+        error("The save data manager is not managing save data for a key of: " .. key)
+    end
+    restoreDefaultForFeatureKey(
+        nil,
+        self.saveDataDefaultsMap,
+        key,
+        saveData,
+        childObjectKey
+    )
+end
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManager", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerLoad", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerSave", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerSetGlobal", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerRegisterClass", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerRemove", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerReset", true)
+return ____exports