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

package/features/saveDataManager/main.js

@@ -0,0 +1,131 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../cachedClasses";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { SaveDataKey } from "../../enums/private/SaveDataKey";
+import { SerializationType } from "../../enums/SerializationType";
+import { deepCopy } from "../../functions/deepCopy";
+import { logError } from "../../functions/log";
+import { clearTable, iterateTableInOrder } from "../../functions/table";
+import { loadFromDisk } from "./load";
+import { saveDataConditionalFuncMap, saveDataDefaultsMap, saveDataMap, } from "./maps";
+import { saveToDisk } from "./save";
+import { SAVE_DATA_MANAGER_DEBUG, SAVE_DATA_MANAGER_FEATURE_NAME, } from "./saveDataManagerConstants";
+const RESETTABLE_SAVE_DATA_KEYS = new Set([
+    SaveDataKey.RUN,
+    SaveDataKey.LEVEL,
+    SaveDataKey.ROOM,
+]);
+let mod = null;
+let loadedDataOnThisRun = false;
+/** @internal */
+export function saveDataManagerInit(incomingMod) {
+    mod = incomingMod;
+    mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit); // 9
+    mod.AddCallback(ModCallback.PRE_GAME_EXIT, preGameExit); // 17
+    mod.AddCallback(ModCallback.POST_NEW_LEVEL, postNewLevel); // 18
+    mod.AddCallbackCustom(ModCallbackCustom.POST_NEW_ROOM_EARLY, postNewRoomEarly); // 19
+}
+// ModCallback.POST_PLAYER_INIT (9)
+function postPlayerInit() {
+    if (mod === null) {
+        error(`The mod for the ${SAVE_DATA_MANAGER_FEATURE_NAME} was not initialized.`);
+    }
+    if (loadedDataOnThisRun) {
+        return;
+    }
+    loadedDataOnThisRun = true;
+    // We want to unconditionally load save data on every new run since there might be persistent data
+    // that is not tied to an individual run.
+    loadFromDisk(mod, saveDataMap);
+    const gameFrameCount = game.GetFrameCount();
+    const isContinued = gameFrameCount !== 0;
+    if (!isContinued) {
+        restoreDefaultsAll();
+    }
+    // On continued runs, the PostNewLevel callback will not fire, so we do not have to worry about
+    // saved data based on level getting overwritten.
+}
+// ModCallback.PRE_GAME_EXIT (17)
+function preGameExit() {
+    if (mod === null) {
+        error(`The mod for the ${SAVE_DATA_MANAGER_FEATURE_NAME} was not initialized.`);
+    }
+    // We unconditionally save variables to disk (because regardless of a save & quit or a death,
+    // persistent variables should be recorded).
+    saveToDisk(mod, saveDataMap, saveDataConditionalFuncMap);
+    restoreDefaultsAll();
+    loadedDataOnThisRun = false;
+}
+// ModCallback.POST_NEW_LEVEL (18)
+function postNewLevel() {
+    restoreDefaults(SaveDataKey.LEVEL);
+}
+// ModCallbackCustom.POST_NEW_ROOM_EARLY
+function postNewRoomEarly() {
+    restoreDefaults(SaveDataKey.ROOM);
+}
+function restoreDefaultsAll() {
+    restoreDefaults(SaveDataKey.RUN);
+    restoreDefaults(SaveDataKey.LEVEL);
+    restoreDefaults(SaveDataKey.ROOM);
+}
+function restoreDefaults(saveDataKey) {
+    iterateTableInOrder(saveDataMap, (subscriberName, saveData) => {
+        restoreDefaultSaveData(subscriberName, saveData, saveDataKey);
+    }, SAVE_DATA_MANAGER_DEBUG);
+}
+export function restoreDefaultSaveData(subscriberName, saveData, saveDataKey) {
+    // Only allow certain save data keys to be reset.
+    if (!RESETTABLE_SAVE_DATA_KEYS.has(saveDataKey)) {
+        error(`Unknown save data key name of: ${saveDataKey}`);
+    }
+    const childTable = saveData[saveDataKey];
+    if (childTable === undefined) {
+        // This feature does not happen to store any variables on this particular child table.
+        return;
+    }
+    // Get the default values for this feature.
+    const saveDataDefaults = saveDataDefaultsMap.get(subscriberName);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (saveDataDefaults === undefined) {
+        logError(`Failed to find the default copy of the save data for subscriber: ${subscriberName}`);
+        return;
+    }
+    // Get the default values for the specific sub-table of this feature.
+    const childTableDefaults = saveDataDefaults[saveDataKey];
+    if (childTableDefaults === undefined) {
+        logError(`Failed to find the default copy of the child table "${saveDataKey}" for subscriber "${subscriberName}". This error usually means that your save data is out of date. You can try purging all of your save data by deleting the following directory: C:\\Program Files (x86)\\Steam\\steamapps\\common\\The Binding of Isaac Rebirth\\data`);
+        return;
+    }
+    // Make a new copy of the default child table.
+    const childTableDefaultsCopy = deepCopy(childTableDefaults, SerializationType.NONE, `${subscriberName} --> ${saveDataKey}`);
+    // We do not want to blow away the existing child table because we don't want to break any
+    // existing references. Instead, empty the table and copy all of the elements from the copy of the
+    // defaults table.
+    clearAndCopyAllElements(childTable, childTableDefaultsCopy);
+}
+/**
+ * Will empty the old table of all elements, and then shallow copy all the elements from the new
+ * table to the old table.
+ */
+function clearAndCopyAllElements(oldTable, newTable) {
+    clearTable(oldTable);
+    for (const [key, value] of pairs(newTable)) {
+        oldTable.set(key, value);
+    }
+}
+/** @internal */
+export function forceSaveDataManagerSave() {
+    if (mod === null) {
+        return;
+    }
+    saveToDisk(mod, saveDataMap, saveDataConditionalFuncMap);
+}
+/** @internal */
+export function forceSaveDataManagerLoad() {
+    if (mod === null) {
+        return;
+    }
+    loadFromDisk(mod, saveDataMap);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/saveDataManager/maps.js

@@ -0,0 +1,9 @@
+/**
+ * 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.)
+ */
+export const saveDataMap = new LuaTable();
+export const saveDataDefaultsMap = new LuaTable();
+export const saveDataConditionalFuncMap = new Map();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZmVhdHVyZXMvc2F2ZURhdGFNYW5hZ2VyL21hcHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxJQUFJLFFBQVEsRUFBb0IsQ0FBQztBQUU1RCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLFFBQVEsRUFBb0IsQ0FBQztBQUNwRSxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxJQUFJLEdBQUcsRUFBeUIsQ0FBQyJ9

package/features/saveDataManager/merge.js

@@ -0,0 +1,139 @@
+import { SerializationBrand } from "../../enums/private/SerializationBrand";
+import { SerializationType } from "../../enums/SerializationType";
+import { isArray } from "../../functions/array";
+import { deepCopy } from "../../functions/deepCopy";
+import { log } from "../../functions/log";
+import { deserializeIsaacAPIClass, isSerializedIsaacAPIClass, } from "../../functions/serialization";
+import { clearTable, iterateTableInOrder } from "../../functions/table";
+import { isTSTLMap, isTSTLSet } from "../../functions/tstlClass";
+import { isTable } from "../../functions/types";
+import { getTraversalDescription } from "../../functions/utils";
+import { SAVE_DATA_MANAGER_DEBUG } from "./saveDataManagerConstants";
+import { isSerializationBrand } from "./serializationBrand";
+/**
+ * `merge` takes the values from a new table and recursively merges them into an old object (while
+ * performing appropriate deserialization).
+ *
+ * It supports the following object types:
+ *
+ * - `LuaTable` / basic TSTL objects
+ * - TSTL `Map`
+ * - TSTL `Set`
+ * - TSTL classes
+ * - `DefaultMap`
+ * - Isaac `Color` objects
+ * - Isaac `KColor` objects
+ * - Isaac `RNG` objects
+ * - Isaac `Vector` objects
+ *
+ * Since it is common for a variable to have a type of `something | null`, we must iterate over the
+ * new object and copy over all of the values. (A value of null transpiles to nil, which means the
+ * table key does not exist.) The consequence of this is that it can copy over old variables that
+ * are no longer used in the code, or copy over old variables of a different type, which can cause
+ * run-time errors. In such cases, users will have to manually delete their save data.
+ */
+export function merge(oldObject, newTable, traversalDescription) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (SAVE_DATA_MANAGER_DEBUG) {
+        log(`merge is traversing: ${traversalDescription}`);
+    }
+    if (!isTable(oldObject)) {
+        error("The first argument given to the merge function is not a table.");
+    }
+    if (!isTable(newTable)) {
+        error("The second argument given to the merge function is not a table.");
+    }
+    // First, handle the special case of an array with a shallow copy.
+    if (isArray(oldObject) && isArray(newTable)) {
+        mergeArray(oldObject, newTable);
+        return;
+    }
+    // Depending on whether we are working on a Lua table or a TypeScriptToLua object, we need to
+    // iterate in a specific way.
+    if (isTSTLMap(oldObject) || isTSTLSet(oldObject)) {
+        mergeTSTLObject(oldObject, newTable, traversalDescription);
+    }
+    else {
+        mergeTable(oldObject, newTable, traversalDescription);
+    }
+}
+function mergeArray(oldArray, newArray) {
+    // Assume that we should blow away all array values with whatever is present in the incoming
+    // array.
+    clearTable(oldArray);
+    iterateTableInOrder(newArray, (key, value) => {
+        oldArray.set(key, value);
+    }, SAVE_DATA_MANAGER_DEBUG);
+}
+function mergeTSTLObject(oldObject, newTable, traversalDescription) {
+    // We blow away the old object and recursively copy over all of the incoming values.
+    oldObject.clear();
+    // During serialization, we brand some Lua tables with a special identifier to signify that it has
+    // keys that should be deserialized to numbers.
+    const convertStringKeysToNumbers = newTable.has(SerializationBrand.OBJECT_WITH_NUMBER_KEYS);
+    iterateTableInOrder(newTable, (key, value) => {
+        if (isSerializationBrand(key)) {
+            return;
+        }
+        let keyToUse = key;
+        if (convertStringKeysToNumbers) {
+            const numberKey = tonumber(key);
+            if (numberKey === undefined) {
+                return;
+            }
+            keyToUse = numberKey;
+        }
+        if (isTSTLMap(oldObject)) {
+            let valueCopy;
+            if (isTable(value)) {
+                valueCopy = deepCopy(value, SerializationType.DESERIALIZE, traversalDescription);
+            }
+            else {
+                valueCopy = value;
+            }
+            oldObject.set(keyToUse, valueCopy);
+        }
+        else if (isTSTLSet(oldObject)) {
+            oldObject.add(keyToUse);
+        }
+    }, SAVE_DATA_MANAGER_DEBUG);
+}
+function mergeTable(oldTable, newTable, traversalDescription) {
+    iterateTableInOrder(newTable, (key, value) => {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (SAVE_DATA_MANAGER_DEBUG) {
+            const valueToPrint = value === "" ? "(empty string)" : `${value}`;
+            log(`merge is merging: ${traversalDescription} --> ${valueToPrint}`);
+        }
+        if (isSerializationBrand(key)) {
+            return;
+        }
+        // Handle the special case of serialized Isaac API classes.
+        if (isSerializedIsaacAPIClass(value)) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (SAVE_DATA_MANAGER_DEBUG) {
+                log("merge found a serialized Isaac API class.");
+            }
+            const deserializedObject = deserializeIsaacAPIClass(value);
+            oldTable.set(key, deserializedObject);
+            return;
+        }
+        if (isTable(value)) {
+            let oldValue = oldTable.get(key);
+            if (!isTable(oldValue)) {
+                // The child table does not exist on the old table. However, we still need to copy over
+                // the new table, because we need to handle data types like "Foo | null". Thus, set up a
+                // blank sub-table on the old table, and continue to recursively merge..
+                oldValue = new LuaTable();
+                oldTable.set(key, oldValue);
+            }
+            traversalDescription = getTraversalDescription(key, traversalDescription);
+            merge(oldValue, value, traversalDescription);
+        }
+        else {
+            // Base case: copy the value
+            oldTable.set(key, value);
+        }
+    }, SAVE_DATA_MANAGER_DEBUG);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2ZlYXR1cmVzL3NhdmVEYXRhTWFuYWdlci9tZXJnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUM1RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDaEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMxQyxPQUFPLEVBQ0wsd0JBQXdCLEVBQ3hCLHlCQUF5QixHQUMxQixNQUFNLCtCQUErQixDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RSxPQUFPLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNyRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUU1RDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBQ0gsTUFBTSxVQUFVLEtBQUssQ0FDbkIsU0FHa0IsRUFDbEIsUUFBc0MsRUFDdEMsb0JBQTRCO0lBRTVCLHVFQUF1RTtJQUN2RSxJQUFJLHVCQUF1QixFQUFFO1FBQzNCLEdBQUcsQ0FBQyx3QkFBd0Isb0JBQW9CLEVBQUUsQ0FBQyxDQUFDO0tBQ3JEO0lBRUQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRTtRQUN2QixLQUFLLENBQUMsZ0VBQWdFLENBQUMsQ0FBQztLQUN6RTtJQUVELElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEVBQUU7UUFDdEIsS0FBSyxDQUFDLGlFQUFpRSxDQUFDLENBQUM7S0FDMUU7SUFFRCxrRUFBa0U7SUFDbEUsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFO1FBQzNDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDaEMsT0FBTztLQUNSO0lBRUQsNkZBQTZGO0lBQzdGLDZCQUE2QjtJQUM3QixJQUFJLFNBQVMsQ0FBQyxTQUFTLENBQUMsSUFBSSxTQUFTLENBQUMsU0FBUyxDQUFDLEVBQUU7UUFDaEQsZUFBZSxDQUFDLFNBQVMsRUFBRSxRQUFRLEVBQUUsb0JBQW9CLENBQUMsQ0FBQztLQUM1RDtTQUFNO1FBQ0wsVUFBVSxDQUFDLFNBQVMsRUFBRSxRQUFRLEVBQUUsb0JBQW9CLENBQUMsQ0FBQztLQUN2RDtBQUNILENBQUM7QUFFRCxTQUFTLFVBQVUsQ0FDakIsUUFBc0MsRUFDdEMsUUFBc0M7SUFFdEMsNEZBQTRGO0lBQzVGLFNBQVM7SUFDVCxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDckIsbUJBQW1CLENBQ2pCLFFBQVEsRUFDUixDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRTtRQUNiLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQzNCLENBQUMsRUFDRCx1QkFBdUIsQ0FDeEIsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLGVBQWUsQ0FDdEIsU0FBbUQsRUFDbkQsUUFBc0MsRUFDdEMsb0JBQTRCO0lBRTVCLG9GQUFvRjtJQUNwRixTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7SUFFbEIsa0dBQWtHO0lBQ2xHLCtDQUErQztJQUMvQyxNQUFNLDBCQUEwQixHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQzdDLGtCQUFrQixDQUFDLHVCQUF1QixDQUMzQyxDQUFDO0lBRUYsbUJBQW1CLENBQ2pCLFFBQVEsRUFDUixDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRTtRQUNiLElBQUksb0JBQW9CLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDN0IsT0FBTztTQUNSO1FBRUQsSUFBSSxRQUFRLEdBQUcsR0FBRyxDQUFDO1FBQ25CLElBQUksMEJBQTBCLEVBQUU7WUFDOUIsTUFBTSxTQUFTLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ2hDLElBQUksU0FBUyxLQUFLLFNBQVMsRUFBRTtnQkFDM0IsT0FBTzthQUNSO1lBQ0QsUUFBUSxHQUFHLFNBQVMsQ0FBQztTQUN0QjtRQUVELElBQUksU0FBUyxDQUFDLFNBQVMsQ0FBQyxFQUFFO1lBQ3hCLElBQUksU0FBa0IsQ0FBQztZQUN2QixJQUFJLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRTtnQkFDbEIsU0FBUyxHQUFHLFFBQVEsQ0FDbEIsS0FBSyxFQUNMLGlCQUFpQixDQUFDLFdBQVcsRUFDN0Isb0JBQW9CLENBQ3JCLENBQUM7YUFDSDtpQkFBTTtnQkFDTCxTQUFTLEdBQUcsS0FBSyxDQUFDO2FBQ25CO1lBRUQsU0FBUyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsU0FBUyxDQUFDLENBQUM7U0FDcEM7YUFBTSxJQUFJLFNBQVMsQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUMvQixTQUFTLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1NBQ3pCO0lBQ0gsQ0FBQyxFQUNELHVCQUF1QixDQUN4QixDQUFDO0FBQ0osQ0FBQztBQUVELFNBQVMsVUFBVSxDQUNqQixRQUFzQyxFQUN0QyxRQUFzQyxFQUN0QyxvQkFBNEI7SUFFNUIsbUJBQW1CLENBQ2pCLFFBQVEsRUFDUixDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRTtRQUNiLHVFQUF1RTtRQUN2RSxJQUFJLHVCQUF1QixFQUFFO1lBQzNCLE1BQU0sWUFBWSxHQUFHLEtBQUssS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxHQUFHLEtBQUssRUFBRSxDQUFDO1lBQ2xFLEdBQUcsQ0FBQyxxQkFBcUIsb0JBQW9CLFFBQVEsWUFBWSxFQUFFLENBQUMsQ0FBQztTQUN0RTtRQUVELElBQUksb0JBQW9CLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDN0IsT0FBTztTQUNSO1FBRUQsMkRBQTJEO1FBQzNELElBQUkseUJBQXlCLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDcEMsdUVBQXVFO1lBQ3ZFLElBQUksdUJBQXVCLEVBQUU7Z0JBQzNCLEdBQUcsQ0FBQywyQ0FBMkMsQ0FBQyxDQUFDO2FBQ2xEO1lBRUQsTUFBTSxrQkFBa0IsR0FBRyx3QkFBd0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUMzRCxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxrQkFBa0IsQ0FBQyxDQUFDO1lBQ3RDLE9BQU87U0FDUjtRQUVELElBQUksT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ2xCLElBQUksUUFBUSxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFpQyxDQUFDO1lBQ2pFLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEVBQUU7Z0JBQ3RCLHVGQUF1RjtnQkFDdkYsd0ZBQXdGO2dCQUN4Rix3RUFBd0U7Z0JBQ3hFLFFBQVEsR0FBRyxJQUFJLFFBQVEsRUFBRSxDQUFDO2dCQUMxQixRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxRQUFRLENBQUMsQ0FBQzthQUM3QjtZQUVELG9CQUFvQixHQUFHLHVCQUF1QixDQUM1QyxHQUFHLEVBQ0gsb0JBQW9CLENBQ3JCLENBQUM7WUFDRixLQUFLLENBQUMsUUFBUSxFQUFFLEtBQUssRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO1NBQzlDO2FBQU07WUFDTCw0QkFBNEI7WUFDNUIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7U0FDMUI7SUFDSCxDQUFDLEVBQ0QsdUJBQXVCLENBQ3hCLENBQUM7QUFDSixDQUFDIn0=

