isaacscript-common 6.6.3 → 6.7.0

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/{npc.ts → npcs.ts}

@@ -16,8 +16,8 @@ import {
   VisVariant,
 } from "isaac-typescript-definitions";
 import { EGGY_STATE_FRAME_OF_FINAL_SPIDER } from "../constants";
-import { getFilteredNewEntities } from "./entity";
-import { getNPCs, getProjectiles } from "./entitySpecific";
+import { getFilteredNewEntities } from "./entities";
+import { getNPCs, getProjectiles } from "./entitiesSpecific";
 
 /**
  * Used to filter out certain NPCs when determining of an NPC is "alive" and/or should keep the
@@ -78,19 +78,22 @@ export function fireProjectiles(
  *
  * This function will not include NPCs on an internal blacklist, such as Death's scythes or Big Horn
  * holes.
+ *
+ * @param entityType Optional. If specified, will only get the NPCs that match the type. Default is
+ *                   -1, which matches every type.
+ * @param variant Optional. If specified, will only get the NPCs that match the variant. Default is
+ *                -1, which matches every variant.
+ * @param subType Optional. If specified, will only get the NPCs that match the sub-type. Default is
+ *                -1, which matches every sub-type.
+ * @param ignoreFriendly Optional. Default is false.
  */
 export function getAliveNPCs(
-  matchingEntityType?: EntityType,
-  matchingVariant?: int,
-  matchingSubType?: int,
+  entityType: EntityType = -1,
+  variant = -1,
+  subType = -1,
   ignoreFriendly = false,
 ): EntityNPC[] {
-  const npcs = getNPCs(
-    matchingEntityType,
-    matchingVariant,
-    matchingSubType,
-    ignoreFriendly,
-  );
+  const npcs = getNPCs(entityType, variant, subType, ignoreFriendly);
   return npcs.filter((npc) => !npc.IsDead() && !isAliveExceptionNPC(npc));
 }
 
@@ -146,3 +149,31 @@ export function isRaglingDeathPatch(npc: EntityNPC): boolean {
     npc.State === NpcState.SPECIAL
   );
 }
+
+/**
+ * The base game `EntityNPC.FireProjectiles` method does not return anything, which is a problem in
+ * situations where you need to work with the fired projectiles. This function invokes that method,
+ * and then returns the projectiles that were spawned.
+ *
+ * @param npc The EntityNPC firing projectiles.
+ * @param position The starting position of the projectiles.
+ * @param velocity The starting velocity of the projectiles.
+ * @param projectilesMode A ProjectilesMode enum value defining how to fire the projectiles.
+ * @param projectileParams A ProjectileParams object containing various parameters for the
+ *                         projectiles.
+ * @returns An array of EntityProjectiles containing all fired projectiles.
+ */
+export function npcFireProjectiles(
+  npc: EntityNPC,
+  position: Vector,
+  velocity: Vector,
+  projectilesMode: ProjectilesMode,
+  projectileParams: ProjectileParams,
+): EntityProjectile[] {
+  const oldEntities = getProjectiles();
+  npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
+  const newEntities = getProjectiles();
+  const filteredNewEntities = getFilteredNewEntities(oldEntities, newEntities);
+
+  return filteredNewEntities;
+}