isaacscript-common 2.2.0 → 2.3.0

package/src/classes/DefaultMap.ts

@@ -0,0 +1,220 @@
+/* eslint-disable sort-exports/sort-exports */
+
+/**
+ * A function that creates the value for your default map. For example, if it was a default map
+ * containing maps, the factory function would be: `() => new Map()`
+ */
+export type FactoryFunction<V, Args extends unknown[]> = (
+  ...extraArgs: Args
+) => V;
+
+type FirstArg<K, V, Args extends unknown[]> =
+  | Iterable<[K, V]>
+  | V
+  | FactoryFunction<V, Args>;
+type SecondArg<V, Args extends unknown[]> = V | FactoryFunction<V, Args>;
+
+interface ParsedArgs<K, V, Args extends unknown[]> {
+  iterable: Iterable<[K, V]> | undefined;
+  defaultValue: V | undefined;
+  defaultValueFactory: FactoryFunction<V, Args> | undefined;
+}
+
+/**
+ * An extended `Map` with some new methods:
+ *
+ * - `getAndSetDefault` - If the key exists, this will return the same thing as the `get` method.
+ *   Otherwise, it will set a default value to the key, and then return the default value.
+ * - `getDefaultValue` - Returns the default value to be used for a new key. (If a factory function
+ *   was provided during instantiation, this will execute the factory function.)
+ * - `getConstructorArg` - Helper method for cloning the map. Returns either the default value or
+ *   the reference to the factory function.
+ *
+ * When instantiating a new DefaultMap, you must specify either a default value or a function that
+ * returns a default value.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Initializes a new empty DefaultMap with a default value of "foo".
+ * const defaultMapWithPrimitive = new DefaultMap<string, string>("foo");
+ *
+ * // Initializes a new empty DefaultMap with a default value of a new Map.
+ * const defaultMapWithFactory = new DefaultMap<string, Map<string, string>>(() => {
+ *   return new Map();
+ * })
+ *
+ * // Initializes a DefaultMap with some initial values and a default value of "bar".
+ * const defaultMapWithInitialValues = new DefaultMap<string, string>([
+ *   ["a1", "a2"],
+ *   ["b1", "b2"],
+ * ], "bar");
+ * ```
+ *
+ * If specified, the first argument of a factory function must always be equal to the key:
+ *
+ * ```ts
+ * const defaultMapWithConditionalDefaultValue = new DefaultMap<number, number>((key: number) => {
+ *   return isOdd(key) ? 0 : 1;
+ * });
+ * ```
+ *
+ * You can also specify a factory function that takes a generic amount of arguments beyond the
+ * first:
+ *
+ * ```ts
+ * const factoryFunction = (arg: boolean) => arg ? 0 : 1;
+ * const defaultMapWithExtraArgs = new DefaultMap<string, string, [arg: boolean]>(factoryFunction);
+ * ```
+ */
+export class DefaultMap<K, V, Args extends unknown[] = []> extends Map<K, V> {
+  private defaultValue: V | undefined;
+  private defaultValueFactory: FactoryFunction<V, Args> | undefined;
+
+  /**
+   * See the main `DefaultMap` documentation:
+   * https://isaacscript.github.io/isaacscript-common/classes/classes_DefaultMap.DefaultMap
+   */
+  constructor(
+    iterableOrDefaultValueOrDefaultValueFactory: FirstArg<K, V, Args>,
+    defaultValueOrDefaultValueFactory?: SecondArg<V, Args>,
+  ) {
+    const { iterable, defaultValue, defaultValueFactory } = parseArguments(
+      iterableOrDefaultValueOrDefaultValueFactory,
+      defaultValueOrDefaultValueFactory,
+    );
+
+    if (defaultValue === undefined && defaultValueFactory === undefined) {
+      error(
+        "A DefaultMap must be instantiated with either a default value or a function that returns a default value.",
+      );
+    }
+
+    if (iterable === undefined) {
+      super();
+    } else {
+      super(iterable);
+    }
+
+    this.defaultValue = defaultValue;
+    this.defaultValueFactory = defaultValueFactory;
+  }
+
+  /**
+   * If the key exists, this will return the same thing as the `get` method. Otherwise, it will set
+   * a default value to the key, and then return the default value.
+   */
+  getAndSetDefault(key: K, ...extraArgs: Args): V {
+    const value = this.get(key);
+    if (value !== undefined) {
+      return value;
+    }
+
+    const defaultValue = this.getDefaultValue(...extraArgs);
+    this.set(key, defaultValue);
+    return defaultValue;
+  }
+
+  /**
+   * Returns the default value to be used for a new key. (If a factory function was provided during
+   * instantiation, this will execute the factory function.)
+   */
+  getDefaultValue(...extraArgs: Args): V {
+    if (this.defaultValue !== undefined) {
+      return this.defaultValue;
+    }
+
+    if (this.defaultValueFactory !== undefined) {
+      return this.defaultValueFactory(...extraArgs);
+    }
+
+    return error("A DefaultMap was incorrectly instantiated.");
+  }
+
+  /**
+   * Helper method for cloning the map. Returns either the default value or a reference to the
+   * factory function.
+   */
+  getConstructorArg(): V | FactoryFunction<V, Args> {
+    if (this.defaultValue !== undefined) {
+      return this.defaultValue;
+    }
+
+    if (this.defaultValueFactory !== undefined) {
+      return this.defaultValueFactory;
+    }
+
+    return error("A DefaultMap was incorrectly instantiated.");
+  }
+}
+
+function parseArguments<K, V, Args extends unknown[]>(
+  firstArg: FirstArg<K, V, Args>,
+  secondArg?: SecondArg<V, Args>,
+): ParsedArgs<K, V, Args> {
+  return secondArg === undefined
+    ? parseArgumentsOne(firstArg)
+    : parseArgumentsTwo(firstArg, secondArg);
+}
+
+function parseArgumentsOne<K, V, Args extends unknown[]>(
+  firstArg: FirstArg<K, V, Args>,
+): ParsedArgs<K, V, Args> {
+  const arg = firstArg as SecondArg<V, Args>;
+  const { defaultValue, defaultValueFactory } =
+    parseDefaultValueOrDefaultValueFactory(arg);
+  return {
+    iterable: undefined,
+    defaultValue,
+    defaultValueFactory,
+  };
+}
+
+function parseArgumentsTwo<K, V, Args extends unknown[]>(
+  firstArg: FirstArg<K, V, Args>,
+  secondArg: SecondArg<V, Args>,
+): ParsedArgs<K, V, Args> {
+  const firstArgType = type(firstArg);
+  if (firstArgType !== "table") {
+    error(
+      "A DefaultMap constructor with two arguments must have the first argument be the initializer list.",
+    );
+  }
+
+  const { defaultValue, defaultValueFactory } =
+    parseDefaultValueOrDefaultValueFactory(secondArg);
+  return {
+    iterable: firstArg as Iterable<[K, V]>,
+    defaultValue,
+    defaultValueFactory,
+  };
+}
+
+function parseDefaultValueOrDefaultValueFactory<V, Args extends unknown[]>(
+  arg: SecondArg<V, Args>,
+): {
+  defaultValue: V | undefined;
+  defaultValueFactory: FactoryFunction<V, Args> | undefined;
+} {
+  if (typeof arg === "function") {
+    return {
+      defaultValue: undefined,
+      defaultValueFactory: arg as FactoryFunction<V, Args>,
+    };
+  }
+
+  if (
+    typeof arg === "boolean" ||
+    typeof arg === "number" ||
+    typeof arg === "string"
+  ) {
+    return {
+      defaultValue: arg as V,
+      defaultValueFactory: undefined,
+    };
+  }
+
+  return error(
+    `A DefaultMap was instantiated with an unknown type of: ${typeof arg}`,
+  );
+}