package/features/saveDataManager/save.js

@@ -0,0 +1,43 @@
+import { SerializationType } from "../../enums/SerializationType";
+import { deepCopy } from "../../functions/deepCopy";
+import { jsonEncode } from "../../functions/jsonHelpers";
+import { log } from "../../functions/log";
+import { iterateTableInOrder } from "../../functions/table";
+import { SAVE_DATA_MANAGER_DEBUG, SAVE_DATA_MANAGER_FEATURE_NAME, } from "./saveDataManagerConstants";
+export function saveToDisk(mod, saveDataMap, saveDataConditionalFuncMap) {
+    const allSaveData = getAllSaveDataToWriteToDisk(saveDataMap, saveDataConditionalFuncMap);
+    const jsonString = jsonEncode(allSaveData);
+    mod.SaveData(jsonString); // Write it to the "save#.dat" file
+    log(`The ${SAVE_DATA_MANAGER_FEATURE_NAME} wrote data to the "save#.dat" file.`);
+}
+function getAllSaveDataToWriteToDisk(saveDataMap, saveDataConditionalFuncMap) {
+    const allSaveData = new LuaTable();
+    iterateTableInOrder(saveDataMap, (subscriberName, saveData) => {
+        // Handle the feature of the save data manager where certain mod features can conditionally
+        // write their data to disk.
+        const conditionalFunc = saveDataConditionalFuncMap.get(subscriberName);
+        if (conditionalFunc !== undefined) {
+            const shouldSave = conditionalFunc();
+            if (!shouldSave) {
+                return;
+            }
+        }
+        // Strip out the room part of the save data.
+        const saveDataWithoutRoom = {
+            persistent: saveData.persistent,
+            run: saveData.run,
+            level: saveData.level,
+        };
+        // If there is no data, then we can move on to the next feature.
+        if (Object.keys(saveDataWithoutRoom).length === 0) {
+            return;
+        }
+        // If we encode TypeScriptToLua Maps into JSON, it will result in a lot of extraneous data
+        // that is unnecessary. Make a copy of the data and recursively convert all TypeScriptToLua
+        // Maps into Lua tables.
+        const saveDataCopy = deepCopy(saveDataWithoutRoom, SerializationType.SERIALIZE, subscriberName);
+        allSaveData.set(subscriberName, saveDataCopy);
+    }, SAVE_DATA_MANAGER_DEBUG);
+    return allSaveData;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/saveDataManager/saveDataManagerConstants.js

@@ -0,0 +1,4 @@
+/** Set this to true to enable more verbosity in the save data manger. */
+export const SAVE_DATA_MANAGER_DEBUG = false;
+export const SAVE_DATA_MANAGER_FEATURE_NAME = "save data manager";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZURhdGFNYW5hZ2VyQ29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mZWF0dXJlcy9zYXZlRGF0YU1hbmFnZXIvc2F2ZURhdGFNYW5hZ2VyQ29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHlFQUF5RTtBQUN6RSxNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyxLQUFLLENBQUM7QUFFN0MsTUFBTSxDQUFDLE1BQU0sOEJBQThCLEdBQUcsbUJBQW1CLENBQUMifQ==

package/features/saveDataManager/serializationBrand.js

@@ -0,0 +1,12 @@
+import { SerializationBrand } from "../../enums/private/SerializationBrand";
+import { getEnumValues } from "../../functions/enums";
+import { isString } from "../../functions/types";
+const SERIALIZATION_BRANDS = getEnumValues(SerializationBrand);
+const SERIALIZATION_BRAND_SET = new Set(SERIALIZATION_BRANDS);
+export function isSerializationBrand(key) {
+    if (!isString(key)) {
+        return false;
+    }
+    return SERIALIZATION_BRAND_SET.has(key);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXphdGlvbkJyYW5kLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mZWF0dXJlcy9zYXZlRGF0YU1hbmFnZXIvc2VyaWFsaXphdGlvbkJyYW5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFakQsTUFBTSxvQkFBb0IsR0FBRyxhQUFhLENBQUMsa0JBQWtCLENBQUMsQ0FBQztBQUMvRCxNQUFNLHVCQUF1QixHQUF3QixJQUFJLEdBQUcsQ0FDMUQsb0JBQW9CLENBQ3JCLENBQUM7QUFFRixNQUFNLFVBQVUsb0JBQW9CLENBQUMsR0FBWTtJQUMvQyxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQ2xCLE9BQU8sS0FBSyxDQUFDO0tBQ2Q7SUFFRCxPQUFPLHVCQUF1QixDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUMxQyxDQUFDIn0=

package/features/sirenHelpers.js

@@ -0,0 +1,90 @@
+import { EntityType, ModCallback, } from "isaac-typescript-definitions";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { getEntities } from "../functions/entity";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "sirenHelpers";
+const v = {
+    run: {
+        familiarBlacklist: [],
+    },
+};
+/** @internal */
+export function sirenHelpersInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.POST_NPC_INIT, postNPCInitSirenHelper, EntityType.SIREN_HELPER);
+}
+// ModCallback.POST_NPC_INIT (27)
+// EntityType.SIREN_HELPER (966)
+function postNPCInitSirenHelper(npc) {
+    checkReturnFamiliarToPlayer(npc);
+}
+function checkReturnFamiliarToPlayer(npc) {
+    if (npc.Target === undefined) {
+        return;
+    }
+    const familiar = npc.Target.ToFamiliar();
+    if (familiar === undefined) {
+        return;
+    }
+    if (blacklistEntryExists(familiar.Variant, familiar.SubType)) {
+        npc.Remove();
+        familiar.AddToFollowers();
+    }
+}
+function blacklistEntryExists(incomingFamiliarVariant, incomingFamiliarSubType) {
+    for (const [familiarVariant, familiarSubType] of v.run.familiarBlacklist) {
+        if (incomingFamiliarVariant === familiarVariant &&
+            familiarSubType === incomingFamiliarSubType) {
+            // There is an entry that matches the variant and sub-type exactly.
+            return true;
+        }
+        if (incomingFamiliarVariant === familiarVariant &&
+            familiarSubType === undefined) {
+            // There is an entry that matches all sub-types for this variant.
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Blacklists a familiar from being stolen by The Siren boss. This should be called once at the
+ * beginning of every run.
+ *
+ * @param familiarVariant The familiar variant to blacklist.
+ * @param familiarSubType The sub-type to blacklist. Optional. The default is to blacklist all
+ *                        sub-types of the given variant.
+ */
+export function setFamiliarNoSirenSteal(familiarVariant, familiarSubType) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    if (blacklistEntryExists(familiarVariant, familiarSubType)) {
+        return;
+    }
+    v.run.familiarBlacklist.push([familiarVariant, familiarSubType]);
+}
+/**
+ * Helper function to check if the Siren boss has stolen a familiar. Some familiars may need to
+ * behave differently when under The Siren's control (e.g. if they auto-target enemies).
+ *
+ * @param familiar The familiar to be checked.
+ * @returns Returns whether the familiar has been stolen by The Siren.
+ */
+export function hasSirenStolenFamiliar(familiar) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    return getSirenHelper(familiar) !== undefined;
+}
+/**
+ * When The Siren boss "steals" your familiars, a hidden "Siren Helper" entity is spawned to control
+ * each familiar stolen. (Checking for this entity seems to be the only way to detect when the Siren
+ * steals a familiar.)
+ *
+ * @param familiar The familiar to be checked.
+ * @returns Returns the hidden "Siren Helper" entity corresponding to the given familiar, if it
+ *          exists. Returns undefined otherwise.
+ */
+function getSirenHelper(familiar) {
+    const familiarPtrHash = GetPtrHash(familiar);
+    const sirenHelpers = getEntities(EntityType.SIREN_HELPER);
+    return sirenHelpers.find((sirenHelper) => sirenHelper.Target !== undefined &&
+        GetPtrHash(sirenHelper.Target) === familiarPtrHash);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/features/stageHistory.js

@@ -0,0 +1,43 @@
+import { game } from "../cachedClasses";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "stageHistory";
+const v = {
+    run: {
+        stageHistory: [],
+    },
+};
+/** @internal */
+export function stageHistoryInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallbackCustom(ModCallbackCustom.POST_NEW_LEVEL_REORDERED, postNewLevelReordered);
+}
+// ModCallbackCustom.POST_NEW_LEVEL_REORDERED
+function postNewLevelReordered() {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+    v.run.stageHistory.push([stage, stageType]);
+}
+/** Helper function to get all of the stages that a player has visited thus far on this run. */
+export function getStageHistory() {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    return v.run.stageHistory;
+}
+/**
+ * Helper function to check if a player has previous visited a particular stage (or stage + stage
+ * type combination) on this run.
+ *
+ * @param stage The stage to check for.
+ * @param stageType Optional. If provided, will check for a specific stage and stage type
+ *                  combination.
+ */
+export function hasVisitedStage(stage, stageType) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    if (stageType === undefined) {
+        return v.run.stageHistory.some(([previousStage]) => previousStage === stage);
+    }
+    return v.run.stageHistory.some(([previousStage, previousStageType]) => previousStage === stage && previousStageType === stageType);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhZ2VIaXN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mZWF0dXJlcy9zdGFnZUhpc3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXhDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQy9ELE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUU1RCxNQUFNLFlBQVksR0FBRyxjQUFjLENBQUM7QUFFcEMsTUFBTSxDQUFDLEdBQUc7SUFDUixHQUFHLEVBQUU7UUFDSCxZQUFZLEVBQUUsRUFBc0Q7S0FDckU7Q0FDRixDQUFDO0FBRUYsZ0JBQWdCO0FBQ2hCLE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxHQUFnQjtJQUMvQyxlQUFlLENBQUMsWUFBWSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBRWpDLEdBQUcsQ0FBQyxpQkFBaUIsQ0FDbkIsaUJBQWlCLENBQUMsd0JBQXdCLEVBQzFDLHFCQUFxQixDQUN0QixDQUFDO0FBQ0osQ0FBQztBQUVELDZDQUE2QztBQUM3QyxTQUFTLHFCQUFxQjtJQUM1QixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDOUIsTUFBTSxLQUFLLEdBQUcsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQy9CLE1BQU0sU0FBUyxHQUFHLEtBQUssQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUV2QyxDQUFDLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUMsQ0FBQztBQUM5QyxDQUFDO0FBRUQsK0ZBQStGO0FBQy9GLE1BQU0sVUFBVSxlQUFlO0lBRzdCLDZCQUE2QixDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzVDLE9BQU8sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUM7QUFDNUIsQ0FBQztBQUVEOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUM3QixLQUFpQixFQUNqQixTQUFxQjtJQUVyQiw2QkFBNkIsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUU1QyxJQUFJLFNBQVMsS0FBSyxTQUFTLEVBQUU7UUFDM0IsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQzVCLENBQUMsQ0FBQyxhQUFhLENBQUMsRUFBRSxFQUFFLENBQUMsYUFBYSxLQUFLLEtBQUssQ0FDN0MsQ0FBQztLQUNIO0lBRUQsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQzVCLENBQUMsQ0FBQyxhQUFhLEVBQUUsaUJBQWlCLENBQUMsRUFBRSxFQUFFLENBQ3JDLGFBQWEsS0FBSyxLQUFLLElBQUksaUJBQWlCLEtBQUssU0FBUyxDQUM3RCxDQUFDO0FBQ0osQ0FBQyJ9

package/features/taintedLazarusPlayers.js

@@ -0,0 +1,92 @@
+// This feature provides a way for end-users to get the `EntityPlayer` object for the other Tainted
+// Lazarus.
+import { ModCallback, PlayerType } from "isaac-typescript-definitions";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "taintedLazarusPlayers";
+const v = {
+    run: {
+        queuedTaintedLazarus: [],
+        queuedDeadTaintedLazarus: [],
+        /**
+         * The PostPlayerInit callback fires for Dead Tainted Lazarus at the beginning of the run.
+         * However, the player index for the Dead Tainted Lazarus player object at that time does not
+         * actually correspond to the player index for the real player once Flip has been used. Thus, we
+         * revert to using PtrHash as an index for our map, which is consistent between the Dead Tainted
+         * Lazarus object in the PostPlayerInit callback and the "real" Dead Tainted Lazarus.
+         */
+        subPlayerMap: new Map(),
+    },
+};
+/** @internal */
+export function taintedLazarusPlayersInit(mod) {
+    saveDataManager(FEATURE_NAME, v, () => false);
+    mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit);
+}
+// ModCallback.POST_PLAYER_INIT (9)
+function postPlayerInit(player) {
+    const entityPtr = EntityPtr(player);
+    const character = player.GetPlayerType();
+    if (character === PlayerType.LAZARUS_B) {
+        v.run.queuedTaintedLazarus.push(entityPtr);
+    }
+    else if (character === PlayerType.LAZARUS_2_B) {
+        v.run.queuedDeadTaintedLazarus.push(entityPtr);
+    }
+    else {
+        return;
+    }
+    checkDequeue();
+}
+/**
+ * When starting a run, the PostPlayerInit callback will fire first for Dead Tainted Lazarus, then
+ * for Tainted Lazarus. When continuing a run, the PostPlayerInit callback will fire first for the
+ * character that is currently active. Thus, since the order of the characters is not certain, we
+ * insert each of their pointers into a queue, and then only populate the map when we have one
+ * Tainted Lazarus and one Dead Tainted Lazarus.
+ */
+function checkDequeue() {
+    if (v.run.queuedTaintedLazarus.length === 0 ||
+        v.run.queuedDeadTaintedLazarus.length === 0) {
+        return;
+    }
+    const taintedLazarusPtr = v.run.queuedTaintedLazarus.shift();
+    const deadTaintedLazarusPtr = v.run.queuedDeadTaintedLazarus.shift();
+    if (taintedLazarusPtr === undefined || deadTaintedLazarusPtr === undefined) {
+        return;
+    }
+    const taintedLazarus = taintedLazarusPtr.Ref;
+    const deadTaintedLazarus = deadTaintedLazarusPtr.Ref;
+    if (taintedLazarus === undefined || deadTaintedLazarus === undefined) {
+        return;
+    }
+    const taintedLazarusPtrHash = GetPtrHash(taintedLazarus);
+    const deadTaintedLazarusPtrHash = GetPtrHash(deadTaintedLazarus);
+    v.run.subPlayerMap.set(taintedLazarusPtrHash, deadTaintedLazarusPtr);
+    v.run.subPlayerMap.set(deadTaintedLazarusPtrHash, taintedLazarusPtr);
+}
+/**
+ * Helper function to get the other version of Tainted Lazarus.
+ *
+ * - On Tainted Lazarus, returns the player object for Dead Tainted Lazarus.
+ * - On Dead Tainted Lazarus, returns the player object for Tainted Lazarus.
+ * - Returns undefined if player object retrieval failed for any reason.
+ *
+ * If you call the `EntityPlayer.Exists` method on the returned object, it will return false.
+ * However, you can still call the other methods like you normally would (e.g.
+ * `EntityPlayer.AddCollectible`).
+ */
+export function getTaintedLazarusSubPlayer(player) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const ptrHash = GetPtrHash(player);
+    const entityPtr = v.run.subPlayerMap.get(ptrHash);
+    if (entityPtr === undefined) {
+        return undefined;
+    }
+    const entity = entityPtr.Ref;
+    if (entity === undefined) {
+        return undefined;
+    }
+    return entity.ToPlayer();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/featuresInitialized.js

