isaacscript-common 14.1.2 → 14.2.0

package/src/features.ts

@@ -5,9 +5,15 @@ import { EsauJrDetection } from "./classes/features/callbackLogic/EsauJrDetectio
 import { FlipDetection } from "./classes/features/callbackLogic/FlipDetection";
 import { GameReorderedCallbacks } from "./classes/features/callbackLogic/GameReorderedCallbacks";
 import { GridEntityCollisionDetection } from "./classes/features/callbackLogic/GridEntityCollisionDetection";
-import { GridEntityDetection } from "./classes/features/callbackLogic/GridEntityDetection";
+import { GridEntityRenderDetection } from "./classes/features/callbackLogic/GridEntityRenderDetection";
+import { GridEntityUpdateDetection } from "./classes/features/callbackLogic/GridEntityUpdateDetection";
+import { ItemPickupDetection } from "./classes/features/callbackLogic/ItemPickupDetection";
+import { PlayerCollectibleDetection } from "./classes/features/callbackLogic/PlayerCollectibleDetection";
 import { PlayerReorderedCallbacks } from "./classes/features/callbackLogic/PlayerReorderedCallbacks";
+import { SlotRenderDetection } from "./classes/features/callbackLogic/SlotRenderDetection";
+import { SlotUpdateDetection } from "./classes/features/callbackLogic/SlotUpdateDetection";
 import { RunInNFrames } from "./classes/features/other/RunInNFrames";
+import { SaveDataManager } from "./classes/features/other/SaveDataManager";
 import { ISCFeature } from "./enums/ISCFeature";
 import { ModCallbackCustom2 } from "./enums/ModCallbackCustom2";
 import {
@@ -21,19 +27,25 @@ export interface ISCFeatureToClass {
   [ISCFeature.ESAU_JR_DETECTION]: EsauJrDetection;
   [ISCFeature.FLIP_DETECTION]: FlipDetection;
   [ISCFeature.GRID_ENTITY_COLLISION_DETECTION]: GridEntityCollisionDetection;
-  [ISCFeature.GRID_ENTITY_DETECTION]: GridEntityDetection;
+  [ISCFeature.GRID_ENTITY_RENDER_DETECTION]: GridEntityRenderDetection;
+  [ISCFeature.GRID_ENTITY_UPDATE_DETECTION]: GridEntityUpdateDetection;
   [ISCFeature.GAME_REORDERED_CALLBACKS]: GameReorderedCallbacks;
+  [ISCFeature.ITEM_PICKUP_DETECTION]: ItemPickupDetection;
+  [ISCFeature.PLAYER_COLLECTIBLE_DETECTION]: PlayerCollectibleDetection;
   [ISCFeature.PLAYER_REORDERED_CALLBACKS]: PlayerReorderedCallbacks;
+  [ISCFeature.SLOT_RENDER_DETECTION]: SlotRenderDetection;
+  [ISCFeature.SLOT_UPDATE_DETECTION]: SlotUpdateDetection;
 
   // Extra features
   [ISCFeature.CUSTOM_GRID_ENTITIES]: CustomGridEntities;
   [ISCFeature.RUN_IN_N_FRAMES]: RunInNFrames;
+  [ISCFeature.SAVE_DATA_MANAGER]: SaveDataManager;
 }
 
 validateInterfaceMatchesEnum<ISCFeatureToClass, ISCFeature>();
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function getFeatures(callbacks: ModCallbackCustomToClass) {
+export function getFeatures(mod: Mod, callbacks: ModCallbackCustomToClass) {
   // Some features rely on other features; we must initialize those first.
   const runInNFrames = new RunInNFrames();
   const customGridEntities = new CustomGridEntities(runInNFrames);
@@ -58,7 +70,7 @@ export function getFeatures(callbacks: ModCallbackCustomToClass) {
         callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_COLLISION],
         customGridEntities,
       ),
-    [ISCFeature.GRID_ENTITY_DETECTION]: new GridEntityDetection(
+    [ISCFeature.GRID_ENTITY_UPDATE_DETECTION]: new GridEntityUpdateDetection(
       callbacks[ModCallbackCustom2.POST_GRID_ENTITY_INIT],
       callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_INIT],
       callbacks[ModCallbackCustom2.POST_GRID_ENTITY_UPDATE],
@@ -71,20 +83,43 @@ export function getFeatures(callbacks: ModCallbackCustomToClass) {
       callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_BROKEN],
       customGridEntities,
     ),
+    [ISCFeature.GRID_ENTITY_RENDER_DETECTION]: new GridEntityRenderDetection(
+      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_RENDER],
+      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_RENDER],
+      customGridEntities,
+    ),
     [ISCFeature.GAME_REORDERED_CALLBACKS]: new GameReorderedCallbacks(
       callbacks[ModCallbackCustom2.POST_GAME_STARTED_REORDERED],
       callbacks[ModCallbackCustom2.POST_NEW_LEVEL_REORDERED],
       callbacks[ModCallbackCustom2.POST_NEW_ROOM_REORDERED],
       callbacks[ModCallbackCustom2.POST_GAME_STARTED_REORDERED_LAST],
     ),
