isaacscript-common 6.14.0 → 6.16.1

package/dist/types/TSTLClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSTLClass.d.ts","sourceRoot":"","sources":["../../src/types/TSTLClass.ts"],"names":[],"mappings":";AAAA,oBAAY,SAAS,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG;IACnD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "6.14.0",
+  "version": "6.16.1",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",
@@ -22,6 +22,6 @@
   "main": "dist/index",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "isaac-typescript-definitions": "^3.0.35"
+    "isaac-typescript-definitions": "^3.1.0"
   }
 }

package/src/callbacks/postGridEntityCustomCollision.ts

@@ -0,0 +1,74 @@
+import { GridCollisionClass, ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { getCustomGridEntities } from "../features/customGridEntity";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getCollidingEntitiesWithGridEntity } from "../functions/gridEntities";
+import {
+  postGridEntityCustomCollisionFire,
+  postGridEntityCustomCollisionHasSubscriptions,
+} from "./subscriptions/postGridEntityCustomCollision";
+
+const v = {
+  room: {
+    /** Indexed by grid entity pointer hash. */
+    collidingEntitiesMap: new DefaultMap<PtrHash, Set<PtrHash>>(
+      () => new Set(),
+    ),
+  },
+};
+
+/** @internal */
+export function postGridEntityCustomCollisionInit(mod: ModUpgraded): void {
+  saveDataManager("postGridEntityCustomCollisionInit", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postGridEntityCustomCollisionHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const customGridEntities = getCustomGridEntities();
+  for (const [gridEntity, data] of customGridEntities) {
+    if (gridEntity.CollisionClass === GridCollisionClass.NONE) {
+      continue;
+    }
+
+    // The following code is copied from the `POST_GRID_ENTITY_COLLISION` callback.
+    const gridEntityPtrHash = GetPtrHash(gridEntity);
+    const oldCollidingEntities =
+      v.room.collidingEntitiesMap.getAndSetDefault(gridEntityPtrHash);
+
+    // Check for new colliding entities.
+    const collidingEntities = getCollidingEntitiesWithGridEntity(gridEntity);
+    for (const entity of collidingEntities) {
+      const entityPtrHash = GetPtrHash(entity);
+      if (!oldCollidingEntities.has(entityPtrHash)) {
+        oldCollidingEntities.add(entityPtrHash);
+        postGridEntityCustomCollisionFire(
+          gridEntity,
+          data.gridEntityTypeCustom,
+          entity,
+        );
+      }
+    }
+
+    // Remove old colliding entities.
+    const collidingEntitiesPtrHashes = collidingEntities.map((entity) =>
+      GetPtrHash(entity),
+    );
+    const collidingEntitiesPtrHashSet = new Set(collidingEntitiesPtrHashes);
+    for (const oldCollidingEntityPtrHash of oldCollidingEntities.values()) {
+      if (!collidingEntitiesPtrHashSet.has(oldCollidingEntityPtrHash)) {
+        oldCollidingEntities.delete(oldCollidingEntityPtrHash);
+      }
+    }
+  }
+}

package/src/callbacks/postGridEntityCustomRender.ts

@@ -1,29 +1,13 @@
-import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
+import { ModCallback } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../classes/ModUpgraded";
 import { getCustomGridEntities } from "../features/customGridEntity";
-import { saveDataManager } from "../features/saveDataManager/exports";
 import {
   postGridEntityCustomRenderFire,
   postGridEntityCustomRenderHasSubscriptions,
 } from "./subscriptions/postGridEntityCustomRender";
 
-type GridEntityTuple = [
-  gridEntityType: GridEntityType,
-  gridEntityVariant: int,
-  state: int,
-];
-
-const v = {
-  room: {
-    /** Indexed by grid index. */
-    initializedGridEntities: new Map<int, GridEntityTuple>(),
-  },
-};
-
 /** @internal */
 export function postGridEntityCustomRenderInit(mod: ModUpgraded): void {
-  saveDataManager("postGridEntityCustomRender", v, hasSubscriptions);
-
   mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
 }
 

package/src/callbacks/postGridEntityCustomUpdate.ts

@@ -1,29 +1,13 @@
-import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
+import { ModCallback } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../classes/ModUpgraded";
 import { getCustomGridEntities } from "../features/customGridEntity";
-import { saveDataManager } from "../features/saveDataManager/exports";
 import {
   postGridEntityCustomUpdateFire,
   postGridEntityCustomUpdateHasSubscriptions,
 } from "./subscriptions/postGridEntityCustomUpdate";
 
-type GridEntityTuple = [
-  gridEntityType: GridEntityType,
-  gridEntityVariant: int,
-  state: int,
-];
-
-const v = {
-  room: {
-    /** Indexed by grid index. */
-    initializedGridEntities: new Map<int, GridEntityTuple>(),
-  },
-};
-
 /** @internal */
 export function postGridEntityCustomUpdateInit(mod: ModUpgraded): void {
-  saveDataManager("postGridEntityCustomUpdate", v, hasSubscriptions);
-
   mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
 }
 

package/src/callbacks/subscriptions/postGridEntityCustomBroken.ts

@@ -0,0 +1,36 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export type PostGridEntityCustomBrokenRegisterParameters = [
+  callback: (
+    gridEntity: GridEntity,
+    gridEntityTypeCustom: GridEntityType,
+  ) => void,
+  gridEntityTypeCustom?: GridEntityType,
+];
+
+const subscriptions: PostGridEntityCustomBrokenRegisterParameters[] = [];
+
+/** @internal */
+export function postGridEntityCustomBrokenRegister(
+  ...args: PostGridEntityCustomBrokenRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postGridEntityCustomBrokenFire(
+  gridEntity: GridEntity,
+  gridEntityTypeCustom: GridEntityType,
+): void {
+  for (const [callback, callbackGridEntityTypeCustom] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityTypeCustom !== undefined &&
+      callbackGridEntityTypeCustom !== gridEntityTypeCustom
+    ) {
+      continue;
+    }
+
+    callback(gridEntity, gridEntityTypeCustom);
+  }
+}

package/src/callbacks/subscriptions/postGridEntityCustomCollision.ts

@@ -0,0 +1,43 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export type PostGridEntityCustomCollisionRegisterParameters = [
+  callback: (
+    gridEntity: GridEntity,
+    gridEntityTypeCustom: GridEntityType,
+    entity: Entity,
+  ) => void,
+  gridEntityTypeCustom?: GridEntityType,
+];
+
+const subscriptions: PostGridEntityCustomCollisionRegisterParameters[] = [];
+
+/** @internal */
+export function postGridEntityCustomCollisionHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postGridEntityCustomCollisionRegister(
+  ...args: PostGridEntityCustomCollisionRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postGridEntityCustomCollisionFire(
+  gridEntity: GridEntity,
+  gridEntityTypeCustom: GridEntityType,
+  entity: Entity,
+): void {
+  for (const [callback, callbackGridEntityTypeCustom] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityTypeCustom !== undefined &&
+      callbackGridEntityTypeCustom !== gridEntityTypeCustom
+    ) {
+      continue;
+    }
+
+    callback(gridEntity, gridEntityTypeCustom, entity);
+  }
+}

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/collectibles.ts

@@ -323,6 +323,10 @@ export function getCollectibleName(collectibleType: CollectibleType): string {
   return DEFAULT_COLLECTIBLE_NAME;
 }
 
+/**
+ * Helper function to get the "pedestal type" of a collectible. For example, it might be sitting on
+ * top of a broken Blood Donation Machine, or it might be sitting on top of an opened Spiked Chest.
+ */
 export function getCollectiblePedestalType(
   collectible: EntityPickup,
 ): CollectiblePedestalType {
@@ -338,8 +342,8 @@ export function getCollectiblePedestalType(
 }
 
 /**
- * Helper function to get the path to a collectible's quality. Returns 0 if the provided collectible
- * type was not valid.
+ * Helper function to get a collectible's quality. For example, Mom's Knife has a quality of 4.
+ * Returns 0 if the provided collectible type was not valid.
  */
 export function getCollectibleQuality(collectibleType: CollectibleType): int {
   const itemConfigItem = itemConfig.GetCollectible(collectibleType);

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);
+    }
+  }
 }