isaacscript-common 6.6.2 → 6.6.5

package/src/functions/mergeTests.ts

@@ -1,3 +1,4 @@
+import { DefaultMap } from "../classes/DefaultMap";
 import { SerializationType } from "../enums/SerializationType";
 import { merge } from "../features/saveDataManager/merge";
 import { deepCopy } from "./deepCopy";
@@ -6,13 +7,22 @@ import { isRNG, newRNG } from "./rng";
 import { isSerializedIsaacAPIClass } from "./serialization";
 import { copyVector, isVector } from "./vector";
 
-export function mergeTests(): void {
+/**
+ * Run the suite of tests that prove that the "merge" helper function works properly. (This function
+ * is not exported but is used internally in the save data manager.)
+ *
+ * This function is only useful if you are troubleshooting the save data manager.
+ */
+export function runMergeTests(): void {
   oldTableHasUpdatedValue();
   newTableHasSameValue();
   oldTableHasUpdatedValueFromNull();
   oldTableHasSerializedIsaacAPIClass();
 
-  oldTableHasFilledInterface();
+  oldTableHasFilledChildTable();
+  oldTableHasFilledMap();
+  oldTableHasFilledDefaultMap();
+
   oldTableHasVector();
   oldTableHasVectorSerialized();
   oldTableHasRNG();
@@ -90,7 +100,7 @@ function oldTableHasSerializedIsaacAPIClass() {
   }
 }
 
-function oldTableHasFilledInterface() {
+function oldTableHasFilledChildTable() {
   interface Foo {
     bar: string;
   }
@@ -107,7 +117,7 @@ function oldTableHasFilledInterface() {
     foo,
   } as unknown as LuaTable<AnyNotNil, unknown>;
 
-  merge(oldTable, newTable, "oldTableHasFilledInterface");
+  merge(oldTable, newTable, "oldTableHasFilledChildTable");
 
   const oldTableValue = oldTable.get(key) as Foo | undefined;
   if (oldTableValue === undefined) {
@@ -119,6 +129,142 @@ function oldTableHasFilledInterface() {
   }
 }
 
+function oldTableHasFilledMap() {
+  const v = {
+    run: {
+      myMap: new Map<string, string>(),
+    },
+  };
+
+  const saveData = {
+    run: {
+      myMap: new Map<string, string>([
+        ["foo1", "bar1"],
+        ["foo2", "bar2"],
+        ["foo3", "bar3"],
+      ]),
+    },
+  };
+  const serializedSaveData = deepCopy(saveData, SerializationType.SERIALIZE);
+
+  merge(
+    v as unknown as LuaTable,
+    serializedSaveData as LuaTable,
+    "oldTableHasFilledMap",
+  );
+
+  const expectedSize = 3;
+  if (v.run.myMap.size !== expectedSize) {
+    error(
+      `The size of the merged map was equal to ${v.run.myMap.size}, but it should be equal to: ${expectedSize}`,
+    );
+  }
+
+  {
+    const key = "foo1";
+    const expectedValue = "bar1";
+
+    const value = v.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 = v.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 = v.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 v = {
+    run: {
+      myDefaultMap: new DefaultMap<string, string>("default"),
+    },
+  };
+
+  const saveData = {
+    run: {
+      myDefaultMap: new DefaultMap<string, string>("default", [
+        ["foo1", "bar1"],
+        ["foo2", "bar2"],
+        ["foo3", "bar3"],
+      ]),
+    },
+  };
+  const serializedSaveData = deepCopy(saveData, SerializationType.SERIALIZE);
+
+  merge(
+    v as unknown as LuaTable,
+    serializedSaveData as LuaTable,
+    "oldTableHasFilledDefaultMap",
+  );
+
+  const expectedSize = 3;
+  if (v.run.myDefaultMap.size !== expectedSize) {
+    error(
+      `The size of the merged default map was equal to ${v.run.myDefaultMap.size}, but it should be equal to: ${expectedSize}`,
+    );
+  }
+
+  {
+    const key = "foo1";
+    const expectedValue = "bar1";
+
+    const value = v.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 = v.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 = v.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() {
   log("Starting test: oldTableHasVector");
 
@@ -183,6 +329,7 @@ function oldTableHasVectorSerialized() {
   const newTableSerialized = deepCopy(
     newTable,
     SerializationType.SERIALIZE,
+    "oldTableHasVectorSerialized",
   ) as LuaTable<AnyNotNil, unknown>;
 
   merge(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
@@ -266,6 +413,7 @@ function oldTableHasRNGSerialized() {
   const newTableSerialized = deepCopy(
     newTable,
     SerializationType.SERIALIZE,
+    "oldTableHasRNGSerialized",
   ) as LuaTable<AnyNotNil, unknown>;
 
   merge(oldTable, newTableSerialized, "oldTableHasRNGSerialized");

package/src/functions/playerIndex.ts

@@ -63,6 +63,10 @@ export function getPlayerFromIndex(
  * though they are technically different characters, they share the same inventory and InitSeed.) If
  * this is not desired, pass true for the `differentiateForgottenAndSoul` argument, and the RNG of
  * Spoon Bender (3) will be used for The Soul.
+ *
+ * Also note that this index doesn't work in the `POST_PLAYER_INIT` function for players 2 through
+ * 4. With that said, in almost all cases, you should be lazy-initializing your data structures in
+ * other callbacks, so this should not be an issue.
  */
 export function getPlayerIndex(
   player: EntityPlayer,

package/src/functions/table.ts

@@ -134,7 +134,7 @@ export function getStringsFromTable(
  * This function will sort the table entries based on the value of the key.
  *
  * This function will only work on tables that have number keys or string keys. It will throw a
- * runtime error if it encounters a key of another type.
+ * run-time error if it encounters a key of another type.
  *
  * @param luaTable The table to iterate over.
  * @param func The function to run for each iteration.

package/src/functions/trinketGive.ts

@@ -98,7 +98,7 @@ export function temporarilyRemoveTrinket(
   let numTrinkets = 0;
   while (player.HasTrinket(trinketType)) {
     player.TryRemoveTrinket(trinketType);
-    numTrinkets += 1;
+    numTrinkets++;
   }
 
   let numSmeltedTrinkets = numTrinkets;
@@ -106,13 +106,13 @@ export function temporarilyRemoveTrinket(
     trinketType1 === trinketType ||
     trinketType1 === getGoldenTrinketType(trinketType);
   if (trinketWasInSlot1) {
-    numSmeltedTrinkets -= 1;
+    numSmeltedTrinkets--;
   }
   const trinketWasInSlot2 =
     trinketType2 === trinketType ||
     trinketType2 === getGoldenTrinketType(trinketType);
   if (trinketWasInSlot2) {
-    numSmeltedTrinkets -= 1;
+    numSmeltedTrinkets--;
   }
 
   return {

package/src/functions/tstlClass.ts

@@ -100,7 +100,7 @@ export function isUserDefinedTSTLClass(object: unknown): object is TSTLClass {
 
   let numKeys = 0;
   for (const [key] of pairs(metatable)) {
-    numKeys += 1;
+    numKeys++;
 
     if (!isString(key)) {
       return false;

package/src/functions/ui.ts

@@ -27,10 +27,10 @@ export function getHUDOffsetVector(): Vector {
   const x = hudOffset * 2;
   let y = hudOffset;
   if (y >= 4) {
-    y += 1;
+    y++;
   }
   if (y >= 9) {
-    y += 1;
+    y++;
   }
 
   return Vector(x, y);
@@ -69,7 +69,7 @@ export function getHeartsUIWidth(): int {
 
   let heartRowLength = getHeartRowLength(player);
   if (hasHolyMantleEffect) {
-    heartRowLength += 1;
+    heartRowLength++;
   }
   if (curses === LevelCurse.UNKNOWN) {
     heartRowLength = 1;