+    [ISCFeature.ITEM_PICKUP_DETECTION]: new ItemPickupDetection(
+      callbacks[ModCallbackCustom2.POST_ITEM_PICKUP],
+      callbacks[ModCallbackCustom2.PRE_ITEM_PICKUP],
+    ),
+    [ISCFeature.PLAYER_COLLECTIBLE_DETECTION]: new PlayerCollectibleDetection(
+      callbacks[ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_ADDED],
+      callbacks[ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_REMOVED],
+      runInNFrames,
+    ),
     [ISCFeature.PLAYER_REORDERED_CALLBACKS]: new PlayerReorderedCallbacks(
       callbacks[ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED],
       callbacks[ModCallbackCustom2.POST_PLAYER_RENDER_REORDERED],
       callbacks[ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED],
     ),
+    [ISCFeature.SLOT_RENDER_DETECTION]: new SlotRenderDetection(
+      callbacks[ModCallbackCustom2.POST_SLOT_RENDER],
+      callbacks[ModCallbackCustom2.POST_SLOT_ANIMATION_CHANGED],
+    ),
+    [ISCFeature.SLOT_UPDATE_DETECTION]: new SlotUpdateDetection(
+      callbacks[ModCallbackCustom2.POST_SLOT_INIT],
+      callbacks[ModCallbackCustom2.POST_SLOT_UPDATE],
+    ),
 
     // Extra features
     [ISCFeature.CUSTOM_GRID_ENTITIES]: customGridEntities,
     [ISCFeature.RUN_IN_N_FRAMES]: runInNFrames,
+    [ISCFeature.SAVE_DATA_MANAGER]: new SaveDataManager(mod),
   } as const);
 }

package/src/functions/array.ts

@@ -418,21 +418,20 @@ export function isArray(object: unknown): object is unknown[] {
     return false;
   }
 
-  // Second, handle the case of non-numerical keys.
+  // Second, handle the case of an "empty" table.
   const keys = Object.keys(object);
+  if (keys.length === 0) {
+    return true;
+  }
+
+  // Third, handle the case of non-numerical keys.
   const hasAllNumberKeys = keys.every((key) => isNumber(key));
   if (!hasAllNumberKeys) {
     return false;
   }
 
