isaacscript-common 6.15.0 → 6.16.0

package/src/enums/ModCallbackCustom.ts

@@ -363,6 +363,42 @@ export enum ModCallbackCustom {
    */
   POST_GRID_ENTITY_COLLISION,
 
+  /**
+   * Fires from the `POST_UPDATE` callback when a grid entity created with the
+   * `spawnCustomGridEntity` helper function is hit by an explosion.
+   *
+   * In most cases, you will want to remove the grid entity inside of this callback in order to
+   * prevent further "broken" callbacks from firing. (This would not be the case if you were trying
+   * to emulate a super tinted rock that takes multiple explosions to destroy, for example.)
+   *
+   * When registering the callback, takes an optional second argument that will make the callback
+   * only fire if it matches the `GridEntityType` provided.
+   *
+   * ```ts
+   * function postGridEntityCustomBroken(
+   *   gridEntity: GridEntity,
+   *   gridEntityTypeCustom: GridEntityType,
+   * ): void {}
+   * ```
+   */
+  POST_GRID_ENTITY_CUSTOM_BROKEN,
+
+  /**
+   * Fires from the `POST_UPDATE` callback a new entity collides with a grid entity created with the
+   * `spawnCustomGridEntity` helper function.
+   *
+   * When registering the callback, takes an optional second argument that will make the callback
+   * only fire if it matches the `GridEntityType` provided.
+   *
+   * ```ts
+   * function postGridEntityCustomRender(
+   *   gridEntity: GridEntity,
+   *   gridEntityTypeCustom: GridEntityType,
+   * ): void {}
+   * ```
+   */
+  POST_GRID_ENTITY_CUSTOM_COLLISION,
+
   /**
    * Fires from the `POST_RENDER` callback on every frame that a grid entity created with the
    * `spawnCustomGridEntity` helper function exists.
@@ -371,7 +407,7 @@ export enum ModCallbackCustom {
    * only fire if it matches the `GridEntityType` provided.
    *
    * ```ts
-   * function postGridEntityRenderCustom(
+   * function postGridEntityCustomRender(
    *   gridEntity: GridEntity,
    *   gridEntityTypeCustom: GridEntityType,
    * ): void {}
@@ -387,7 +423,7 @@ export enum ModCallbackCustom {
    * only fire if it matches the `GridEntityType` provided.
    *
    * ```ts
-   * function postGridEntityUpdateCustom(
+   * function postGridEntityCustomUpdate(
    *   gridEntity: GridEntity,
    *   gridEntityTypeCustom: GridEntityType,
    * ): void {}

package/src/features/customGridEntity.ts

@@ -1,17 +1,22 @@
 import {
   ActiveSlot,
   CollectibleType,
+  DamageFlag,
+  EntityType,
   GridCollisionClass,
   GridEntityType,
   ModCallback,
   UseFlag,
 } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
+import { postGridEntityCustomBrokenFire } from "../callbacks/subscriptions/postGridEntityCustomBroken";
 import { DefaultMap } from "../classes/DefaultMap";
 import { ModUpgraded } from "../classes/ModUpgraded";
 import { DecorationVariant } from "../enums/DecorationVariant";
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { spawnNPC } from "../functions/entitiesSpecific";
+import { hasFlag } from "../functions/flag";
 import {
   removeGridEntity,
   spawnGridEntityWithVariant,
@@ -33,6 +38,7 @@ const v = {
   },
 
   room: {
+    dummyPtrHashes: new Set<PtrHash>(),
     manuallyUsingShovel: false,
   },
 };
@@ -41,6 +47,12 @@ const v = {
 export function customGridEntityInit(mod: ModUpgraded): void {
   saveDataManager(FEATURE_NAME, v);
 
+  mod.AddCallback(
+    ModCallback.ENTITY_TAKE_DMG,
+    entityTakeDmgDummy,
+    EntityType.DUMMY,
+  ); // 11
+
   mod.AddCallback(
     ModCallback.PRE_USE_ITEM,
     preUseItemWeNeedToGoDeeper,
@@ -53,6 +65,51 @@ export function customGridEntityInit(mod: ModUpgraded): void {
   );
 }
 
+// ModCallback.ENTITY_TAKE_DMG (11)
+// EntityType.DUMMY (964)
+function entityTakeDmgDummy(
+  tookDamage: Entity,
+  _damageAmount: float,
+  damageFlags: BitFlags<DamageFlag>,
+  _damageSource: EntityRef,
+  _damageCountdownFrames: int,
+): boolean | undefined {
+  const ptrHash = GetPtrHash(tookDamage);
+  if (!v.room.dummyPtrHashes.has(ptrHash)) {
+    return undefined;
+  }
+
+  if (!hasFlag(damageFlags, DamageFlag.EXPLOSION)) {
+    return false;
+  }
+
+  const room = game.GetRoom();
+  const roomListIndex = getRoomListIndex();
+  const roomCustomGridEntities = v.level.customGridEntities.get(roomListIndex);
+  if (roomCustomGridEntities === undefined) {
+    return false;
+  }
+
+  const gridIndex = room.GetGridIndex(tookDamage.Position);
+  const data = roomCustomGridEntities.get(gridIndex);
+  if (data === undefined) {
+    return false;
+  }
+
+  const gridEntity = room.GetGridEntity(gridIndex);
+  if (gridEntity === undefined) {
+    error(
+      `Failed to get the grid entity for a custom grid entity that broke at grid index: ${gridIndex}`,
+    );
+  }
+
+  postGridEntityCustomBrokenFire(gridEntity, data.gridEntityTypeCustom);
+
+  // Even though the custom grid entity is now broke, we do not want to remove it, as the end-user
+  // could intend for it to persist with different graphics.
+  return false;
+}
+
 // ModCallback.PRE_USE_ITEM (23)
 // CollectibleType.WE_NEED_TO_GO_DEEPER (84)
 function preUseItemWeNeedToGoDeeper(
@@ -161,6 +218,10 @@ function postNewRoomReordered() {
  * @param defaultAnimation Optional. The name of the animation to play after the sprite is
  *                         initialized and after the player re-enters a room with this grid entity
  *                         in it. If not specified, the default animation in the anm2 will be used.
+ * @param breakable Optional. Whether or not an explosion will be able to break this grid entity.
+ *                  False by default. Use the `POST_GRID_ENTITY_CUSTOM_BROKEN` callback to detect
+ *                  when it breaks. Due to technical limitations, you can only set the grid entity
+ *                  to be breakable if it has a collision class.
  */
 export function spawnCustomGridEntity(
   gridEntityTypeCustom: GridEntityType,
@@ -168,9 +229,16 @@ export function spawnCustomGridEntity(
   gridCollisionClass: GridCollisionClass,
   anm2Path: string,
   defaultAnimation?: string,
+  breakable = false,
 ): GridEntity {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
 
+  if (breakable && gridCollisionClass === GridCollisionClass.NONE) {
+    error(
+      "Failed to spawn a custom grid entity because it is not possible to have breakable custom grid entities with a collision class of: GridCollisionClass.NONE (0)",
+    );
+  }
+
   const room = game.GetRoom();
   const roomListIndex = getRoomListIndex();
   const gridIndex = isVector(gridIndexOrPosition)
@@ -215,6 +283,14 @@ export function spawnCustomGridEntity(
     v.level.customGridEntities.getAndSetDefault(roomListIndex);
   roomCustomGridEntities.set(gridIndex, customGridEntityData);
 
+  // We check to see if an explosion touches a custom grid entity by spawning a Dummy on top, and
+  // the monitoring for explosions in the `ENTITY_TAKE_DMG` callback.
+  if (breakable) {
+    const position = room.GetGridPosition(gridIndex);
+    const dummy = spawnNPC(EntityType.DUMMY, 0, 0, position);
+    dummy.Visible = false;
+  }
+
   return decoration;
 }
 

package/src/functions/color.ts

@@ -1,21 +1,14 @@
 import { SerializationBrand } from "../enums/private/SerializationBrand";
-import { SerializationType } from "../enums/SerializationType";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandom } from "./random";
 import { getRandomSeed, isRNG, newRNG } from "./rng";
 import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedColor = LuaMap<string, unknown> & {
+export type SerializedColor = LuaMap<string, unknown> & {
   readonly __serializedColorBrand: symbol;
 };
 
-interface CopyColorReturn {
-  [SerializationType.NONE]: Color;
-  [SerializationType.SERIALIZE]: SerializedColor;
-  [SerializationType.DESERIALIZE]: Color;
-}
-
 const KEYS = ["R", "G", "B", "A", "RO", "GO", "BO"];
 const OBJECT_NAME = "Color";
 
@@ -23,88 +16,59 @@ export function colorEquals(color1: Color, color2: Color): boolean {
   return isaacAPIClassEquals(color1, color2, KEYS);
 }
 
+/** Helper function to copy a `Color` Isaac API class. */
+export function copyColor(color: Color): Color {
+  if (!isColor(color)) {
+    error(
+      `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  return Color(
+    color.R,
+    color.G,
+    color.B,
+    color.A,
+    color.RO,
+    color.GO,
+    color.BO,
+  );
+}
+
 /**
- * Helper function to copy a `Color` object.
- *
- * @param color The Color object to copy. In the case of deserialization, this will actually be a
- *              Lua table instead of an instantiated Color class.
- * @param serializationType Default is `SerializationType.NONE`.
+ * Helper function to convert a `SerializedColor` object to a normal `Color` object. (This is used
+ * by the save data manager when reading data from the "save#.dat" file.)
  */
-export function copyColor<
-  C extends Color | SerializedColor,
-  S extends SerializationType,
->(color: C, serializationType: S): CopyColorReturn[S];
-export function copyColor<C extends Color | SerializedColor>(
-  color: C,
-): CopyColorReturn[SerializationType.NONE];
-export function copyColor(
-  color: Color | SerializedColor,
-  serializationType = SerializationType.NONE,
-): CopyColorReturn[keyof CopyColorReturn] {
-  switch (serializationType) {
-    case SerializationType.NONE: {
-      if (!isColor(color)) {
-        error(
-          `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      return Color(
-        color.R,
-        color.G,
-        color.B,
-        color.A,
-        color.RO,
-        color.GO,
-        color.BO,
-      );
-    }
-
-    case SerializationType.SERIALIZE: {
-      if (!isColor(color)) {
-        error(
-          `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      const colorTable = new LuaMap<string, unknown>();
-      copyValuesToTable(color, KEYS, colorTable);
-      colorTable.set(SerializationBrand.COLOR, "");
-      return colorTable as SerializedColor;
-    }
-
-    case SerializationType.DESERIALIZE: {
-      if (!isTable(color)) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
-        );
-      }
-
-      const [r, g, b, a, ro, go, bo] = getNumbersFromTable(
-        color as LuaMap<string, unknown>,
-        OBJECT_NAME,
-        ...KEYS,
-      );
-
-      if (r === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: r`,
-        );
-      }
-      if (g === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: g`,
-        );
-      }
-      if (b === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: b`,
-        );
-      }
-
-      return Color(r, g, b, a, ro, go, bo);
-    }
+export function deserializeColor(color: SerializedColor): Color {
+  if (!isTable(color)) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
+    );
+  }
+
+  const [r, g, b, a, ro, go, bo] = getNumbersFromTable(
+    color as LuaMap<string, unknown>,
+    OBJECT_NAME,
+    ...KEYS,
+  );
+
+  if (r === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: R`,
+    );
+  }
+  if (g === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: G`,
+    );
+  }
+  if (b === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: B`,
+    );
   }
+
+  return Color(r, g, b, a, ro, go, bo);
 }
 
 /**
@@ -143,3 +107,19 @@ export function isSerializedColor(object: unknown): object is SerializedColor {
 
   return tableHasKeys(object, ...KEYS) && object.has(SerializationBrand.COLOR);
 }
+/**
+ * Helper function to convert a `Color` object to a `SerializedColor` object. (This is used by the
+ * save data manager when writing data from the "save#.dat" file.)
+ */
+export function serializeColor(color: Color): SerializedColor {
+  if (!isColor(color)) {
+    error(
+      `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  const colorTable = new LuaMap<string, unknown>();
+  copyValuesToTable(color, KEYS, colorTable);
+  colorTable.set(SerializationBrand.COLOR, "");
+  return colorTable as SerializedColor;
+}

package/src/functions/deepCopy.ts

@@ -4,7 +4,7 @@ import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { SerializationType } from "../enums/SerializationType";
 import { SAVE_DATA_MANAGER_DEBUG } from "../features/saveDataManager/saveDataManagerConstants";
 import { isSerializationBrand } from "../features/saveDataManager/serializationBrands";
-import { TSTLClass } from "../types/private/TSTLClass";
+import { TSTLClass } from "../types/TSTLClass";
 import { isArray } from "./array";
 import { getEnumValues } from "./enums";
 import { getIsaacAPIClassName } from "./isaacAPIClass";
@@ -13,6 +13,7 @@ import {
   copyIsaacAPIClass,
   deserializeIsaacAPIClass,
   isSerializedIsaacAPIClass,
+  serializeIsaacAPIClass,
 } from "./serialization";
 import {
   getTSTLClassName,
@@ -664,5 +665,17 @@ function deepCopyUserdata(
     );
   }
 
-  return copyIsaacAPIClass(value, serializationType);
+  switch (serializationType) {
+    case SerializationType.NONE: {
+      return copyIsaacAPIClass(value);
+    }
+
+    case SerializationType.SERIALIZE: {
+      return serializeIsaacAPIClass(value);
+    }
+
+    case SerializationType.DESERIALIZE: {
+      return deserializeIsaacAPIClass(value);
+    }
+  }
 }

package/src/functions/gridEntities.ts

@@ -9,14 +9,12 @@ import {
 } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
 import { DISTANCE_OF_GRID_TILE } from "../constants";
-import { RockAltType } from "../enums/RockAltType";
 import { GRID_ENTITY_TYPE_TO_BROKEN_STATE_MAP } from "../maps/gridEntityTypeToBrokenStateMap";
 import { GRID_ENTITY_XML_MAP } from "../maps/gridEntityXMLMap";
 import {
   DEFAULT_TOP_LEFT_WALL_GRID_INDEX,
   ROOM_SHAPE_TO_TOP_LEFT_WALL_GRID_INDEX_MAP,
 } from "../maps/roomShapeToTopLeftWallGridIndexMap";
-import { BACKDROP_TYPE_TO_ROCK_ALT_TYPE } from "../objects/backdropTypeToRockAltType";
 import { AnyGridEntity } from "../types/AnyGridEntity";
 import { isCircleIntersectingRectangle } from "./math";
 import { roomUpdateSafe } from "./rooms";
@@ -276,27 +274,6 @@ export function getMatchingGridEntities(
   );
 }
 
