isaacscript-common 6.22.4 → 7.1.0

package/src/functions/jsonRoom.ts

@@ -22,7 +22,7 @@ export function getJSONRoomDoorSlotFlags(
   const roomShapeNumber = tonumber(roomShapeString);
   if (roomShapeNumber === undefined) {
     error(
-      `Failed to parse the "shape" property of a JSON room: ${roomShapeString}`,
+      `Failed to parse the "shape" field of a JSON room: ${roomShapeString}`,
     );
   }
   const roomShape = roomShapeNumber as RoomShape;
@@ -33,7 +33,7 @@ export function getJSONRoomDoorSlotFlags(
     const existsString = door.$.exists;
     if (existsString !== "True" && existsString !== "False") {
       error(
-        `Failed to parse the "exists" property of a JSON room door: ${existsString}`,
+        `Failed to parse the "exists" field of a JSON room door: ${existsString}`,
       );
     }
 
@@ -44,13 +44,13 @@ export function getJSONRoomDoorSlotFlags(
     const xString = door.$.x;
     const x = tonumber(xString);
     if (x === undefined) {
-      error(`Failed to parse the "x" property of a JSON room door: ${xString}`);
+      error(`Failed to parse the "x" field of a JSON room door: ${xString}`);
     }
 
     const yString = door.$.y;
     const y = tonumber(yString);
     if (y === undefined) {
-      error(`Failed to parse the "y" property of a JSON room door: ${yString}`);
+      error(`Failed to parse the "y" field of a JSON room door: ${yString}`);
     }
 
     const doorSlot = getRoomShapeDoorSlot(roomShape, x, y);

package/src/functions/kColor.ts

@@ -9,8 +9,8 @@ export type SerializedKColor = LuaMap<string, unknown> & {
   readonly __serializedKColorBrand: symbol;
 };
 
-const KEYS = ["Red", "Green", "Blue", "Alpha"];
 const OBJECT_NAME = "KColor";
+const KEYS = ["Red", "Green", "Blue", "Alpha"];
 
 /** Helper function to copy a `KColor` Isaac API class. */
 export function copyKColor(kColor: KColor): KColor {
@@ -84,7 +84,7 @@ export function getRandomKColor(
   return KColor(r, g, b, alpha);
 }
 
-/** Helper function to check if something is an instantiated KColor object. */
+/** Helper function to check if something is an instantiated `KColor` object. */
 export function isKColor(object: unknown): object is KColor {
   return isIsaacAPIClassOfType(object, OBJECT_NAME);
 }

package/src/functions/log.ts

@@ -455,7 +455,7 @@ export function logUseFlags(
  * the Isaac API).
  */
 export function logUserdata(this: void, userdata: unknown): void {
-  if (isUserdata(userdata)) {
+  if (!isUserdata(userdata)) {
     log("Userdata: [not userdata]");
     return;
   }

package/src/functions/npcs.ts

@@ -108,8 +108,8 @@ export function isAliveExceptionNPC(npc: EntityNPC): boolean {
  * that is spawned when the boss does the multi-stomp attack.
  *
  * When this attack occurs, four extra copies of Daddy Long Legs will be spawned with the same
- * entity type, variant, and sub-type. The `Entity.Parent` property will be undefined in this case,
- * so the way to tell them apart is to check for a non-undefined `Entity.SpawnerEntity` property.
+ * entity type, variant, and sub-type. The `Entity.Parent` field will be undefined in this case, so
+ * the way to tell them apart is to check for a non-undefined `Entity.SpawnerEntity` field.
  */
 export function isDaddyLongLegsChildStompEntity(npc: EntityNPC): boolean {
   return (

package/src/functions/playerIndex.ts

@@ -198,7 +198,7 @@ export function getSubPlayerParent(
 
 /**
  * Helper function to detect if a particular player is a "child" player, meaning that they have a
- * non-undefined `EntityPlayer.Parent` property. (For example, the Strawman Keeper.)
+ * non-undefined `EntityPlayer.Parent` field. (For example, the Strawman Keeper.)
  */
 export function isChildPlayer(player: EntityPlayer): boolean {
   return player.Parent !== undefined;

package/src/functions/playerStats.ts

@@ -0,0 +1,26 @@
+import { StatType } from "../enums/StatType";
+import { StatTypeType } from "../interfaces/StatTypeType";
+
+/** Helper function to get the stat for a player corresponding to the `StatType`. */
+export function getPlayerStat<T extends StatType>(
+  player: EntityPlayer,
+  statType: T,
+): StatTypeType[T] {
+  // We can't use a switch statement here because control-flow based type analysis does not apply to
+  // generic type parameters.
+  return {
+    [StatType.DAMAGE]: player.Damage, // 1 << 0
+    [StatType.FIRE_DELAY]: player.MaxFireDelay, // 1 << 1
+    [StatType.SHOT_SPEED]: player.ShotSpeed, // 1 << 2
+    [StatType.TEAR_HEIGHT]: player.TearHeight, // 1 << 3
+    [StatType.TEAR_RANGE]: player.TearRange, // 1 << 3
+    [StatType.TEAR_FALLING_ACCELERATION]: player.TearFallingAcceleration, // 1 << 3
+    [StatType.TEAR_FALLING_SPEED]: player.TearFallingSpeed, // 1 << 3
+    [StatType.MOVE_SPEED]: player.MoveSpeed, // 1 << 4
+    [StatType.TEAR_FLAG]: player.TearFlags, // 1 << 5
+    [StatType.TEAR_COLOR]: player.TearColor, // 1 << 6
+    [StatType.FLYING]: player.CanFly, // 1 << 7
+    [StatType.LUCK]: player.Luck, // 1 << 10
+    [StatType.SIZE]: player.SizeMulti, // 1 << 11
+  }[statType];
+}

package/src/functions/players.ts

@@ -48,7 +48,7 @@ export function addCollectibleCostume(
 
 /**
  * Helper function to add a stat to a player based on the `CacheFlag` provided. Call this function
- * from the EvaluateCache callback.
+ * from the `EVALUATE_CACHE` callback.
  *
  * Note that for `CacheFlag.FIRE_DELAY`, the "amount" argument will be interpreted as the tear stat
  * to add (and not the amount to mutate `EntityPlayer.MaxFireDelay` by).

package/src/functions/rng.ts

@@ -15,8 +15,8 @@ export type SerializedRNG = LuaMap<string, unknown> & {
  */
 const RECOMMENDED_SHIFT_IDX = 35;
 
-const KEYS = ["seed"];
 const OBJECT_NAME = "RNG";
+const KEYS = ["seed"];
 
 /** Helper function to copy an `RNG` Isaac API class. */
 export function copyRNG(rng: RNG): RNG {
@@ -60,7 +60,7 @@ export function getRandomSeed(): Seed {
   return safeRandomNumber as Seed;
 }
 
-/** Helper function to check if something is an instantiated RNG object. */
+/** Helper function to check if something is an instantiated `RNG` object. */
 export function isRNG(object: unknown): object is RNG {
   return isIsaacAPIClassOfType(object, OBJECT_NAME);
 }

package/src/functions/roomTransition.ts

@@ -31,7 +31,7 @@ export function reloadRoom(): void {
  * arguments.
  *
  * Use this function instead of invoking the `Game.StartRoomTransition` method directly so that:
- * - you do not forget to set `Level.LeaveDoor` property
+ * - you do not forget to set the `Level.LeaveDoor` field
  * - to prevent crashing on invalid room grid indexes
  * - to automatically handle Curse of the Maze
  *

package/src/functions/rooms.ts

@@ -50,7 +50,7 @@ import { erange, irange } from "./utils";
 /**
  * Helper function for quickly switching to a new room without playing a particular animation. Use
  * this helper function over invoking the `Game.ChangeRoom` method directly to ensure that you do
- * not forget to set the `LeaveDoor` property and to prevent crashing on invalid room grid indexes.
+ * not forget to set the `LeaveDoor` field and to prevent crashing on invalid room grid indexes.
  */
 export function changeRoom(roomGridIndex: int): void {
   const level = game.GetLevel();

package/src/functions/sprites.ts

@@ -34,9 +34,9 @@ export function clearSprite(sprite: Sprite, ...layerIDs: int[]): void {
  *
  * Note that this function is bugged with the Stop Watch or the Broken Watch, since using the
  * `Sprite.SetFrame` method will reset the internal accumulator used to slow down the playback speed
- * of the animation. (The `PlaybackSpeed` property of the sprite is not used.) Thus, it is only safe
- * to use this function on animations that are not slowed down by Stop Watch or Broken Watch, such
- * as player animations.
+ * of the animation. (The `PlaybackSpeed` field of the sprite is not used.) Thus, it is only safe to
+ * use this function on animations that are not slowed down by Stop Watch or Broken Watch, such as
+ * player animations.
  */
 export function getLastFrameOfAnimation(
   sprite: Sprite,

package/src/functions/tears.ts

@@ -1,6 +1,7 @@
 /**
- * - Converts the specified amount of tears stat into MaxFireDelay and adds it to the player.
- * - This function should only be used inside the EvaluateCache callback.
+ * - Converts the specified amount of tears stat into the format of `EntityPlayer.MaxFireDelay` and
+ *   adds it to the player.
+ * - This function should only be used inside the `EVALUATE_CACHE` callback.
  * - In this context, the "tears stat" represents what is shown on the in-game stat UI.
  */
 export function addTearsStat(player: EntityPlayer, tearsStat: float): void {
@@ -11,7 +12,7 @@ export function addTearsStat(player: EntityPlayer, tearsStat: float): void {
 }
 
 /**
- * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` attribute. This is
+ * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` field. This is
  *   equivalent to how many tears the player can shoot per frame.
  * - If you already have a "tears" stat and you want to convert it back to MaxFireDelay, then use
  *   this function.
@@ -22,7 +23,7 @@ export function getFireDelay(tearsStat: float): float {
 }
 
 /**
- * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` attribute. This is
+ * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` field. This is
  *   equivalent to how many tears the player can shoot per frame.
  * - If you want to convert this to the "tears" stat that is shown on the in-game stat UI, then use
  *   this function.

package/src/functions/utils.ts

@@ -187,9 +187,13 @@ export function repeat(n: int, func: (i: int) => void): void {
  * When you see this function, it simply means that the programmer intends to add in more code to
  * this spot later.
  *
+ * This function is variadic, meaning that you can pass as many arguments as you want. (This is
+ * useful as a means to prevent lint warnings.)
+ *
  * This function does not actually do anything. (It is an "empty" function.)
  */
-export function todo(): void {}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function todo(...args: unknown[]): void {}
 
 /**
  * Helper function to sort a two-dimensional array by the first element.

package/src/functions/vector.ts

@@ -11,8 +11,8 @@ export type SerializedVector = LuaMap<string, unknown> & {
   readonly __serializedVectorBrand: symbol;
 };
 
-const KEYS = ["X", "Y"];
 const OBJECT_NAME = "Vector";
+const KEYS = ["X", "Y"];
 
 /** Helper function to copy a `Vector` Isaac API class. */
 export function copyVector(vector: Vector): Vector {
@@ -91,7 +91,7 @@ export function isSerializedVector(
   return tableHasKeys(object, ...KEYS) && object.has(SerializationBrand.VECTOR);
 }
 
-/** Helper function to check if something is an instantiated Vector object. */
+/** Helper function to check if something is an instantiated `Vector` object. */
 export function isVector(object: unknown): object is Vector {
   return isIsaacAPIClassOfType(object, OBJECT_NAME);
 }

package/src/initCustomCallbacks.ts

@@ -37,6 +37,7 @@ import { postPickupStateChangedInit } from "./callbacks/postPickupStateChanged";
 import { postPitRenderInit } from "./callbacks/postPitRender";
 import { postPitUpdateInit } from "./callbacks/postPitUpdate";
 import { postPlayerChangeHealthInit } from "./callbacks/postPlayerChangeHealth";
+import { postPlayerChangeStatInit } from "./callbacks/postPlayerChangeStat";
 import { postPlayerChangeTypeInit } from "./callbacks/postPlayerChangeType";
 import { postPlayerCollectibleCallbacksInit } from "./callbacks/postPlayerCollectible";
 import { postPlayerFatalDamageInit } from "./callbacks/postPlayerFatalDamage";
@@ -109,6 +110,7 @@ export function initCustomCallbacks(mod: ModUpgraded): void {
   postPitRenderInit(mod);
   postPitUpdateInit(mod);
   postPlayerChangeHealthInit(mod);
+  postPlayerChangeStatInit(mod);
   postPlayerChangeTypeInit(mod);
   postPlayerCollectibleCallbacksInit(mod);
   postPlayerFatalDamageInit(mod);

package/src/interfaces/SaveData.ts

@@ -1,3 +1,5 @@
+/* eslint-disable max-classes-per-file */
+
 /**
  * This is the format of the object that you give to the save data manager. It will contains all of
  * the variables for the particular mod feature.
@@ -11,19 +13,265 @@
  * - `boolean`
  * - `number`
  * - `string`
+ * - `undefined` (will be skipped over when saving)
+ * - `null` (will be skipped over when saving)
  * - `Map` / `DefaultMap`
  * - `Set`
  * - serializable Isaac API classes (such as `Color`)
  * - TSTL classes (i.e. classes that you made yourself)
  * - sub-objects or a `LuaMap` that contains the above values
+ */
+export interface SaveData<
+  Persistent = unknown,
+  Run = unknown,
+  Level = unknown,
+> {
+  persistent?: Serializable<Persistent>;
+  run?: Serializable<Run>;
+  level?: Serializable<Level>;
+  room?: Record<string, unknown>; // Room data is never saved to disk.
+}
+
+/**
+ * A type that represents valid serializable data fed to the save data manager.
+ *
+ * Custom errors are thrown when an Isaac API class or a nested custom class is detected.
  *
- * (Unfortunately, it is not possible to create a recursive type definition that matches these
- * properties. This means that the TypeScript compiler will not be able to validate that you are
- * passing in serializable data.)
+ * The recursive nature of this type is based on the `Immutable` type:
+ * https://stackoverflow.com/questions/41879327/deepreadonly-object-typescript
  */
-export interface SaveData {
-  persistent?: Record<string, unknown>;
-  run?: Record<string, unknown>;
-  level?: Record<string, unknown>;
-  room?: Record<string, unknown>;
+type Serializable<T> =
+  // Allow the trivial case of primitives.
+  T extends SerializablePrimitive
+    ? T
+    : // Allow a specific subset of Isaac API classes that are copyable / serializable.
+    T extends SerializableIsaacAPIClass
+    ? T
+    : // Disallow all other Isaac API classes.
+    T extends IsaacAPIClass
+    ? ErrorIsaacAPIClassIsNotSerializable
+    : // Allow some specific "container" objects.
+    // These container objects are explicitly handled by the save data manager, but there are
+    // restrictions on the things inside of them.
+    T extends Array<infer U>
+    ? SerializableArray<U>
+    : T extends ReadonlyArray<infer U>
+    ? SerializableReadonlyArray<U>
+    : T extends Map<infer K, infer V>
+    ? SerializableMap<K, V>
+    : T extends ReadonlyMap<infer K, infer V>
+    ? SerializableReadonlyMap<K, V>
+    : T extends Set<infer V>
+    ? SerializableSet<V>
+    : T extends ReadonlySet<infer V>
+    ? SerializableReadonlySet<V>
+    : // Allow any other object, as long as the values are themselves serializable.
+      SerializableObject<T>;
+
+/**
+ * This is mostly copied from the `Serializable` type. The difference is that we want to disallow
+ * classes with methods.
+ */
+type SerializableInsideArrayOrMap<T> =
+  // Allow the trivial case of primitives.
+  T extends SerializablePrimitive
+    ? T
+    : // Allow a specific subset of Isaac API classes that are copyable / serializable.
+    T extends SerializableIsaacAPIClass
+    ? T
+    : // Disallow all other Isaac API classes.
+    T extends IsaacAPIClass
+    ? ErrorIsaacAPIClassIsNotSerializable
+    : // Allow some specific "container" objects.
+    // These container objects are explicitly handled by the save data manager, but there are
+    // restrictions on the things inside of them.
+    T extends Array<infer U>
+    ? SerializableArray<U>
+    : T extends ReadonlyArray<infer U>
+    ? SerializableReadonlyArray<U>
+    : T extends Map<infer K, infer V>
+    ? SerializableMap<K, V>
+    : T extends ReadonlyMap<infer K, infer V>
+    ? SerializableReadonlyMap<K, V>
+    : T extends Set<infer V>
+    ? SerializableSet<V>
+    : T extends ReadonlySet<infer V>
+    ? SerializableReadonlySet<V>
+    : // Disallow objects with functions on them (i.e. classes with methods).
+    // (This has to be after allowing maps and sets, because those have functions inside of them.)
+    T extends HasMethods<T>
+    ? ErrorCustomClassNotSerializable
+    : // Disallow functions.
+    // (We can only disallow functions when inside of containers, because we want to allow classes
+    // with methods attached to normal objects.)
+    T extends Function // eslint-disable-line @typescript-eslint/ban-types
+    ? FunctionIsNotSerializable
+    : // Finally, allow any other object, as long as the values are themselves serializable.
+      SerializableObject<T>;
+
+type SerializablePrimitive = boolean | string | number | undefined | null;
+type SerializableArray<T> = Array<SerializableInsideArrayOrMap<T>>;
+type SerializableReadonlyArray<T> = ReadonlyArray<
+  SerializableInsideArrayOrMap<T>
+>;
+type SerializableMap<K, V> = Map<
+  SerializableInsideArrayOrMap<K>,
+  SerializableInsideArrayOrMap<V>
+>;
+type SerializableReadonlyMap<K, V> = ReadonlyMap<
+  SerializableInsideArrayOrMap<K>,
+  SerializableInsideArrayOrMap<V>
+>;
+type SerializableSet<T> = Set<SerializableInsideArrayOrMap<T>>;
+type SerializableReadonlySet<T> = ReadonlySet<SerializableInsideArrayOrMap<T>>;
+type SerializableObject<T> = { [K in keyof T]: Serializable<T[K]> };
+type SerializableIsaacAPIClass = BitSet128 | Color | KColor | RNG | Vector;
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type HasMethods<T> = {} extends {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  [K in keyof T as T[K] extends Function ? K : never]-?: 1;
+}
+  ? never
+  : T;
+
+type FunctionIsNotSerializable =
+  "Error: Functions are not serializable. For more information, see: https://isaacscript.github.io/main/gotchas#functions-are-not-serializable";
+
+type ErrorIsaacAPIClassIsNotSerializable =
+  "Error: Isaac API classes (such as e.g. `Entity` or `RoomConfig`) are not serializable. For more information, see: https://isaacscript.github.io/main/gotchas#isaac-api-classes-are-not-serializable";
+
+type ErrorCustomClassNotSerializable =
+  "Error: Custom classes with one or more methods are not serializable when inside of an array, map, or set. For more information, see: https://isaacscript.github.io/main/gotchas#custom-classes-are-not-serializable";
+
+// -----
+// Tests
+// -----
+
+function test<Persistent, Run, Level>(
+  _saveData: SaveData<Persistent, Run, Level>,
+) {}
+
+{
+  const saveDataWithPrimitives = {
+    run: {
+      foo: 123,
+      bar: "bar",
+      baz: true,
+      nested: {
+        foo: 123,
+        bar: "bar",
+        baz: true,
+      },
+    },
+  };
+
+  // Primitives and nested primitives are allowed.
+  test(saveDataWithPrimitives);
+}
+
+{
+  const saveDataWithEntity = {
+    run: {
+      foo: {} as Entity,
+    },
+  };
+
+  // @ts-expect-error Isaac API classes are not serializable.
+  test(saveDataWithEntity);
+}
+
+{
+  const saveDataWithMap = {
+    run: {
+      foo: new Map<string, string>(),
+    },
+  };
+
+  // Maps with primitive values are allowed.
+  test(saveDataWithMap);
+}
+
+{
+  const saveDataWithMap = {
+    run: {
+      foo: new Map<string, () => void>(),
+    },
+  };
+
+  // @ts-expect-error Maps with function values are not serializable.
+  test(saveDataWithMap);
+}
+
+{
+  const saveDataWithMap = {
+    run: {
+      foo: new Map<string, Map<string, string>>(),
+    },
+  };
+
+  // Nested maps are allowed.
+  test(saveDataWithMap);
+}
+
+{
+  class Foo {
+    someField = 123;
+  }
+
+  const saveDataWithClass = {
+    run: {
+      foo: new Foo(),
+    },
+  };
+
+  // Custom classes without methods are allowed.
+  test(saveDataWithClass);
+}
+
+{
+  class Foo {
+    someField = 123;
+    someMethod() {} // eslint-disable-line class-methods-use-this
+  }
+
+  const saveDataWithClassWithMethod = {
+    run: {
+      foo: new Foo(),
+    },
+  };
+
+  // Custom classes with methods are allowed.
+  test(saveDataWithClassWithMethod);
+}
+
+{
+  class Foo {
+    someField = 123;
+  }
+
+  const saveDataWithNestedClass = {
+    run: {
+      fooMap: new Map<string, Foo>(),
+    },
+  };
+
+  // Nested custom classes without methods are allowed.
+  test(saveDataWithNestedClass);
+}
+
+{
+  class Foo {
+    someField = 123;
+    someMethod() {} // eslint-disable-line class-methods-use-this
+  }
+
+  const saveDataWithNestedClass = {
+    run: {
+      fooMap: new Map<string, Foo>(),
+    },
+  };
+
+  // @ts-expect-error Nested custom classes with methods are not serializable.
+  test(saveDataWithNestedClass);
 }

package/src/interfaces/StatTypeType.ts

@@ -0,0 +1,18 @@
+import { TearFlag } from "isaac-typescript-definitions";
+import { StatType } from "../enums/StatType";
+
+export interface StatTypeType {
+  [StatType.DAMAGE]: float;
+  [StatType.FIRE_DELAY]: float;
+  [StatType.SHOT_SPEED]: float;
+  [StatType.TEAR_HEIGHT]: float;
+  [StatType.TEAR_RANGE]: float;
+  [StatType.TEAR_FALLING_ACCELERATION]: float;
+  [StatType.TEAR_FALLING_SPEED]: float;
+  [StatType.MOVE_SPEED]: float;
+  [StatType.TEAR_FLAG]: BitFlags<TearFlag>;
+  [StatType.TEAR_COLOR]: Color;
+  [StatType.FLYING]: boolean;
+  [StatType.LUCK]: float;
+  [StatType.SIZE]: Vector;
+}

package/src/interfaces/index.ts

@@ -7,4 +7,5 @@ export * from "./PlayerHealth";
 export * from "./PocketItemDescription";
 export * from "./RoomDescription";
 export * from "./SaveData";
+export * from "./StatTypeType";
 export * from "./TrinketSituation";

package/src/interfaces/indexTypeDoc.ts

@@ -7,4 +7,5 @@ export * as PlayerHealth from "./PlayerHealth";
 export * as PocketItemDescription from "./PocketItemDescription";
 export * as RoomDescription from "./RoomDescription";
 export * as SaveData from "./SaveData";
+export * as StatTypeType from "./StatTypeType";
 export * as TrinketSituation from "./TrinketSituation";

package/src/interfaces/private/AddCallbackParameterCustom.ts

@@ -50,6 +50,7 @@ import { PostPickupStateChangedRegisterParameters } from "../../callbacks/subscr
 import { PostPitRenderRegisterParameters } from "../../callbacks/subscriptions/postPitRender";
 import { PostPitUpdateRegisterParameters } from "../../callbacks/subscriptions/postPitUpdate";
 import { PostPlayerChangeHealthRegisterParameters } from "../../callbacks/subscriptions/postPlayerChangeHealth";
+import { PostPlayerChangeStatRegisterParameters } from "../../callbacks/subscriptions/postPlayerChangeStat";
 import { PostPlayerChangeTypeRegisterParameters } from "../../callbacks/subscriptions/postPlayerChangeType";
 import { PostPlayerCollectibleAddedRegisterParameters } from "../../callbacks/subscriptions/postPlayerCollectibleAdded";
 import { PostPlayerCollectibleRemovedRegisterParameters } from "../../callbacks/subscriptions/postPlayerCollectibleRemoved";
@@ -140,6 +141,7 @@ export interface AddCallbackParameterCustom {
   [ModCallbackCustom.POST_PIT_RENDER]: PostPitRenderRegisterParameters;
   [ModCallbackCustom.POST_PIT_UPDATE]: PostPitUpdateRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_CHANGE_HEALTH]: PostPlayerChangeHealthRegisterParameters;
+  [ModCallbackCustom.POST_PLAYER_CHANGE_STAT]: PostPlayerChangeStatRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_CHANGE_TYPE]: PostPlayerChangeTypeRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED]: PostPlayerCollectibleAddedRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED]: PostPlayerCollectibleRemovedRegisterParameters;

package/src/objects/callbackRegisterFunctions.ts

@@ -50,6 +50,7 @@ import { postPickupStateChangedRegister } from "../callbacks/subscriptions/postP
 import { postPitRenderRegister } from "../callbacks/subscriptions/postPitRender";
 import { postPitUpdateRegister } from "../callbacks/subscriptions/postPitUpdate";
 import { postPlayerChangeHealthRegister } from "../callbacks/subscriptions/postPlayerChangeHealth";
+import { postPlayerChangeStatRegister } from "../callbacks/subscriptions/postPlayerChangeStat";
 import { postPlayerChangeTypeRegister } from "../callbacks/subscriptions/postPlayerChangeType";
 import { postPlayerCollectibleAddedRegister } from "../callbacks/subscriptions/postPlayerCollectibleAdded";
 import { postPlayerCollectibleRemovedRegister } from "../callbacks/subscriptions/postPlayerCollectibleRemoved";
@@ -155,6 +156,7 @@ export const CALLBACK_REGISTER_FUNCTIONS: {
   [ModCallbackCustom.POST_PIT_RENDER]: postPitRenderRegister,
   [ModCallbackCustom.POST_PIT_UPDATE]: postPitUpdateRegister,
   [ModCallbackCustom.POST_PLAYER_CHANGE_HEALTH]: postPlayerChangeHealthRegister,
+  [ModCallbackCustom.POST_PLAYER_CHANGE_STAT]: postPlayerChangeStatRegister,
   [ModCallbackCustom.POST_PLAYER_CHANGE_TYPE]: postPlayerChangeTypeRegister,
   [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED]:
     postPlayerCollectibleAddedRegister,

package/src/objects/isaacAPIClassTypeToBrand.ts

@@ -4,6 +4,7 @@ import { SerializationBrand } from "../enums/private/SerializationBrand";
 export const ISAAC_API_CLASS_TYPE_TO_BRAND: {
   readonly [key in CopyableIsaacAPIClassType]: SerializationBrand;
 } = {
+  [CopyableIsaacAPIClassType.BIT_SET_128]: SerializationBrand.BIT_SET_128,
   [CopyableIsaacAPIClassType.COLOR]: SerializationBrand.COLOR,
   [CopyableIsaacAPIClassType.K_COLOR]: SerializationBrand.K_COLOR,
   [CopyableIsaacAPIClassType.RNG]: SerializationBrand.RNG,

package/src/objects/isaacAPIClassTypeToFunctions.ts

@@ -1,6 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
+import {
+  copyBitSet128,
+  deserializeBitSet128,
+  isSerializedBitSet128,
+  serializeBitSet128,
+} from "../functions/bitSet128";
 import {
   copyColor,
   deserializeColor,
@@ -36,6 +42,12 @@ interface IsaacAPIClassTypeFunctions {
 export const ISAAC_API_CLASS_TYPE_TO_FUNCTIONS: {
   readonly [key in CopyableIsaacAPIClassType]: IsaacAPIClassTypeFunctions;
 } = {
+  [CopyableIsaacAPIClassType.BIT_SET_128]: {
+    isSerialized: isSerializedBitSet128,
+    copy: copyBitSet128,
+    serialize: serializeBitSet128,
+    deserialize: deserializeBitSet128,
+  },
   [CopyableIsaacAPIClassType.COLOR]: {
     isSerialized: isSerializedColor,
     copy: copyColor,

package/src/types/index.ts

@@ -2,7 +2,6 @@ export * from "./AnyEntity";
 export * from "./AnyGridEntity";
 export * from "./CollectibleIndex";
 export * from "./Immutable";
-export * from "./IsaacAPIClass";
 export * from "./PickingUpItem";
 export * from "./PickupIndex";
 export * from "./PlayerIndex";

package/src/types/indexTypeDoc.ts

@@ -2,7 +2,6 @@ export * as AnyEntity from "./AnyEntity";
 export * as AnyGridEntity from "./AnyGridEntity";
 export * as CollectibleIndex from "./CollectibleIndex";
 export * as Immutable from "./Immutable";
-export * as IsaacAPIClass from "./IsaacAPIClass";
 export * as PickingUpItem from "./PickingUpItem";
 export * as PickupIndex from "./PickupIndex";
 export * as PlayerIndex from "./PlayerIndex";