package/src/classes/ModUpgraded.ts

@@ -0,0 +1,83 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { AddCallbackParameterCustom } from "../interfaces/AddCallbackParameterCustom";
+import { CALLBACK_REGISTER_FUNCTIONS } from "../objects/callbackRegisterFunctions";
+
+/**
+ * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
+ * hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
+ * extends the base class and adds a new method of `AddCallbackCustom`.
+ *
+ * To upgrade your mod, use the `upgradeMod` helper function.
+ */
+export class ModUpgraded implements Mod {
+  // -----------------
+  // Vanilla variables
+  // -----------------
+
+  Name: string; // The vanilla mod object stores this for some reason
+
+  // ----------------
+  // Custom variables
+  // ----------------
+
+  /** We store a copy of the original mod object so that we can re-implement its functions. */
+  Mod: Mod;
+
+  constructor(mod: Mod) {
+    this.Name = mod.Name;
+
+    this.Mod = mod;
+  }
+
+  // ---------------
+  // Vanilla methods
+  // ---------------
+
+  AddCallback<T extends ModCallback>(
+    modCallback: T,
+    ...args: AddCallbackParameter[T]
+  ): void {
+    this.Mod.AddCallback(modCallback, ...args);
+  }
+
+  HasData(): boolean {
+    return this.Mod.HasData();
+  }
+
+  LoadData(): string {
+    return this.Mod.LoadData();
+  }
+
+  RemoveCallback(callbackID: ModCallback, callback: () => void): void {
+    this.Mod.RemoveCallback(callbackID, callback);
+  }
+
+  RemoveData(): void {
+    this.Mod.RemoveData();
+  }
+
+  SaveData(data: string): void {
+    this.Mod.SaveData(data);
+  }
+
+  // --------------
+  // Custom methods
+  // --------------
+
+  // eslint-disable-next-line class-methods-use-this
+  AddCallbackCustom<T extends ModCallbackCustom>(
+    modCallbackCustom: T,
+    ...args: AddCallbackParameterCustom[T]
+  ): void {
+    const callbackRegisterFunction =
+      CALLBACK_REGISTER_FUNCTIONS[modCallbackCustom];
+    if (callbackRegisterFunction === undefined) {
+      error(
+        `Failed to find a callback registration function for custom callback: ${modCallbackCustom}`,
+      );
+    }
+
+    callbackRegisterFunction(...args);
+  }
+}