@@ -0,0 +1,16 @@
+let featuresInitialized = false;
+/** @internal */
+export function areFeaturesInitialized() {
+    return featuresInitialized;
+}
+/** @internal */
+export function errorIfFeaturesNotInitialized(featureName) {
+    if (!areFeaturesInitialized()) {
+        error(`The "${featureName}" feature is not initialized. You must first upgrade your mod object by calling the "upgradeMod" function.`);
+    }
+}
+/** @internal */
+export function setFeaturesInitialized() {
+    featuresInitialized = true;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVhdHVyZXNJbml0aWFsaXplZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZmVhdHVyZXNJbml0aWFsaXplZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLG1CQUFtQixHQUFHLEtBQUssQ0FBQztBQUVoQyxnQkFBZ0I7QUFDaEIsTUFBTSxVQUFVLHNCQUFzQjtJQUNwQyxPQUFPLG1CQUFtQixDQUFDO0FBQzdCLENBQUM7QUFFRCxnQkFBZ0I7QUFDaEIsTUFBTSxVQUFVLDZCQUE2QixDQUFDLFdBQW1CO0lBQy9ELElBQUksQ0FBQyxzQkFBc0IsRUFBRSxFQUFFO1FBQzdCLEtBQUssQ0FDSCxRQUFRLFdBQVcsNEdBQTRHLENBQ2hJLENBQUM7S0FDSDtBQUNILENBQUM7QUFFRCxnQkFBZ0I7QUFDaEIsTUFBTSxVQUFVLHNCQUFzQjtJQUNwQyxtQkFBbUIsR0FBRyxJQUFJLENBQUM7QUFDN0IsQ0FBQyJ9