isaacscript-common 84.0.1 → 84.1.1

package/dist/functions/math.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tanh = exports.splitNumber = exports.sign = exports.round = exports.lerpAngleDegrees = exports.lerp = exports.isOdd = exports.isEven = exports.isCircleIntersectingRectangle = exports.inRectangle = exports.getCircleDiscretizedPoints = exports.getAngleDifference = exports.clamp = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const direction_1 = require("./direction");
+/**
+ * Helper function to normalize a number, ensuring that it is within a certain range.
+ *
+ * - If `num` is less than `min`, then it will be clamped to `min`.
+ * - If `num` is greater than `max`, then it will be clamped to `max`.
+ */
+function clamp(num, min, max) {
+    return Math.max(min, Math.min(num, max));
+}
+exports.clamp = clamp;
+function getAngleDifference(angle1, angle2) {
+    const subtractedAngle = angle1 - angle2;
+    return ((subtractedAngle + 180) % 360) - 180;
+}
+exports.getAngleDifference = getAngleDifference;
+/**
+ * Helper function to get an array of equidistant points on the circumference around a circle.
+ * Useful for equally distributing things in a circle pattern.
+ *
+ * @param centerPos A position that represents the center of the center to get the points from.
+ * @param radius The radius of the circle.
+ * @param numPoints The number of points on the circumference of the circle to get.
+ * @param xMultiplier An optional multiplier to get the points around an oval. Default is 1.
+ * @param yMultiplier An optional multiplier to get the points around an oval. Default is 1.
+ * @param initialDirection By default, the first point on the circle will be on the top center, but
+ *                         this can be optionally changed by specifying this argument.
+ */
+function getCircleDiscretizedPoints(centerPos, radius, numPoints, xMultiplier = 1, yMultiplier = 1, initialDirection = isaac_typescript_definitions_1.Direction.UP) {
+    const vector = (0, direction_1.directionToVector)(initialDirection);
+    const initialPosition = vector.mul(radius);
+    const positions = [];
+    for (let i = 0; i < numPoints; i++) {
+        const rotatedPosition = initialPosition.Rotated((i * 360) / numPoints);
+        rotatedPosition.X *= xMultiplier;
+        rotatedPosition.Y *= yMultiplier;
+        const positionFromCenter = centerPos.add(rotatedPosition);
+        positions.push(positionFromCenter);
+    }
+    return positions;
+}
+exports.getCircleDiscretizedPoints = getCircleDiscretizedPoints;
+/**
+ * Helper function to check if a given position is within a given rectangle.
+ *
+ * This is an inclusive check, meaning that it will return true if the position is on the border of
+ * the rectangle.
+ */
+function inRectangle(position, topLeft, bottomRight) {
+    return (position.X >= topLeft.X &&
+        position.X <= bottomRight.X &&
+        position.Y >= topLeft.Y &&
+        position.Y <= bottomRight.Y);
+}
+exports.inRectangle = inRectangle;
+/**
+ * From: https://www.geeksforgeeks.org/check-if-any-point-overlaps-the-given-circle-and-rectangle/
+ */
+function isCircleIntersectingRectangle(circleCenter, circleRadius, rectangleTopLeft, rectangleBottomRight) {
+    const nearestX = Math.max(rectangleTopLeft.X, Math.min(circleCenter.X, rectangleBottomRight.X));
+    const nearestY = Math.max(rectangleTopLeft.Y, Math.min(circleCenter.Y, rectangleBottomRight.Y));
+    const nearestPointToCircleOnRectangle = Vector(nearestX, nearestY);
+    const distanceToCenterOfCircle = nearestPointToCircleOnRectangle.Distance(circleCenter);
+    return distanceToCenterOfCircle <= circleRadius;
+}
+exports.isCircleIntersectingRectangle = isCircleIntersectingRectangle;
+function isEven(num) {
+    // This is benchmarked to be faster than using the modulus operator by 3%.
+    return (num & 1) === 0;
+}
+exports.isEven = isEven;
+function isOdd(num) {
+    // This is benchmarked to be faster than using the modulus operator by 3%.
+    return (num & 1) === 1;
+}
+exports.isOdd = isOdd;
+function lerp(a, b, pos) {
+    return a + (b - a) * pos;
+}
+exports.lerp = lerp;
+function lerpAngleDegrees(aStart, aEnd, percent) {
+    return aStart + getAngleDifference(aStart, aEnd) * percent;
+}
+exports.lerpAngleDegrees = lerpAngleDegrees;
+/**
+ * If rounding fails, this function returns 0.
+ *
+ * From: http://lua-users.org/wiki/SimpleRound
+ *
+ * @param num The number to round.
+ * @param numDecimalPlaces Optional. Default is 0.
+ */
+function round(num, numDecimalPlaces = 0) {
+    const roundedNum = tonumber(string.format(`%.${numDecimalPlaces}f`, num));
+    return roundedNum ?? 0;
+}
+exports.round = round;
+/** @returns 1 if n is positive, -1 if n is negative, or 0 if n is 0. */
+function sign(n) {
+    if (n > 0) {
+        return 1;
+    }
+    if (n < 0) {
+        return -1;
+    }
+    return 0;
+}
+exports.sign = sign;
+/**
+ * Breaks a number into chunks of a given size. This is similar to the `String.split` method, but
+ * for a number instead of a string.
+ *
+ * For example, `splitNumber(90, 25)` would return an array with four elements:
+ *
+ * - [1, 25]
+ * - [26, 50]
+ * - [51, 75]
+ * - [76, 90]
+ *
+ * @param num The number to split into chunks. This must be a positive integer.
+ * @param size The size of each chunk. This must be a positive integer.
+ * @param startAtZero Whether to start at 0. Defaults to false. If true, the chunks will start at 0
+ *                    instead of 1.
+ */
+function splitNumber(num, size, startAtZero = false) {
+    if (num <= 0) {
+        error(`The number to split needs to be a positive number and is instead: ${num}`);
+    }
+    if (size <= 0) {
+        error(`The size to split needs to be a positive number and is instead: ${num}`);
+    }
+    const chunks = [];
+    let start = startAtZero ? 0 : 1;
+    while (start <= num) {
+        const end = Math.min(start + size - 1, num);
+        chunks.push([start, end]);
+        start += size;
+    }
+    return chunks;
+}
+exports.splitNumber = splitNumber;
+function tanh(x) {
+    return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
+}
+exports.tanh = tanh;