-/**
- * Helper function to get the alternate rock type (i.e. urn, mushroom, etc.) that the current room
- * will have.
- *
- * The rock type is based on the backdrop of the room.
- *
- * For example, if you change the backdrop of the starting room of the run to `BackdropType.CAVES`,
- * and then spawn `GridEntityType.ROCK_ALT`, it will be a mushroom instead of an urn. Additionally,
- * if it is destroyed, it will generate mushroom-appropriate rewards.
- *
- * On the other hand, if an urn is spawned first before the backdrop is changed to
- * `BackdropType.CAVES`, the graphic of the urn will not switch to a mushroom. However, when
- * destroyed, the urn will still generate mushroom-appropriate rewards.
- */
-export function getRockAltType(): RockAltType {
-  const room = game.GetRoom();
-  const backdropType = room.GetBackdropType();
-
-  return BACKDROP_TYPE_TO_ROCK_ALT_TYPE[backdropType];
-}
-
 export function getSurroundingGridEntities(
   gridEntity: GridEntity,
 ): GridEntity[] {

package/src/functions/isaacAPIClass.ts

@@ -1,4 +1,4 @@
-import { IsaacAPIClass } from "../types/private/IsaacAPIClass";
+import { IsaacAPIClass } from "../types/IsaacAPIClass";
 import { trimPrefix } from "./string";
 import { isString, isUserdata } from "./types";
 

package/src/functions/kColor.ts

@@ -1,103 +1,67 @@
 import { SerializationBrand } from "../enums/private/SerializationBrand";
-import { SerializationType } from "../enums/SerializationType";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandom } from "./random";
 import { getRandomSeed, isRNG, newRNG } from "./rng";
 import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedKColor = LuaMap<string, unknown> & {
+export type SerializedKColor = LuaMap<string, unknown> & {
   readonly __serializedKColorBrand: symbol;
 };
 
-interface CopyKColorReturn {
-  [SerializationType.NONE]: KColor;
-  [SerializationType.SERIALIZE]: SerializedKColor;
-  [SerializationType.DESERIALIZE]: KColor;
-}
-
 const KEYS = ["Red", "Green", "Blue", "Alpha"];
 const OBJECT_NAME = "KColor";
 
+/** Helper function to copy a `KColor` Isaac API class. */
+export function copyKColor(kColor: KColor): KColor {
+  if (!isKColor(kColor)) {
+    error(
+      `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  return KColor(kColor.Red, kColor.Green, kColor.Blue, kColor.Alpha);
+}
+
 /**
- * Helper function to copy a `KColor` object.
- *
- * @param kColor The KColor object to copy. In the case of deserialization, this will actually be a
- *               Lua table instead of an instantiated KColor class.
- * @param serializationType Default is `SerializationType.NONE`.
+ * Helper function to convert a `SerializedKColor` object to a normal `KColor` object. (This is used
+ * by the save data manager when reading data from the "save#.dat" file.)
  */
-export function copyKColor<
-  K extends KColor | SerializedKColor,
-  S extends SerializationType,
->(kColor: K, serializationType: S): CopyKColorReturn[S];
-export function copyKColor<K extends KColor | SerializedKColor>(
-  kColor: K,
-): CopyKColorReturn[SerializationType.NONE];
-export function copyKColor(
-  kColor: KColor | SerializedKColor,
-  serializationType = SerializationType.NONE,
-): CopyKColorReturn[keyof CopyKColorReturn] {
-  switch (serializationType) {
-    case SerializationType.NONE: {
-      if (!isKColor(kColor)) {
-        error(
-          `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      return KColor(kColor.Red, kColor.Green, kColor.Blue, kColor.Alpha);
-    }
-
-    case SerializationType.SERIALIZE: {
-      if (!isKColor(kColor)) {
-        error(
-          `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      const kColorTable = new LuaMap<string, unknown>();
-      copyValuesToTable(kColor, KEYS, kColorTable);
-      kColorTable.set(SerializationBrand.K_COLOR, "");
-      return kColorTable as SerializedKColor;
-    }
-
-    case SerializationType.DESERIALIZE: {
-      if (!isTable(kColor)) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
-        );
-      }
-
-      const [r, g, b, a] = getNumbersFromTable(
-        kColor as LuaMap<string, unknown>,
-        OBJECT_NAME,
-        ...KEYS,
-      );
-
-      if (r === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: r`,
-        );
-      }
-      if (g === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: g`,
-        );
-      }
-      if (b === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: b`,
-        );
-      }
-      if (a === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: a`,
-        );
-      }
-
-      return KColor(r, g, b, a);
-    }
+export function deserializeKColor(kColor: SerializedKColor): KColor {
+  if (!isTable(kColor)) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
+    );
+  }
+
+  const [r, g, b, a] = getNumbersFromTable(
+    kColor as LuaMap<string, unknown>,
+    OBJECT_NAME,
+    ...KEYS,
+  );
+
+  if (r === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: Red`,
+    );
   }
+  if (g === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: Green`,
+    );
+  }
+  if (b === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: Blue`,
+    );
+  }
+  if (a === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: Alpha`,
+    );
+  }
+
+  return KColor(r, g, b, a);
 }
 
 /**
@@ -144,3 +108,20 @@ export function isSerializedKColor(
 export function kColorEquals(kColor1: KColor, kColor2: KColor): boolean {
   return isaacAPIClassEquals(kColor1, kColor2, KEYS);
 }
+
+/**
+ * Helper function to convert a `KColor` object to a `SerializedKColor` object. (This is used by the
+ * save data manager when writing data from the "save#.dat" file.)
+ */
+export function serializeKColor(kColor: KColor): SerializedKColor {
+  if (!isKColor(kColor)) {
+    error(
+      `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  const kColorTable = new LuaMap<string, unknown>();
+  copyValuesToTable(kColor, KEYS, kColorTable);
+  kColorTable.set(SerializationBrand.K_COLOR, "");
+  return kColorTable as SerializedKColor;
+}

package/src/functions/mergeTests.ts

@@ -5,7 +5,7 @@ import { deepCopy } from "./deepCopy";
 import { log } from "./log";
 import { isRNG, newRNG } from "./rng";
 import { isSerializedIsaacAPIClass } from "./serialization";
-import { copyVector, isVector } from "./vector";
+import { isVector, serializeVector } from "./vector";
 
 /**
  * Run the suite of tests that prove that the "merge" function works properly. (This function is not
@@ -92,7 +92,7 @@ function oldTableHasSerializedIsaacAPIClass() {
   const y = 60;
   const vector = Vector(x, y);
 
-  const vectorSerialized = copyVector(vector, SerializationType.SERIALIZE);
+  const vectorSerialized = serializeVector(vector);
   if (!isSerializedIsaacAPIClass(vectorSerialized)) {
     error(
       'The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.',