isaacscript-common 87.9.5 → 87.9.7

package/src/functions/merge.ts

@@ -130,58 +130,6 @@ function mergeSerializedArray(
   );
 }
 
-function mergeSerializedTSTLObject(
-  // eslint-disable-next-line complete/prefer-readonly-parameter-types
-  oldObject: Map<AnyNotNil, unknown> | Set<AnyNotNil>,
-  newTable: LuaMap<AnyNotNil, unknown>,
-  traversalDescription: string,
-  classConstructors: LuaMap<string, AnyClass>,
-) {
-  if (SAVE_DATA_MANAGER_DEBUG) {
-    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.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) || isDefaultMap(oldObject)) {
-        const deserializedValue = deepCopy(
-          value,
-          SerializationType.DESERIALIZE,
-          traversalDescription,
-          classConstructors,
-        );
-        oldObject.set(keyToUse, deserializedValue);
-      } else if (isTSTLSet(oldObject)) {
-        oldObject.add(keyToUse);
-      }
-    },
-    SAVE_DATA_MANAGER_DEBUG,
-  );
-}
-
 function mergeSerializedTable(
   oldTable: LuaMap<AnyNotNil, unknown>,
   newTable: LuaMap<AnyNotNil, unknown>,
@@ -196,7 +144,7 @@ function mergeSerializedTable(
     newTable,
     (key, value) => {
       if (SAVE_DATA_MANAGER_DEBUG) {
-        const valueToPrint = value === "" ? "(empty string)" : `${value}`;
+        const valueToPrint = value === "" ? "(empty string)" : String(value);
         log(`merge is merging: ${traversalDescription} --> ${valueToPrint}`);
       }
 
@@ -238,3 +186,55 @@ function mergeSerializedTable(
     SAVE_DATA_MANAGER_DEBUG,
   );
 }
+
+function mergeSerializedTSTLObject(
+  // eslint-disable-next-line complete/prefer-readonly-parameter-types
+  oldObject: Map<AnyNotNil, unknown> | Set<AnyNotNil>,
+  newTable: LuaMap<AnyNotNil, unknown>,
+  traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
+) {
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    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.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) || isDefaultMap(oldObject)) {
+        const deserializedValue = deepCopy(
+          value,
+          SerializationType.DESERIALIZE,
+          traversalDescription,
+          classConstructors,
+        );
+        oldObject.set(keyToUse, deserializedValue);
+      } else if (isTSTLSet(oldObject)) {
+        oldObject.add(keyToUse);
+      }
+    },
+    SAVE_DATA_MANAGER_DEBUG,
+  );
+}

package/src/functions/mergeTests.ts

@@ -31,35 +31,12 @@ export function runMergeTests(): void {
   logAndPrint(successText);
 }
 