package/dist/functions/merge.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = void 0;
+const constants_1 = require("../classes/features/other/saveDataManager/constants");
+const SerializationBrand_1 = require("../enums/private/SerializationBrand");
+const SerializationType_1 = require("../enums/SerializationType");
+const serialization_1 = require("../serialization");
+const array_1 = require("./array");
+const deepCopy_1 = require("./deepCopy");
+const log_1 = require("./log");
+const serialization_2 = require("./serialization");
+const table_1 = require("./table");
+const tstlClass_1 = require("./tstlClass");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * `merge` takes the values from a new table and recursively merges them into an old object (while
+ * performing appropriate deserialization).
+ *
+ * This function is used to merge incoming data from the "save#.dat" file into a mod's variables.
+ * Merging is useful instead of blowing away a table entirely because mod code often relies on the
+ * local table/object references.
+ *
+ * This function always assumes that the new table is serialized data and will attempt to perform
+ * deserialization on the objects within. In other words, unlike the `deepCopy` function, the
+ * `merge` function will always operates in the mode of `SerializationType.DESERIALIZE`. For the
+ * types of objects that will be deserialized, see the documentation for the `deepCopy` function.
+ *
+ * This function does not iterate over the old object, like you would naively expect. This is
+ * because it is common for a variable to have a type of `something | null`. If this is the case,
+ * the key would not appear when iterating over the old object (because a value of null transpiles
+ * to nil, which means the table key does not exist). Thus, we must instead iterate over the new
+ * object and copy the values backwards. The consequence of this is that `merge` 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.
+ *
+ * @param oldObject The old object to merge the values into. This can be either a Lua table, a TSTL
+ *                  map, or a TSTL set.
+ * @param newTable The new table to merge the values from. This must be a Lua table that represents
+ *                 serialized data. In other words, it should be created with the `deepCopy`
+ *                 function using `SerializationType.SERIALIZE`.
+ * @param traversalDescription Used to track the current key that we are operating on for debugging
+ *                             purposes. Use a name that corresponds to the name of the merging
+ *                             table.
+ * @param classConstructors Optional. A Lua table that maps the name of a user-defined TSTL class to
+ *                          its corresponding constructor. If the `deepCopy` function finds any
+ *                          user-defined TSTL classes when recursively iterating through the given
+ *                          object, it will use this map to instantiate a new class. Default is an
+ *                          empty Lua table.
+ */
+function merge(oldObject, newTable, traversalDescription, classConstructors = new LuaMap()) {
+    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+        (0, log_1.log)(`merge is traversing: ${traversalDescription}`);
+    }
+    if (!(0, types_1.isTable)(oldObject)) {
+        error("The first argument given to the merge function is not a table.");
+    }
+    if (!(0, types_1.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 ((0, array_1.isArray)(oldObject) && (0, array_1.isArray)(newTable)) {
+        mergeSerializedArray(oldObject, newTable, traversalDescription, classConstructors);
+        return;
+    }
+    // Depending on whether we are working on a Lua table or a TypeScriptToLua object, we need to
+    // iterate in a specific way.
+    if ((0, tstlClass_1.isTSTLMap)(oldObject) || (0, tstlClass_1.isTSTLSet)(oldObject) || (0, tstlClass_1.isDefaultMap)(oldObject)) {
+        mergeSerializedTSTLObject(oldObject, newTable, traversalDescription, classConstructors);
+    }
+    else {
+        mergeSerializedTable(oldObject, newTable, traversalDescription, classConstructors);
+    }
+}
+exports.merge = merge;
+function mergeSerializedArray(oldArray, newArray, traversalDescription, classConstructors) {
+    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+        (0, log_1.log)(`merge encountered an array: ${traversalDescription}`);
+    }
+    // Assume that we should blow away all array values with whatever is present in the incoming
+    // array.
+    (0, table_1.clearTable)(oldArray);
+    (0, table_1.iterateTableInOrder)(newArray, (key, value) => {
+        const deserializedValue = (0, deepCopy_1.deepCopy)(value, SerializationType_1.SerializationType.DESERIALIZE, traversalDescription, classConstructors);
+        oldArray.set(key, deserializedValue);
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+}
+function mergeSerializedTSTLObject(
+// eslint-disable-next-line isaacscript/prefer-readonly-parameter-types
+oldObject, newTable, traversalDescription, classConstructors) {
+    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+        (0, log_1.log)(`merge encountered a TSTL object: ${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_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS);
+    (0, table_1.iterateTableInOrder)(newTable, (key, value) => {
+        if ((0, serialization_1.isSerializationBrand)(key)) {
+            return;
+        }
+        let keyToUse = key;
+        if (convertStringKeysToNumbers) {
+            const numberKey = tonumber(key);
+            if (numberKey === undefined) {
+                return;
+            }
+            keyToUse = numberKey;
+        }
+        if ((0, tstlClass_1.isTSTLMap)(oldObject) || (0, tstlClass_1.isDefaultMap)(oldObject)) {
+            const deserializedValue = (0, deepCopy_1.deepCopy)(value, SerializationType_1.SerializationType.DESERIALIZE, traversalDescription, classConstructors);
+            oldObject.set(keyToUse, deserializedValue);
+        }
+        else if ((0, tstlClass_1.isTSTLSet)(oldObject)) {
+            oldObject.add(keyToUse);
+        }
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+}
+function mergeSerializedTable(oldTable, newTable, traversalDescription, classConstructors) {
+    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+        (0, log_1.log)(`merge encountered a Lua table: ${traversalDescription}`);
+    }
+    (0, table_1.iterateTableInOrder)(newTable, (key, value) => {
+        if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+            const valueToPrint = value === "" ? "(empty string)" : `${value}`;
+            (0, log_1.log)(`merge is merging: ${traversalDescription} --> ${valueToPrint}`);
+        }
+        if ((0, serialization_1.isSerializationBrand)(key)) {
+            return;
+        }
+        // Handle the special case of serialized Isaac API classes.
+        if ((0, serialization_2.isSerializedIsaacAPIClass)(value)) {
+            if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+                (0, log_1.log)("merge found a serialized Isaac API class.");
+            }
+            const deserializedObject = (0, serialization_2.deserializeIsaacAPIClass)(value);
+            oldTable.set(key, deserializedObject);
+            return;
+        }
+        if ((0, types_1.isTable)(value)) {
+            let oldValue = oldTable.get(key);
+            if (!(0, types_1.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 LuaMap();
+                oldTable.set(key, oldValue);
+            }
+            traversalDescription = (0, utils_1.getTraversalDescription)(key, traversalDescription);
+            merge(oldValue, value, traversalDescription, classConstructors);
+        }
+        else {
+            // Base case: copy the value
+            oldTable.set(key, value);
+        }
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+}

package/dist/functions/mergeTests.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMergeTests = void 0;
+const DefaultMap_1 = require("../classes/DefaultMap");
+const SerializationType_1 = require("../enums/SerializationType");
+const deepCopy_1 = require("./deepCopy");
+const log_1 = require("./log");
+const merge_1 = require("./merge");
+const rng_1 = require("./rng");
+const serialization_1 = require("./serialization");
+const vector_1 = require("./vector");
+/**
+ * Run the suite of tests that prove that the "merge" function works properly.
+ *
+ * This function is only useful if you are troubleshooting the save data manager.
+ */
+function runMergeTests() {
+    oldTableHasUpdatedValue();
+    newTableHasSameValue();
+    oldTableHasUpdatedValueFromNull();
+    oldTableHasSerializedIsaacAPIClass();
+    oldTableHasFilledChildTable();
+    oldTableHasFilledMap();
+    oldTableHasFilledDefaultMap();
+    oldTableHasVector();
+    oldTableHasVectorSerialized();
+    oldTableHasRNG();
+    oldTableHasRNGSerialized();
+    const successText = "All merge tests passed!";
+    (0, log_1.logAndPrint)(successText);
+}
+exports.runMergeTests = runMergeTests;
+function oldTableHasUpdatedValue() {
+    const key = "foo";
+    const oldValue = "bar";
+    const newValue = "baz";
+    const oldTable = {
+        foo: oldValue,
+    };
+    const newTable = {
+        foo: newValue,
+    };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValue");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue !== newValue) {
+        error(`The old table does not have a value of: ${newValue}`);
+    }
+}
+function newTableHasSameValue() {
+    const key = "foo";
+    const oldValue = "bar";
+    const newValue = "baz";
+    const oldTable = {
+        foo: oldValue,
+    };
+    const newTable = {
+        foo: newValue,
+    };
+    (0, merge_1.merge)(oldTable, newTable, "newTableHasSameValue");
+    const newTableValue = newTable.get(key);
+    if (newTableValue !== newValue) {
+        error(`The new table does not have a value of: ${newValue}`);
+    }
+}
+function oldTableHasUpdatedValueFromNull() {
+    const key = "foo";
+    const newValue = "baz";
+    const oldTable = {
+        foo: null,
+    };
+    const newTable = {
+        foo: newValue,
+    };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue !== newValue) {
+        error(`The old table does not have a value of: ${newValue}`);
+    }
+}
+function oldTableHasSerializedIsaacAPIClass() {
+    const x = 50;
+    const y = 60;
+    const vector = Vector(x, y);
+    const vectorSerialized = (0, vector_1.serializeVector)(vector);
+    if (!(0, serialization_1.isSerializedIsaacAPIClass)(vectorSerialized)) {
+        error('The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.');
+    }
+}
+function oldTableHasFilledChildTable() {
+    const key = "foo";
+    const newValue = "baz";
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasFilledChildTable");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (oldTableValue.bar !== newValue) {
+        error('The old table\'s key of "bar" was not filled.');
+    }
+}
+function oldTableHasFilledMap() {
+    const fakeV = {
+        run: {
+            myMap: new Map(),
+        },
+    };
+    const saveData = {
+        run: {
+            myMap: new Map([
+                ["foo1", "bar1"],
+                ["foo2", "bar2"],
+                ["foo3", "bar3"],
+            ]),
+        },
+    };
+    const serializedSaveData = (0, deepCopy_1.deepCopy)(saveData, SerializationType_1.SerializationType.SERIALIZE);
+    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledMap");
+    const expectedSize = 3;
+    if (fakeV.run.myMap.size !== expectedSize) {
+        error(`The size of the merged map was equal to ${fakeV.run.myMap.size}, but it should be equal to: ${expectedSize}`);
+    }
+    {
+        const key = "foo1";
+        const expectedValue = "bar1";
+        const value = fakeV.run.myMap.get(key);
+        if (value !== expectedValue) {
+            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+        }
+    }
+    {
+        const key = "foo2";
+        const expectedValue = "bar2";
+        const value = fakeV.run.myMap.get(key);
+        if (value !== expectedValue) {
+            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+        }
+    }
+    {
+        const key = "foo3";
+        const expectedValue = "bar3";
+        const value = fakeV.run.myMap.get(key);
+        if (value !== expectedValue) {
+            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+        }
+    }
+}
+function oldTableHasFilledDefaultMap() {
+    const fakeV = {
+        run: {
+            myDefaultMap: new DefaultMap_1.DefaultMap("default"),
+        },
+    };
+    const saveData = {
+        run: {
+            myDefaultMap: new DefaultMap_1.DefaultMap("default", [
+                ["foo1", "bar1"],
+                ["foo2", "bar2"],
+                ["foo3", "bar3"],
+            ]),
+        },
+    };
+    const serializedSaveData = (0, deepCopy_1.deepCopy)(saveData, SerializationType_1.SerializationType.SERIALIZE);
+    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledDefaultMap");
+    const expectedSize = 3;
+    if (fakeV.run.myDefaultMap.size !== expectedSize) {
+        error(`The size of the merged default map was equal to ${fakeV.run.myDefaultMap.size}, but it should be equal to: ${expectedSize}`);
+    }
+    {
+        const key = "foo1";
+        const expectedValue = "bar1";
+        const value = fakeV.run.myDefaultMap.get(key);
+        if (value !== expectedValue) {
+            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+        }
+    }
+    {
+        const key = "foo2";
+        const expectedValue = "bar2";
+        const value = fakeV.run.myDefaultMap.get(key);
+        if (value !== expectedValue) {
+            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+        }
+    }
+    {
+        const key = "foo3";
+        const expectedValue = "bar3";
+        const value = fakeV.run.myDefaultMap.get(key);
+        if (value !== expectedValue) {
+            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+        }
+    }
+}
+function oldTableHasVector() {
+    const key = "foo";
+    const x = 50;
+    const y = 60;
+    const newValue = Vector(x, y);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasVector");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (oldTableValue.bar.X !== x) {
+        error(`The old table's value for "x" does not match: ${x}`);
+    }
+    if (oldTableValue.bar.Y !== y) {
+        error(`The old table's value for "y" does not match: ${y}`);
+    }
+    if (!(0, vector_1.isVector)(oldTableValue.bar)) {
+        error("The old table's value is not a Vector object.");
+    }
+}
+function oldTableHasVectorSerialized() {
+    const key = "foo";
+    const x = 50;
+    const y = 60;
+    const newValue = Vector(x, y);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    const newTableSerialized = (0, deepCopy_1.deepCopy)(newTable, SerializationType_1.SerializationType.SERIALIZE, "oldTableHasVectorSerialized");
+    (0, merge_1.merge)(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (oldTableValue.bar.X !== x) {
+        error(`The old table's value for "x" does not match: ${x}`);
+    }
+    if (oldTableValue.bar.Y !== y) {
+        error(`The old table's value for "y" does not match: ${y}`);
+    }
+    if (!(0, vector_1.isVector)(oldTableValue.bar)) {
+        error("The old table's value is not a Vector object (during the serialized test).");
+    }
+}
+function oldTableHasRNG() {
+    const key = "foo";
+    const seed = 50;
+    const newValue = (0, rng_1.newRNG)(seed);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasRNG");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
+        error("The old table's value is not an RNG object.");
+    }
+    const newSeed = oldTableValue.bar.GetSeed();
+    if (newSeed !== seed) {
+        error(`The old table's seed not match: ${seed}`);
+    }
+}
+function oldTableHasRNGSerialized() {
+    const key = "foo";
+    const seed = 50;
+    const newValue = (0, rng_1.newRNG)(seed);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    const newTableSerialized = (0, deepCopy_1.deepCopy)(newTable, SerializationType_1.SerializationType.SERIALIZE, "oldTableHasRNGSerialized");
+    (0, merge_1.merge)(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
+        error("The old table's value is not an RNG object (during the serialized test).");
+    }
+    const newSeed = oldTableValue.bar.GetSeed();
+    if (newSeed !== seed) {
+        error(`The old table's seed not match: ${seed}`);
+    }
+}