package/src/constants.ts

@@ -0,0 +1,140 @@
+import {
+  Dimension,
+  ItemPoolType,
+  LevelStage,
+  RoomType,
+  TrinketSlot,
+} from "isaac-typescript-definitions";
+import { getEnumLength, getLastEnumValue } from "./functions/enums";
+
+/**
+ * The distance of the laser when Azazel does not have any range up items yet. For more info, see
+ * the documentation for the `getAzazelBrimstoneDistance` function.
+ */
+export const AZAZEL_DEFAULT_BRIMSTONE_DISTANCE = 75.125;
+
+/**
+ * The path to the png file for collectible items during Curse of the Blind, making them appear with
+ * a red question mark.
+ */
+export const BLIND_ITEM_PNG_PATH = "gfx/items/collectibles/questionmark.png";
+
+/** Bombs explode when their frame count is equal to this value. */
+export const BOMB_EXPLODE_FRAME = 45;
+
+export const DEFAULT_ITEM_POOL_TYPE = ItemPoolType.TREASURE;
+
+/** This is also the distance that a player spawns from the door that they enter a room from. */
+export const DISTANCE_OF_GRID_TILE = 40;
+
+export const DOOR_HITBOX_RADIUS = 11;
+
+/**
+ * When Eggies take fatal damage, they go into NpcState.STATE_SUICIDE and spawn 14 Swarm Spiders
+ * while their StateFrame ticks upwards. The 14th spider appears when the StateFrame is at this
+ * value.
+ */
+export const EGGY_STATE_FRAME_OF_FINAL_SPIDER = 45;
+
+/**
+ * A non-existent or completely transparent PNG file for use in clearing sprites. For more
+ * information, see the documentation for the `clearSprite` helper function.
+ */
+export const EMPTY_PNG_PATH = "gfx/none.png";
+
+/**
+ * The random items that appear when the player has TMTRAINER are generated on the fly as they are
+ * encountered by the player. The first TMTRAINER item takes the final possible 32 bit number. The
+ * second TMTRAINER item subtracts one from that, and so on.
+ */
+export const FIRST_GLITCHED_COLLECTIBLE_TYPE = (1 << 32) - 1;
+
+export const GAME_FRAMES_PER_SECOND = 30;
+export const GRID_INDEX_CENTER_OF_1X1_ROOM = 67;
+export const ISAAC_FRAMES_PER_SECOND = 60;
+
+/**
+ * The floor is represented by a 13x13 grid. Room indexes start at 0. The first column is
+ * represented by grid indexes 0, 13, 26, and so on.
+ */
+export const LEVEL_GRID_COLUMN_HEIGHT = 13;
+
+/**
+ * The floor is represented by a 13x13 grid. Room indexes start at 0. The first row is represented
+ * by grid indexes from 0 to 12. The second row is represented by grid indexes from 13 to 25, and so
+ * on.
+ */
+export const LEVEL_GRID_ROW_WIDTH = 13;
+
+/**
+ * The floor is represented by a 13x13 grid. Room indexes start at 0. The first row is represented
+ * by grid indexes from 0 to 12. The second row is represented by grid indexes from 13 to 25, and so
+ * on. The maximum room index possible is 168. (It is not 169 because we start at 0 instead of 1.)
+ */
+export const MAX_LEVEL_GRID_INDEX = 168;
+
+/**
+ * The game has a limit on the number of currently spawned familiars and will refuse to spawn any
+ * more if it reaches the limit. Blue flies and blue spiders have a lower priority and will be
+ * deleted to make room for other familiars.
+ */
+export const MAX_NUM_FAMILIARS = 64;
+
+/** The game can only handle up to four different players. */
+export const MAX_NUM_INPUTS = 4;
+
+/** With Birthright, it is possible for Magdalene to have 18 heart containers. */
+export const MAX_PLAYER_HEART_CONTAINERS = 18;
+
+/**
+ * As the player continues to move in a direction, they will accelerate. When going from one wall to
+ * another in a 2x2 room at 2.0 speed (the maximum that the speed stat can rise to), the amount of
+ * units moved per update frame will climb to around 9.797 as they hit the opposite wall. The
+ * constant specifies a value of 9.8 to be safe.
+ */
+export const MAX_PLAYER_SPEED_IN_UNITS = 9.8;
+
+export const MAX_PLAYER_TRINKET_SLOTS = getEnumLength(TrinketSlot);
+
+export const FIRST_ROOM_TYPE = RoomType.DEFAULT; // eslint-disable-line sort-exports/sort-exports
+export const LAST_ROOM_TYPE = getLastEnumValue(RoomType);
+
+/**
+ * The maximum speed stat that a player can have. Any additional speed beyond this will not take
+ * effect.
+ */
+export const MAX_SPEED_STAT = 2.0;
+
+export const FIRST_STAGE = LevelStage.BASEMENT_1; // eslint-disable-line sort-exports/sort-exports
+export const LAST_STAGE = getLastEnumValue(LevelStage);
+
+/** Corresponds to the maximum value for `EntityPlayer.SamsonBerserkCharge`. */
+export const MAX_TAINTED_SAMSON_BERSERK_CHARGE = 100000;
+
+export const NUM_DIMENSIONS = getEnumLength(Dimension) - 1; // Account for "Dimension.CURRENT"
+
+export const SECOND_IN_MILLISECONDS = 1000;
+export const MINUTE_IN_MILLISECONDS = 60 * SECOND_IN_MILLISECONDS; // eslint-disable-line sort-exports/sort-exports
+
+export const ONE_BY_ONE_ROOM_GRID_SIZE = 135;
+
+/** After taking damage, `EntityPlayer.SamsonBerserkCharge` is incremented by this amount. */
+export const TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE = 10000;
+
+/**
+ * This is the number of draw coordinates that each heart spans on the UI in the upper left hand
+ * corner.
+ */
+export const UI_HEART_WIDTH = 12;
+
+/**
+ * This is a safer version of the `Vector.One` constant. (Other mods can mutate this `Vector.One`,
+ * so it is not safe to use.)
+ */
+export const VectorOne: Readonly<Vector> = Vector(1, 1);
+
+/**
+ * This is a safer version of the `Vector.Zero` constant. (Other mods can mutate `Vector.Zero`
+ * vector, so it is not safe to use.)
+ */
+export const VectorZero: Readonly<Vector> = Vector(0, 0);