-function oldTableHasUpdatedValue() {
-  const key = "foo";
-  const oldValue = "bar";
-  const newValue = "baz";
-  const oldTable = {
-    foo: oldValue,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const newTable = {
-    foo: newValue,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-
-  merge(oldTable, newTable, "oldTableHasUpdatedValue");
-
-  const oldTableValue = oldTable.get(key) as string;
-  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,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const newTable = {
-    foo: newValue,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
+  const oldTable = { foo: oldValue } as unknown as LuaMap<AnyNotNil, unknown>;
+  const newTable = { foo: newValue } as unknown as LuaMap<AnyNotNil, unknown>;
 
   merge(oldTable, newTable, "newTableHasSameValue");
 
@@ -69,53 +46,19 @@ function newTableHasSameValue() {
   }
 }
 
-function oldTableHasUpdatedValueFromNull() {
-  const key = "foo";
-  const newValue = "baz";
-  const oldTable = {
-    foo: null as string | null,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const newTable = {
-    foo: newValue,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-
-  merge(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
-
-  const oldTableValue = oldTable.get(key) as string;
-  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 = serializeVector(vector);
-  if (!isSerializedIsaacAPIClass(vectorSerialized)) {
-    error(
-      'The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.',
-    );
-  }
-}
-
 function oldTableHasFilledChildTable() {
   interface Foo {
-    bar: string;
+    readonly bar: string;
   }
 
   const key = "foo";
   const newValue = "baz";
-  const oldTable = {
-    foo: null as Foo | null,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const foo: Foo = {
-    bar: newValue,
-  };
-  const newTable = {
-    foo,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
+  const oldTable = { foo: null as Foo | null } as unknown as LuaMap<
+    AnyNotNil,
+    unknown
+  >;
+  const foo: Foo = { bar: newValue };
+  const newTable = { foo } as unknown as LuaMap<AnyNotNil, unknown>;
 
   merge(oldTable, newTable, "oldTableHasFilledChildTable");
 
@@ -129,16 +72,16 @@ function oldTableHasFilledChildTable() {
   }
 }
 
-function oldTableHasFilledMap() {
+function oldTableHasFilledDefaultMap() {
   const fakeV = {
     run: {
-      myMap: new Map<string, string>(),
+      myDefaultMap: new DefaultMap<string, string>("default"),
     },
   };
 
   const saveData = {
     run: {
-      myMap: new Map<string, string>([
+      myDefaultMap: new DefaultMap<string, string>("default", [
         ["foo1", "bar1"],
         ["foo2", "bar2"],
         ["foo3", "bar3"],
@@ -150,13 +93,13 @@ function oldTableHasFilledMap() {
   merge(
     fakeV as unknown as LuaMap,
     serializedSaveData as LuaMap,
-    "oldTableHasFilledMap",
+    "oldTableHasFilledDefaultMap",
   );
 
   const expectedSize = 3;
-  if (fakeV.run.myMap.size !== expectedSize) {
+  if (fakeV.run.myDefaultMap.size !== expectedSize) {
     error(
-      `The size of the merged map was equal to ${fakeV.run.myMap.size}, but it should be equal to: ${expectedSize}`,
+      `The size of the merged default map was equal to ${fakeV.run.myDefaultMap.size}, but it should be equal to: ${expectedSize}`,
     );
   }
 
@@ -164,10 +107,10 @@ function oldTableHasFilledMap() {
     const key = "foo1";
     const expectedValue = "bar1";
 
-    const value = fakeV.run.myMap.get(key);
+    const value = fakeV.run.myDefaultMap.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}`,
+        `The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`,
       );
     }
   }
@@ -176,10 +119,10 @@ function oldTableHasFilledMap() {
     const key = "foo2";
     const expectedValue = "bar2";
 
-    const value = fakeV.run.myMap.get(key);
+    const value = fakeV.run.myDefaultMap.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}`,
+        `The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`,
       );
     }
   }
@@ -188,25 +131,25 @@ function oldTableHasFilledMap() {
     const key = "foo3";
     const expectedValue = "bar3";
 
-    const value = fakeV.run.myMap.get(key);
+    const value = fakeV.run.myDefaultMap.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}`,
+        `The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`,
       );
     }
   }
 }
 
-function oldTableHasFilledDefaultMap() {
+function oldTableHasFilledMap() {
   const fakeV = {
     run: {
-      myDefaultMap: new DefaultMap<string, string>("default"),
+      myMap: new Map<string, string>(),
     },
   };
 
   const saveData = {
     run: {
-      myDefaultMap: new DefaultMap<string, string>("default", [
+      myMap: new Map<string, string>([
         ["foo1", "bar1"],
         ["foo2", "bar2"],
         ["foo3", "bar3"],
@@ -218,13 +161,13 @@ function oldTableHasFilledDefaultMap() {
   merge(
     fakeV as unknown as LuaMap,
     serializedSaveData as LuaMap,
-    "oldTableHasFilledDefaultMap",
+    "oldTableHasFilledMap",
   );
 
   const expectedSize = 3;
-  if (fakeV.run.myDefaultMap.size !== expectedSize) {
+  if (fakeV.run.myMap.size !== expectedSize) {
     error(
-      `The size of the merged default map was equal to ${fakeV.run.myDefaultMap.size}, but it should be equal to: ${expectedSize}`,
+      `The size of the merged map was equal to ${fakeV.run.myMap.size}, but it should be equal to: ${expectedSize}`,
     );
   }
 
@@ -232,10 +175,10 @@ function oldTableHasFilledDefaultMap() {
     const key = "foo1";
     const expectedValue = "bar1";
 
-    const value = fakeV.run.myDefaultMap.get(key);
+    const value = fakeV.run.myMap.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}`,
+        `The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`,
       );
     }
   }
@@ -244,10 +187,10 @@ function oldTableHasFilledDefaultMap() {
     const key = "foo2";
     const expectedValue = "bar2";
 
-    const value = fakeV.run.myDefaultMap.get(key);
+    const value = fakeV.run.myMap.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}`,
+        `The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`,
       );
     }
   }
@@ -256,173 +199,206 @@ function oldTableHasFilledDefaultMap() {
     const key = "foo3";
     const expectedValue = "bar3";
 
-    const value = fakeV.run.myDefaultMap.get(key);
+    const value = fakeV.run.myMap.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}`,
+        `The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`,
       );
     }
   }
 }
 
-function oldTableHasVector() {
+function oldTableHasRNG() {
   interface Foo {
-    bar: Vector;
+    readonly bar: Readonly<RNG>;
   }
 
   const key = "foo";
-  const x = 50;
-  const y = 60;
-  const newValue = Vector(x, y);
-  const oldTable = {
-    foo: null as Foo | null,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const foo: Foo = {
-    bar: newValue,
-  };
-  const newTable = {
-    foo,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
+  const seed = 50 as Seed;
+  const newValue = newRNG(seed);
+  const oldTable = { foo: null as Foo | null } as unknown as LuaMap<
+    AnyNotNil,
+    unknown
+  >;
+  const foo: Foo = { bar: newValue };
+  const newTable = { foo } as unknown as LuaMap<AnyNotNil, unknown>;
 
-  merge(oldTable, newTable, "oldTableHasVector");
+  merge(oldTable, newTable, "oldTableHasRNG");
 
   const oldTableValue = oldTable.get(key) as Foo | undefined;
   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 (!isRNG(oldTableValue.bar)) {
+    error("The old table's value is not an RNG object.");
   }
 
-  if (!isVector(oldTableValue.bar)) {
-    error("The old table's value is not a Vector object.");
+  const newSeed = oldTableValue.bar.GetSeed();
+  if (newSeed !== seed) {
+    error(`The old table's seed not match: ${seed}`);
   }
 }
 
-function oldTableHasVectorSerialized() {
+function oldTableHasRNGSerialized() {
   interface Foo {
-    bar: Vector;
+    readonly bar: Readonly<RNG>;
   }
 
   const key = "foo";
-  const x = 50;
-  const y = 60;
-  const newValue = Vector(x, y);
-  const oldTable = {
-    foo: null as Foo | null,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const foo: Foo = {
-    bar: newValue,
-  };
-  const newTable = {
-    foo,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
+  const seed = 50 as Seed;
+  const newValue = newRNG(seed);
+  const oldTable = { foo: null as Foo | null } as unknown as LuaMap<
+    AnyNotNil,
+    unknown
+  >;
+  const foo: Foo = { bar: newValue };
+  const newTable = { foo } as unknown as LuaMap<AnyNotNil, unknown>;
   const newTableSerialized = deepCopy(
     newTable,
     SerializationType.SERIALIZE,
-    "oldTableHasVectorSerialized",
+    "oldTableHasRNGSerialized",
   ) as LuaMap<AnyNotNil, unknown>;
 
-  merge(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
+  merge(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
 
   const oldTableValue = oldTable.get(key) as Foo | undefined;
   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 (!isRNG(oldTableValue.bar)) {
+    error(
+      "The old table's value is not an RNG object (during the serialized test).",
+    );
   }
 
-  if (oldTableValue.bar.Y !== y) {
-    error(`The old table's value for "y" does not match: ${y}`);
+  const newSeed = oldTableValue.bar.GetSeed();
+  if (newSeed !== seed) {
+    error(`The old table's seed not match: ${seed}`);
   }
+}
 
-  if (!isVector(oldTableValue.bar)) {
+function oldTableHasSerializedIsaacAPIClass() {
+  const x = 50;
+  const y = 60;
+  const vector = Vector(x, y);
+
+  const vectorSerialized = serializeVector(vector);
+  if (!isSerializedIsaacAPIClass(vectorSerialized)) {
     error(
-      "The old table's value is not a Vector object (during the serialized test).",
+      'The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.',
     );
   }
 }
 
-function oldTableHasRNG() {
+function oldTableHasUpdatedValue() {
+  const key = "foo";
+  const oldValue = "bar";
+  const newValue = "baz";
+  const oldTable = { foo: oldValue } as unknown as LuaMap<AnyNotNil, unknown>;
+  const newTable = { foo: newValue } as unknown as LuaMap<AnyNotNil, unknown>;
+
+  merge(oldTable, newTable, "oldTableHasUpdatedValue");
+
+  const oldTableValue = oldTable.get(key) as string;
+  if (oldTableValue !== newValue) {
+    error(`The old table does not have a value of: ${newValue}`);
+  }
+}
+
+function oldTableHasUpdatedValueFromNull() {
+  const key = "foo";
+  const newValue = "baz";
+  const oldTable = { foo: null as string | null } as unknown as LuaMap<
+    AnyNotNil,
+    unknown
+  >;
+  const newTable = { foo: newValue } as unknown as LuaMap<AnyNotNil, unknown>;
+
+  merge(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
+
+  const oldTableValue = oldTable.get(key) as string;
+  if (oldTableValue !== newValue) {
+    error(`The old table does not have a value of: ${newValue}`);
+  }
+}
+
+function oldTableHasVector() {
   interface Foo {
-    bar: RNG;
+    readonly bar: Readonly<Vector>;
   }
 
   const key = "foo";
-  const seed = 50 as Seed;
-  const newValue = newRNG(seed);
-  const oldTable = {
-    foo: null as Foo | null,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const foo: Foo = {
-    bar: newValue,
-  };
-  const newTable = {
-    foo,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
+  const x = 50;
+  const y = 60;
+  const newValue = Vector(x, y);
+  const oldTable = { foo: null as Foo | null } as unknown as LuaMap<
+    AnyNotNil,
+    unknown
+  >;
+  const foo: Foo = { bar: newValue };
+  const newTable = { foo } as unknown as LuaMap<AnyNotNil, unknown>;
 
-  merge(oldTable, newTable, "oldTableHasRNG");
+  merge(oldTable, newTable, "oldTableHasVector");
 
   const oldTableValue = oldTable.get(key) as Foo | undefined;
   if (oldTableValue === undefined) {
     error(`The old table's key of "${key}" was not filled.`);
   }
 
-  if (!isRNG(oldTableValue.bar)) {
-    error("The old table's value is not an RNG object.");
+  if (oldTableValue.bar.X !== x) {
+    error(`The old table's value for "x" does not match: ${x}`);
   }
 
-  const newSeed = oldTableValue.bar.GetSeed();
-  if (newSeed !== seed) {
-    error(`The old table's seed not match: ${seed}`);
+  if (oldTableValue.bar.Y !== y) {
+    error(`The old table's value for "y" does not match: ${y}`);
+  }
+
+  if (!isVector(oldTableValue.bar)) {
+    error("The old table's value is not a Vector object.");
   }
 }
 
-function oldTableHasRNGSerialized() {
+function oldTableHasVectorSerialized() {
   interface Foo {
-    bar: RNG;
+    readonly bar: Readonly<Vector>;
   }
 
   const key = "foo";
-  const seed = 50 as Seed;
-  const newValue = newRNG(seed);
-  const oldTable = {
-    foo: null as Foo | null,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
-  const foo: Foo = {
-    bar: newValue,
-  };
-  const newTable = {
-    foo,
-  } as unknown as LuaMap<AnyNotNil, unknown>;
+  const x = 50;
+  const y = 60;
+  const newValue = Vector(x, y);
+  const oldTable = { foo: null as Foo | null } as unknown as LuaMap<
+    AnyNotNil,
+    unknown
+  >;
+  const foo: Foo = { bar: newValue };
+  const newTable = { foo } as unknown as LuaMap<AnyNotNil, unknown>;
   const newTableSerialized = deepCopy(
     newTable,
     SerializationType.SERIALIZE,
-    "oldTableHasRNGSerialized",
+    "oldTableHasVectorSerialized",
   ) as LuaMap<AnyNotNil, unknown>;
 
-  merge(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
+  merge(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
 
   const oldTableValue = oldTable.get(key) as Foo | undefined;
   if (oldTableValue === undefined) {
     error(`The old table's key of "${key}" was not filled.`);
   }
 
-  if (!isRNG(oldTableValue.bar)) {
-    error(
-      "The old table's value is not an RNG object (during the serialized test).",
-    );
+  if (oldTableValue.bar.X !== x) {
+    error(`The old table's value for "x" does not match: ${x}`);
   }
 
-  const newSeed = oldTableValue.bar.GetSeed();
-  if (newSeed !== seed) {
-    error(`The old table's seed not match: ${seed}`);
+  if (oldTableValue.bar.Y !== y) {
+    error(`The old table's value for "y" does not match: ${y}`);
+  }
+
+  if (!isVector(oldTableValue.bar)) {
+    error(
+      "The old table's value is not a Vector object (during the serialized test).",
+    );
   }
 }

package/src/functions/nextStage.ts

@@ -29,8 +29,6 @@ export function getNextStage(): LevelStage {
     GameStateFlag.MAUSOLEUM_HEART_KILLED,
   );
   const stage = level.GetStage();
-  const repentanceStage = onRepentanceStage();
-  const roomGridIndex = getRoomGridIndex();
 
   // First, handle the special case of being on the backwards path.
   if (backwardsPath) {
@@ -38,6 +36,9 @@ export function getNextStage(): LevelStage {
     return nextStage === 0 ? LevelStage.HOME : nextStage;
   }
 
+  const repentanceStage = onRepentanceStage();
+  const roomGridIndex = getRoomGridIndex();
+
   // Second, handle the special case of being in a specific off-grid room.
   switch (roomGridIndex) {
     // -8
@@ -169,8 +170,8 @@ export function getNextStageType(upwards = false): StageType {
 
   if (
     repentanceStage
-    && stage === LevelStage.DEPTHS_2
     && mausoleumHeartKilled
+    && stage === LevelStage.DEPTHS_2
   ) {
     return calculateStageTypeRepentance(nextStage);
   }

package/src/functions/pickupVariants.ts

@@ -1,4 +1,4 @@
-/* eslint-disable sort-exports/sort-exports */
+/* eslint-disable perfectionist/sort-modules */
 
 import { EntityType, PickupVariant } from "isaac-typescript-definitions";