-  // Third, handle the case of an "empty" table.
-  const tableLength = Object.keys(object).length;
-  if (tableLength === 0) {
-    return true;
-  }
-
-  // Third, check for non-contiguous elements. (Lua tables start at an index of 1.)
-  for (let i = 1; i <= tableLength; i++) {
+  // Fourth, check for non-contiguous elements. (Lua tables start at an index of 1.)
+  for (let i = 1; i <= keys.length; i++) {
     const element = object.get(i);
     if (element === undefined) {
       return false;

package/src/functions/bitSet128.ts

@@ -1,5 +1,5 @@
 import { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
-import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { SerializationBrand } from "../enums/SerializationBrand";
 import { isIsaacAPIClassOfType } from "./isaacAPIClass";
 import {
   copyUserdataValuesToTable,
@@ -65,8 +65,8 @@ export function isBitSet128(object: unknown): object is BitSet128 {
 }
 
 /**
- * Used to determine is the given table is a serialized `BitSet128` object created by the save data
- * manager and/or the `deepCopy` function.
+ * Used to determine is the given table is a serialized `BitSet128` object created by the `deepCopy`
+ * function.
  */
 export function isSerializedBitSet128(
   object: unknown,

package/src/functions/color.ts

@@ -1,5 +1,5 @@
 import { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
-import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { SerializationBrand } from "../enums/SerializationBrand";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandom } from "./random";
 import { getRandomSeed, isRNG, newRNG } from "./rng";
@@ -103,8 +103,8 @@ export function isColor(object: unknown): object is Color {
 }
 
 /**
- * Used to determine is the given table is a serialized `Color` object created by the save data
- * manager and/or the `deepCopy` function.
+ * Used to determine is the given table is a serialized `Color` object created by the `deepCopy`
+ * function.
  */
 export function isSerializedColor(object: unknown): object is SerializedColor {
   if (!isTable(object)) {

package/src/functions/decorators.ts

@@ -1,13 +1,40 @@
+/**
+ * If you decide to structure your mod as a set of feature classes, you can use decorators to
+ * automatically register callbacks.
+ *
+ * Currently, there are two decorators:
+ * - @Callback
+ * - @CallbackCustom
+ *
+ * For example:
+ *
+ * ```ts
+ * export class MyFeature extends ModFeature {
+ *   @Callback(ModCallback.POST_GAME_STARTED)
+ *   postGameStarted(isContinued: boolean): void {
+ *     Isaac.DebugString(`Callback fired: POST_GAME_STARTED`);
+ *   }
+ * }
+ * ```
+ *
+ * @module
+ */
+
 import { ModCallback } from "isaac-typescript-definitions";
-import { ModFeature } from "../classes/ModFeature";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom2 } from "../enums/ModCallbackCustom2";
-import { AddCallbackParametersCustom2 } from "../interfaces/private/AddCallbackParametersCustom2";
+import {
+  ADD_CALLBACK_ARGS_KEY,
+  ADD_CALLBACK_CUSTOM_ARGS_KEY,
+  ModFeature,
+} from "../classes/ModFeature";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { AddCallbackParametersCustom } from "../interfaces/private/AddCallbackParametersCustom";
 import { AllButFirst } from "../types/AllButFirst";
 
 /**
  * A decorator function that signifies that the decorated class method should be automatically
  * registered with `Mod.AddCallback`.
+ *
+ * @ignore
  */
 export function Callback<T extends ModCallback>(
   modCallback: T,
@@ -18,28 +45,72 @@ export function Callback<T extends ModCallback>(
     propertyKey: string,
     _descriptor: TypedPropertyDescriptor<Fn>,
   ): void => {
+    // First, prepare the arguments for the `Mod.AddCallback` method.
     const methodName = propertyKey as keyof Class;
     const method = target[methodName] as AddCallbackParameters[T][0];
-    // @ts-expect-error The compiler is not smart enough to join the types together.
-    target.mod.AddCallback(modCallback, method, ...optionalArgs);
+    const addCallbackArgs = [
+      modCallback,
+      method,
+      ...optionalArgs,
+    ] as unknown as AddCallbackParameters[T];
+
+    // Since the decorator runs prior to instantiation, we only have access to get and set static
+    // properties, which are located on the "constructor" table. Thus, we store the callback
+    // arguments for later.
+    const constructor = target.constructor as unknown as LuaTable<
+      AnyNotNil,
+      unknown
+    >;
+    if (!constructor.has(ADD_CALLBACK_ARGS_KEY)) {
+      constructor.set(ADD_CALLBACK_ARGS_KEY, []);
+    }
+
+    const callbackTuples = constructor.get(ADD_CALLBACK_ARGS_KEY) as unknown[];
+    callbackTuples.push(addCallbackArgs);
   };
 }
 
 /**
  * A decorator function that signifies that the decorated class method should be automatically
  * registered with `ModUpgraded.AddCallbackCustom`.
+ *
+ * @ignore
  */
-export function CallbackCustom<T extends ModCallbackCustom2>(
+export function CallbackCustom<T extends ModCallbackCustom>(
   modCallbackCustom: T,
-  ...optionalArgs: AllButFirst<AddCallbackParametersCustom2[T]>
+  ...optionalArgs: AllButFirst<AddCallbackParametersCustom[T]>
 ) {
-  return <Class extends { mod: ModUpgraded }>(
+  return <
+    Class extends ModFeature,
+    Fn extends AddCallbackParametersCustom[T][0],
+  >(
     target: Class,
     propertyKey: string,
+    _descriptor: TypedPropertyDescriptor<Fn>,
   ): void => {
+    // First, prepare the arguments for the `Mod.AddCallbackCustom` method.
     const methodName = propertyKey as keyof Class;
-    const method = target[methodName] as AddCallbackParametersCustom2[T][0];
-    // @ts-expect-error The compiler is not smart enough to join the types together.
-    target.mod.AddCallbackCustom2(modCallbackCustom, method, ...optionalArgs);
+    const method = target[methodName] as AddCallbackParametersCustom[T][0];
+    const addCallbackArgs = [
+      modCallbackCustom,
+      method,
+      ...optionalArgs,
+    ] as unknown as AddCallbackParametersCustom[T];
+
+    // Since the decorator runs prior to instantiation, we only have access to get and set static
+    // properties, which are located on the "constructor" table. Thus, we store the callback
+    // arguments for later.
+    const constructor = target.constructor as unknown as LuaTable<
+      AnyNotNil,
+      unknown
+    >;
+    if (!constructor.has(ADD_CALLBACK_CUSTOM_ARGS_KEY)) {
+      constructor.set(ADD_CALLBACK_CUSTOM_ARGS_KEY, []);
+    }
+
+    const callbackTuples = constructor.get(
+      ADD_CALLBACK_CUSTOM_ARGS_KEY,
+    ) as unknown[];
+    callbackTuples.push(addCallbackArgs);
   };
 }

package/src/functions/deepCopy.ts

@@ -1,8 +1,8 @@
 import { DefaultMap } from "../classes/DefaultMap";
-import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { SerializationBrand } from "../enums/SerializationBrand";
 import { SerializationType } from "../enums/SerializationType";
 import { SAVE_DATA_MANAGER_DEBUG } from "../features/saveDataManager/constants";
-import { isSerializationBrand } from "../features/saveDataManager/serializationBrands";
+import { AnyClass } from "../types/AnyClass";
 import { TSTLClass } from "../types/TSTLClass";
 import { isArray } from "./array";
 import { getIsaacAPIClassName } from "./isaacAPIClass";
@@ -11,6 +11,7 @@ import {
   copyIsaacAPIClass,
   deserializeIsaacAPIClass,
   isCopyableIsaacAPIClass,
+  isSerializationBrand,
   isSerializedIsaacAPIClass,
   serializeIsaacAPIClass,
 } from "./serialization";
@@ -19,7 +20,6 @@ import {
   isDefaultMap,
   isTSTLMap,
   isTSTLSet,
-  isUserDefinedTSTLClass,
   newTSTLClass,
 } from "./tstlClass";
 import { asString, isNumber, isPrimitive } from "./types";
@@ -54,27 +54,37 @@ import { getTraversalDescription, twoDimensionalSort } from "./utils";
  * @param serializationType Optional. Has 3 possible values. Can copy objects as-is, or can
  *                          serialize objects to Lua tables, or can deserialize Lua tables to
  *                          objects. Default is `SerializationType.NONE`.
- * @param traversalDescription Optional. Used to track the current key that we are operating on.
- *                             Default is an empty string.
+ * @param traversalDescription Optional. Used to track the current key that we are operating on for
+ *                             debugging purposes. Default is an empty string.
+ * @param classConstructors Optional. A Lua table that maps the name of a user-defined TSTL class to
+ *                          its corresponding constructor. If the `deepCopy` function finds any
+ *                          user-defined TSTL classes when recursively iterating through the given
+ *                          object, it will use this map to instantiate a new class. Default is an
+ *                          empty Lua table.
  * @param insideMap Optional. Tracks whether or not the deep copy function is in the process of
  *                  recursively copying a TSTL Map. Default is false.
  */
 export function deepCopy<T>(
+  // An overload describing the trivial case of a normal copy. (T --> T)
   value: T,
   serializationType?: SerializationType.NONE,
   traversalDescription?: string,
+  classConstructors?: LuaMap<string, AnyClass>,
   insideMap?: boolean,
 ): T;
 export function deepCopy(
+  // An overload describing the serialization/deserialization case.
   value: unknown,
   serializationType: SerializationType,
   traversalDescription?: string,
+  classConstructors?: LuaMap<string, AnyClass>,
   insideMap?: boolean,
-): unknown; // The return types for serialization/deserialization are non-trivial, so we do not type them.
+): unknown; // The return types for serialization/deserialization are non-trivial, so we do not annotate them.
 export function deepCopy(
   value: unknown,
   serializationType = SerializationType.NONE,
   traversalDescription = "",
+  classConstructors = new LuaMap<string, AnyClass>(),
   insideMap = false,
 ): unknown {
   if (SAVE_DATA_MANAGER_DEBUG) {
@@ -123,6 +133,7 @@ export function deepCopy(
         luaMap,
         serializationType,
         traversalDescription,
+        classConstructors,
         insideMap,
       );
     }
@@ -137,6 +148,7 @@ function deepCopyTable(
   luaMap: LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ): unknown {
   // First, handle the cases of TSTL classes or serialized TSTL classes.
@@ -145,6 +157,7 @@ function deepCopyTable(
       luaMap,
       serializationType,
       traversalDescription,
+      classConstructors,
       insideMap,
     );
   }
@@ -154,6 +167,7 @@ function deepCopyTable(
       luaMap,
       serializationType,
       traversalDescription,
+      classConstructors,
       insideMap,
     );
   }
@@ -163,6 +177,7 @@ function deepCopyTable(
       luaMap,
       serializationType,
       traversalDescription,
+      classConstructors,
       insideMap,
     );
   }
@@ -181,11 +196,12 @@ function deepCopyTable(
     );
   }
 
-  if (isUserDefinedTSTLClass(luaMap)) {
+  if (className !== undefined || luaMap.has(SerializationBrand.TSTL_CLASS)) {
     return deepCopyTSTLClass(
-      luaMap,
+      luaMap as TSTLClass,
       serializationType,
       traversalDescription,
+      classConstructors,
       insideMap,
     );
   }
@@ -207,6 +223,7 @@ function deepCopyTable(
       luaMap,
       serializationType,
       traversalDescription,
+      classConstructors,
       insideMap,
     );
   }
@@ -216,6 +233,7 @@ function deepCopyTable(
     luaMap,
     serializationType,
     traversalDescription,
+    classConstructors,
     insideMap,
   );
 }
@@ -224,6 +242,7 @@ function deepCopyDefaultMap(
   defaultMap: DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ) {
   if (SAVE_DATA_MANAGER_DEBUG) {
@@ -258,6 +277,7 @@ function deepCopyDefaultMap(
         defaultMap,
         serializationType,
         traversalDescription,
+        classConstructors,
         insideMap,
       );
     }
@@ -275,6 +295,7 @@ function deepCopyDefaultMap(
     defaultMap,
     serializationType,
     traversalDescription,
+    classConstructors,
     insideMap,
   );
 
@@ -332,7 +353,7 @@ function getNewDefaultMap(
     case SerializationType.DESERIALIZE: {
       if (isDefaultMap(defaultMap)) {
         error(
-          `The deep copy function failed to deserialize a default map of "${traversalDescription}", since it was not a Lua table.`,
+          `Failed to deserialize a default map of "${traversalDescription}", since it was not a Lua table.`,
         );
       }
 
@@ -341,7 +362,7 @@ function getNewDefaultMap(
       );
       if (defaultMapValue === undefined) {
         error(
-          `The deep copy function failed to deserialize a default map of "${traversalDescription}", since there was no serialization brand of: ${SerializationBrand.DEFAULT_MAP_VALUE}`,
+          `Failed to deserialize a default map of "${traversalDescription}", since there was no serialization brand of: ${SerializationBrand.DEFAULT_MAP_VALUE}`,
         );
       }
 
@@ -355,6 +376,7 @@ function deepCopyMap(
   map: Map<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ) {
   if (SAVE_DATA_MANAGER_DEBUG) {
@@ -375,6 +397,7 @@ function deepCopyMap(
     map,
     serializationType,
     traversalDescription,
+    classConstructors,
     insideMap,
   );
 
@@ -407,6 +430,7 @@ function deepCopySet(
   set: Set<AnyNotNil> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ) {
   if (SAVE_DATA_MANAGER_DEBUG) {
@@ -427,6 +451,7 @@ function deepCopySet(
     set,
     serializationType,
     traversalDescription,
+    classConstructors,
     insideMap,
   );
 
@@ -460,6 +485,7 @@ function deepCopyTSTLClass(
   tstlClass: TSTLClass,
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ) {
   if (SAVE_DATA_MANAGER_DEBUG) {
@@ -467,19 +493,53 @@ function deepCopyTSTLClass(
   }
 
   let newClass: TSTLClass | LuaMap<AnyNotNil, unknown>;
-  if (serializationType === SerializationType.SERIALIZE) {
-    // Since we are serializing, the new object will be a Lua table.
-    newClass = new LuaMap<AnyNotNil, unknown>();
-    // (We do not brand it with the class type because we will not have the associated class
-    // constructor during deserialization, so knowing what type of class it is is pointless.)
-  } else {
-    newClass = newTSTLClass(tstlClass);
+  switch (serializationType) {
+    case SerializationType.NONE: {
+      // We can use the class constructor from the old class.
+      newClass = newTSTLClass(tstlClass);
+      break;
+    }
+
+    case SerializationType.SERIALIZE: {
+      newClass = new LuaMap<AnyNotNil, unknown>();
+
+      // We brand it with the name of the class so that we can run the corresponding constructor
+      // during deserialization.
+      const tstlClassName = getTSTLClassName(tstlClass);
+      if (tstlClassName !== undefined) {
+        newClass.set(SerializationBrand.TSTL_CLASS, tstlClassName);
+      }
+
+      break;
+    }
+
+    case SerializationType.DESERIALIZE: {
+      const tstlClassName = tstlClass.get(SerializationBrand.TSTL_CLASS) as
+        | string
+        | undefined;
+      if (tstlClassName === undefined) {
+        error(
+          "Failed to deserialize a TSTL class since the brand did not contain the class name.",
+        );
+      }
+
+      const classConstructor = classConstructors.get(tstlClassName);
+      if (classConstructor === undefined) {
+        error(
+          `Failed to deserialize a TSTL class since there was no constructor registered for a class name of "${tstlClassName}". If this mod is using the save data manager, it must register the class constructor with the "saveDataManagerRegisterClass" method.`,
+        );
+      }
+
+      // eslint-disable-next-line new-cap
+      newClass = new classConstructor() as TSTLClass;
+    }
   }
 
   const { entries, convertedNumberKeysToStrings } = getCopiedEntries(
     tstlClass,
     serializationType,
     traversalDescription,
+    classConstructors,
     insideMap,
   );
 
@@ -498,6 +558,7 @@ function deepCopyArray(
   array: unknown[],
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ) {
   if (SAVE_DATA_MANAGER_DEBUG) {
@@ -511,6 +572,7 @@ function deepCopyArray(
       value,
       serializationType,
       traversalDescription,
+      classConstructors,
       insideMap,
     );
     newArray.push(newValue);
@@ -523,6 +585,7 @@ function deepCopyNormalLuaTable(
   luaMap: LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ) {
   if (SAVE_DATA_MANAGER_DEBUG) {
@@ -534,6 +597,7 @@ function deepCopyNormalLuaTable(
     luaMap,
     serializationType,
     traversalDescription,
+    classConstructors,
     insideMap,
   );
 
@@ -556,6 +620,7 @@ function getCopiedEntries(
   object: unknown,
   serializationType: SerializationType,
   traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
   insideMap: boolean,
 ): {
   entries: Array<[key: AnyNotNil, value: unknown]>;
@@ -604,6 +669,7 @@ function getCopiedEntries(
       value,
       serializationType,
       traversalDescription,
+      classConstructors,
       insideMap,
     );
 

package/src/functions/deepCopyTests.ts

@@ -1,5 +1,5 @@
 import { DefaultMap } from "../classes/DefaultMap";
-import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { SerializationBrand } from "../enums/SerializationBrand";
 import { SerializationType } from "../enums/SerializationType";
 import { arrayEquals } from "./array";
 import { deepCopy } from "./deepCopy";

package/src/functions/initArray.ts

@@ -1,14 +1,13 @@
 import { deepCopy } from "./deepCopy";
-import { isPrimitive } from "./types";
 import { repeat } from "./utils";
 
 /**
  * Initializes an array with all of the elements containing the specified default value.
  *
- * If the provided default value is not a boolean, number, or string, then it will be copied with
- * the `deepCopy` function before adding it to the new array. In this way, you can initialize an
- * array of arrays, or an array of maps, and so on. (If the `deepCopy` function was not used, then
- * all of the array elements would just be references to the same underlying data structure.)
+ * The provided default value will be copied with the `deepCopy` function before adding it to the
+ * new array. Thus, you can initialize an array of arrays, or an array of maps, and so on. (If the
+ * `deepCopy` function was not used, then all of the array elements would just be references to the
+ * same underlying data structure.)
  *
  * For example:
  *
@@ -20,12 +19,8 @@ import { repeat } from "./utils";
 export function initArray<T>(defaultValue: T, size: int): T[] {
   const array: T[] = [];
   repeat(size, () => {
-    if (isPrimitive(defaultValue)) {
-      array.push(defaultValue);
-    } else {
-      const copy = deepCopy(defaultValue);
-      array.push(copy);
-    }
+    const copy = deepCopy(defaultValue);
+    array.push(copy);
   });
 
   return array;