package/src/constantsFirstLast.ts

@@ -0,0 +1,212 @@
+/* eslint-disable sort-exports/sort-exports */
+
+import {
+  Card,
+  CollectibleType,
+  PillColor,
+  PillEffect,
+  PlayerType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { itemConfig } from "./cachedClasses";
+import { getEnumLength, getLastEnumValue } from "./functions/enums";
+
+// ------------
+// Collectibles
+// ------------
+
+/** Equal to `CollectibleType.SAD_ONION`. */
+export const FIRST_COLLECTIBLE_TYPE = CollectibleType.SAD_ONION;
+
+/**
+ * Will change depending on how many modded collectibles there are.
+ *
+ * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles. We
+ * subtract one to account for `CollectibleType.NULL`.)
+ */
+export const LAST_COLLECTIBLE_TYPE = (itemConfig.GetCollectibles().Size -
+  1) as CollectibleType;
+
+/**
+ * Calculated from the `CollectibleType` enum.
+ *
+ * Note that this cannot be calculated from the length of the enum, because unlike all of the other
+ * enums, collectible types are not contiguous.
+ */
+export const LAST_VANILLA_COLLECTIBLE_TYPE = getLastEnumValue(CollectibleType);
+
+/**
+ * If there are no modded collectibles, this constant will represent a collectible type that does
+ * not exist.
+ */
+export const FIRST_MODDED_COLLECTIBLE_TYPE =
+  ((LAST_VANILLA_COLLECTIBLE_TYPE as int) + 1) as CollectibleType;
+
+/** Calculated from the `CollectibleType` enum. `CollectibleType.NULL` is not included. */
+export const NUM_VANILLA_COLLECTIBLE_TYPES = getEnumLength(CollectibleType) - 1;
+
+/** Unlike vanilla collectible types, modded collectible types are always contiguous. */
+export const NUM_MODDED_COLLECTIBLE_TYPES =
+  LAST_COLLECTIBLE_TYPE - LAST_VANILLA_COLLECTIBLE_TYPE;
+
+export const NUM_COLLECTIBLE_TYPES =
+  NUM_VANILLA_COLLECTIBLE_TYPES + NUM_MODDED_COLLECTIBLE_TYPES;
+
+// --------
+// Trinkets
+// --------
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
+ * `TrinketType.NULL`.)
+ */
+export const NUM_TRINKET_TYPES = itemConfig.GetTrinkets().Size - 1;
+
+/** Calculated from the `TrinketType` enum. `TrinketType.NULL` is not included. */
+export const NUM_VANILLA_TRINKET_TYPES = getEnumLength(TrinketType) - 1;
+
+export const NUM_MODDED_TRINKET_TYPES =
+  NUM_TRINKET_TYPES - NUM_VANILLA_TRINKET_TYPES;
+
+/** Equal to `TrinketType.SWALLOWED_PENNY`. */
+export const FIRST_TRINKET_TYPE = TrinketType.SWALLOWED_PENNY;
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
+ * `TrinketType.NULL`.)
+ */
+export const LAST_TRINKET_TYPE = NUM_TRINKET_TYPES as TrinketType;
+
+/** Calculated from the `TrinketType` enum. */
+export const LAST_VANILLA_TRINKET_TYPE = getLastEnumValue(TrinketType);
+
+/**
+ * If there are no modded trinkets, this constant will represent a trinket type that does not exist.
+ */
+export const FIRST_MODDED_TRINKET_TYPE = ((LAST_VANILLA_TRINKET_TYPE as int) +
+  1) as TrinketType;
+
+// -----
+// Cards
+// -----
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * Equal to `itemConfig.GetCards().Size - 1`. (We subtract one to account for `Card.NULL`.)
+ */
+export const NUM_CARDS = itemConfig.GetCards().Size - 1;
+
+/** Calculated from the `Card` enum. `Card.NULL` is not included. */
+export const NUM_VANILLA_CARDS = getEnumLength(Card) - 1;
+
+export const NUM_MODDED_CARDS = NUM_CARDS - NUM_VANILLA_CARDS;
+
+/** Equal to `Card.FOOL`. */
+export const FIRST_CARD = Card.FOOL;
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * Equal to `itemConfig.GetCards().Size - 1`. (We subtract one to account for `Card.NULL`.)
+ */
+export const LAST_CARD = NUM_CARDS as Card;
+
+/** Calculated from the `Card` enum. */
+export const MAX_VANILLA_CARD = getLastEnumValue(Card);
+
+/** If there are no modded cards, this constant will represent a card that does not exist. */
+export const FIRST_MODDED_CARD = ((MAX_VANILLA_CARD as int) + 1) as Card;
+
+// ------------
+// Pill Effects
+// ------------
+
+/**
+ * Will change depending on how many modded pill effects there are.
+ *
+ * Equal to `itemConfig.GetPillEffects().Size - 1`. (We subtract one to account for
+ * `PillEffect.NULL`.)
+ */
+export const NUM_PILL_EFFECTS = itemConfig.GetPillEffects().Size - 1;
+
+/**
+ * Calculated from the `PillEffect` enum.
+ *
+ * (There is no `PillEffect.NULL` in the custom enum, so we don't have to subtract one here.)
+ */
+export const NUM_VANILLA_PILL_EFFECTS = getEnumLength(PillEffect);
+
+export const NUM_MODDED_PILL_EFFECTS =
+  NUM_PILL_EFFECTS - NUM_VANILLA_PILL_EFFECTS;
+
+/** Equal to `PillEffect.BAD_GAS`. */
+export const FIRST_PILL_EFFECT = PillEffect.BAD_GAS;
+
+/**
+ * Will change depending on how many modded pill effects there are.
+ *
+ * Equal to `itemConfig.GetPillEffects().Size - 1`. (We subtract one to account for
+ * `PillEffect.NULL`.)
+ */
+export const LAST_PILL_EFFECT = NUM_PILL_EFFECTS as PillEffect;
+
+/** Calculated from the `PillEffect` enum. */
+export const LAST_VANILLA_PILL_EFFECT = getLastEnumValue(PillEffect);
+
+/**
+ * If there are no modded pill effects, this constant will represent a pill effect that does not
+ * exist.
+ */
+export const FIRST_MODDED_PILL_EFFECT = ((LAST_VANILLA_PILL_EFFECT as int) +
+  1) as PillEffect;
+
+// -----------
+// Pill Colors
+// -----------
+
+/** Equal to `PillColor.BLUE_BLUE`. */
+export const FIRST_PILL_COLOR = PillColor.BLUE_BLUE;
+
+/**
+ * Equal to `PillColor.WHITE_YELLOW`.
+ *
+ * Note that `PillColor.GOLD` is technically higher, but that is not considered for the purposes of
+ * this constant.
+ */
+export const LAST_NORMAL_PILL_COLOR = PillColor.WHITE_YELLOW;
+
+/** Equal to `PillColor.HORSE_BLUE_BLUE`. */
+export const FIRST_HORSE_PILL_COLOR = PillColor.HORSE_BLUE_BLUE;
+
+/**
+ * Equal to `PillColor.HORSE_WHITE_YELLOW`.
+ *
+ * Note that `PillColor.HORSE_GOLD` is technically higher, but that is not considered for the
+ * purposes of this constant.
+ */
+export const LAST_HORSE_PILL_COLOR = PillColor.HORSE_WHITE_YELLOW;
+
+export const NUM_NORMAL_PILL_COLORS = LAST_NORMAL_PILL_COLOR - FIRST_PILL_COLOR;
+
+// -------
+// Players
+// -------
+
+/** Equal to `PlayerType.ISAAC`. */
+export const FIRST_CHARACTER = PlayerType.ISAAC;
+
+// It is not possible to determine "LAST_PLAYER_TYPE", since there is no associated config.
+
+/** Calculated from the `PlayerType` enum. */
+export const LAST_VANILLA_CHARACTER = getLastEnumValue(PlayerType);
+
+/**
+ * If there are no modded characters, this constant will represent a character that does not exist.
+ */
+export const FIRST_MODDED_CHARACTER = ((LAST_VANILLA_CHARACTER as int) +
+  1) as PlayerType;

package/src/enums/HealthType.ts

@@ -0,0 +1,16 @@
+/**
+ * This represents the type of health that is either given or taken away from a player. Note that we
+ * cannot use the `HeartSubType` enum for this purpose this since it has no value for broken hearts
+ * or max hearts.
+ */
+export enum HealthType {
+  RED, // 5.10.1
+  SOUL, // 5.10.3
+  ETERNAL, // 5.10.4
+  BLACK, // 5.10.6
+  GOLDEN, // 5.10.7
+  BONE, // 5.10.11
+  ROTTEN, // 5.10.12
+  BROKEN,
+  MAX_HEARTS,
+}