isaacscript-common 3.16.1 → 4.0.1-dev.0

package/functions/utils.ts

@@ -0,0 +1,189 @@
+import { RenderMode } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+
+const HEX_STRING_LENGTH = 6;
+
+/**
+ * Helper function to return an array with the elements from start to end. It is inclusive at the
+ * start and exclusive at the end. (The "e" stands for exclusive.)
+ *
+ * For example, `erange(1, 3)` will return `[1, 2]`.
+ *
+ * If only one argument is specified, then it will assume that the start is 0.
+ */
+export function erange(start: int, end?: int): int[] {
+  if (end === undefined) {
+    end = start;
+    start = 0;
+  }
+
+  const array: int[] = [];
+  for (let i = start; i < end; i++) {
+    array.push(i);
+  }
+
+  return array;
+}
+
+/**
+ * Helper function to log what is happening in functions that recursively move through nested data
+ * structures.
+ */
+export function getTraversalDescription(
+  key: unknown,
+  traversalDescription: string,
+): string {
+  if (traversalDescription !== "") {
+    traversalDescription += " --> ";
+  }
+
+  traversalDescription += tostring(key);
+
+  return traversalDescription;
+}
+
+/**
+ * Converts a hex string like "#33aa33" to a KColor object.
+ *
+ * @param hexString A hex string like "#ffffff" or "ffffff". (The "#" character is optional.)
+ */
+export function hexToKColor(hexString: string, alpha: float): KColor {
+  hexString = hexString.replace("#", "");
+  if (hexString.length !== HEX_STRING_LENGTH) {
+    error(`Hex strings must be of length ${HEX_STRING_LENGTH}.`);
+  }
+
+  const rString = hexString.substr(0, 2);
+  const R = tonumber(`0x${rString}`);
+  if (R === undefined) {
+    error(`Failed to convert \`0x${rString}\` to a number.`);
+  }
+
+  const gString = hexString.substr(2, 2);
+  const G = tonumber(`0x${gString}`);
+  if (G === undefined) {
+    error(`Failed to convert \`0x${gString}\` to a number.`);
+  }
+
+  const bString = hexString.substr(4, 2);
+  const B = tonumber(`0x${bString}`);
+  if (B === undefined) {
+    error(`Failed to convert \`0x${bString}\` to a number.`);
+  }
+
+  // KColor values should be between 0 and 1.
+  const base = 255;
+  return KColor(R / base, G / base, B / base, alpha);
+}
+
+/**
+ * Helper function to return an array with the elements from start to end, inclusive. (The "i"
+ * stands for inclusive.)
+ *
+ * For example, `irange(1, 3)` will return `[1, 2, 3]`.
+ *
+ * If only one argument is specified, then it will assume that the start is 0.
+ */
+export function irange(start: int, end?: int): int[] {
+  if (end === undefined) {
+    end = start;
+    start = 0;
+  }
+
+  const array: int[] = [];
+  for (let i = start; i <= end; i++) {
+    array.push(i);
+  }
+
+  return array;
+}
+
+/**
+ * Since this is a UI element, we do not want to draw it in water reflections. `renderOffset` will
+ * be a non-zero value in reflections.
+ */
+export function isReflectionRender(): boolean {
+  const room = game.GetRoom();
+  const renderMode = room.GetRenderMode();
+  return renderMode === RenderMode.WATER_REFLECT;
+}
+
+/**
+ * Helper function to print something to the in-game console. Use this instead of invoking the
+ * `Isaac.ConsoleOutput` method directly because it will automatically insert a newline at the end
+ * of the message (which `Isaac.ConsoleOutput` does not do by default).
+ */
+export function printConsole(msg: string): void {
+  Isaac.ConsoleOutput(`${msg}\n`);
+}
+
+/** Helper function to print whether something was enabled or disabled to the in-game console. */
+export function printEnabled(enabled: boolean, description: string): void {
+  const enabledText = enabled ? "Enabled" : "Disabled";
+  printConsole(`${enabledText} ${description}.`);
+}
+
+/**
+ * Helper function to repeat code N times. This is faster to type and cleaner than using a for loop.
+ *
+ * For example:
+ *
+ * ```ts
+ * const player = Isaac.GetPlayer();
+ * repeat(10, () => {
+ *   player.AddCollectible(CollectibleType.STEVEN);
+ * });
+ * ```
+ *
+ * The repeated function is passed the index of the iteration, if needed:
+ *
+ * ```ts
+ * repeat(3, (i) => {
+ *   print(i); // Prints "0", "1", "2"
+ * });
+ * ```
+ */
+export function repeat(n: int, func: (i: int) => void): void {
+  for (let i = 0; i < n; i++) {
+    func(i);
+  }
+}
+
+/**
+ * Helper function to signify that the enclosing code block is not yet complete. Using this function
+ * is similar to writing a "TODO" comment, but it has the benefit of preventing ESLint errors due to
+ * early returns.
+ *
+ * When you see this function, it simply means that the programmer intends to add in more code to
+ * this spot later.
+ *
+ * This function does not actually do anything. (It is an "empty" function.)
+ */
+export function todo(): void {}
+
+/**
+ * Helper function to sort a two-dimensional array by the first element.
+ *
+ * For example:
+ *
+ * ```ts
+ * const myArray = [[1, 2], [2, 3], [3, 4]];
+ * myArray.sort(twoDimensionalSort);
+ * ```
+ *
+ * From:
+ * https://stackoverflow.com/questions/16096872/how-to-sort-2-dimensional-array-by-column-value
+ */
+export function twoDimensionalSort<T>(a: T[], b: T[]): -1 | 0 | 1 {
+  if (a[0] === undefined || b[0] === undefined) {
+    error(
+      "Failed to two-dimensional sort since the first element of the array was undefined.",
+    );
+  }
+
+  if (a[0] === b[0]) {
+    return 0;
+  }
+
+  return a[0] < b[0] ? -1 : 1;
+}

package/functions/vector.d.ts

@@ -2,7 +2,7 @@
 import { Direction } from "isaac-typescript-definitions";
 import { SerializationType } from "../enums/SerializationType";
 declare type SerializedVector = LuaTable<string, unknown> & {
-    __serializedVectorBrand: void;
+    readonly __serializedVectorBrand: unique symbol;
 };
 interface CopyVectorReturn {
     [SerializationType.NONE]: Vector;

package/functions/vector.lua

@@ -15,8 +15,6 @@ local getNumbersFromTable = ____table.getNumbersFromTable
 local tableHasKeys = ____table.tableHasKeys
 local ____types = require("functions.types")
 local isTable = ____types.isTable
-local ____utils = require("functions.utils")
-local ensureAllCases = ____utils.ensureAllCases
 --- Helper function to check if something is an instantiated Vector object.
 function ____exports.isVector(self, object)
     return isIsaacAPIClassOfType(nil, object, OBJECT_NAME)
@@ -76,11 +74,6 @@ function ____exports.copyVector(self, vector, serializationType)
                 return Vector(x, y)
             end
         end
-        do
-            do
-                return ensureAllCases(nil, serializationType)
-            end
-        end
     until true
 end
 --- Used to determine is the given table is a serialized `Vector` object created by the save data

package/functions/vector.ts

@@ -0,0 +1,126 @@
+import { Direction } from "isaac-typescript-definitions";
+import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { SerializationType } from "../enums/SerializationType";
+import { angleToDirection } from "./direction";
+import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
+import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
+import { isTable } from "./types";
+
+type SerializedVector = LuaTable<string, unknown> & {
+  readonly __serializedVectorBrand: unique symbol;
+};
+
+interface CopyVectorReturn {
+  [SerializationType.NONE]: Vector;
+  [SerializationType.SERIALIZE]: SerializedVector;
+  [SerializationType.DESERIALIZE]: Vector;
+}
+
+const KEYS = ["X", "Y"];
+const OBJECT_NAME = "Vector";
+
+/**
+ * Helper function to copy a `Vector` object.
+ *
+ * @param vector The vector to copy. In the case of deserialization, this will actually be a Lua
+ *               table instead of an instantiated Vector class.
+ * @param serializationType Default is `SerializationType.NONE`.
+ */
+export function copyVector<
+  V extends Vector | SerializedVector,
+  S extends SerializationType,
+>(vector: V, serializationType: S): CopyVectorReturn[S];
+export function copyVector<V extends Vector | SerializedVector>(
+  vector: V,
+): CopyVectorReturn[SerializationType.NONE];
+export function copyVector(
+  vector: Vector | SerializedVector,
+  serializationType = SerializationType.NONE,
+): CopyVectorReturn[keyof CopyVectorReturn] {
+  switch (serializationType) {
+    case SerializationType.NONE: {
+      if (!isVector(vector)) {
+        error(
+          `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+        );
+      }
+
+      return Vector(vector.X, vector.Y);
+    }
+
+    case SerializationType.SERIALIZE: {
+      if (!isVector(vector)) {
+        error(
+          `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+        );
+      }
+
+      const vectorTable = new LuaTable<string, unknown>();
+      copyValuesToTable(vector, KEYS, vectorTable);
+      vectorTable.set(SerializationBrand.VECTOR, "");
+      return vectorTable as SerializedVector;
+    }
+
+    case SerializationType.DESERIALIZE: {
+      if (!isTable(vector)) {
+        error(
+          `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
+        );
+      }
+
+      const [x, y] = getNumbersFromTable(
+        vector as LuaTable<string, unknown>,
+        OBJECT_NAME,
+        ...KEYS,
+      );
+
+      if (x === undefined) {
+        error(
+          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: x`,
+        );
+      }
+      if (y === undefined) {
+        error(
+          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: y`,
+        );
+      }
+
+      return Vector(x, y);
+    }
+  }
+}
+
+/**
+ * Used to determine is the given table is a serialized `Vector` object created by the save data
+ * manager and/or the `deepCopy` function.
+ */
+export function isSerializedVector(
+  object: unknown,
+): object is SerializedVector {
+  if (!isTable(object)) {
+    return false;
+  }
+
+  return tableHasKeys(object, ...KEYS) && object.has(SerializationBrand.VECTOR);
+}
+
+/** Helper function to check if something is an instantiated Vector object. */
+export function isVector(object: unknown): object is Vector {
+  return isIsaacAPIClassOfType(object, OBJECT_NAME);
+}
+
+export function vectorEquals(vector1: Vector, vector2: Vector): boolean {
+  return isaacAPIClassEquals(vector1, vector2, KEYS);
+}
+
+/** Helper function for finding out which way a vector is pointing. */
+export function vectorToDirection(vector: Vector): Direction {
+  const angleDegrees = vector.GetAngleDegrees();
+  return angleToDirection(angleDegrees);
+}
+
+export function vectorToString(vector: Vector, round = false): string {
+  const x = round ? Math.round(vector.X) : vector.X;
+  const y = round ? Math.round(vector.Y) : vector.Y;
+  return `(${x}, ${y})`;
+}

package/index.ts

@@ -0,0 +1,172 @@
+/* eslint-disable sort-exports/sort-exports */
+
+export * from "./cachedClasses";
+export {
+  initCustomDoor,
+  spawnCustomDoor,
+} from "./callbacks/postCustomDoorEnter";
+export {
+  forceNewLevelCallback,
+  forceNewRoomCallback,
+} from "./callbacks/reorderedCallbacks";
+export * from "./classes/DefaultMap";
+export * from "./classes/ModUpgraded";
+export * from "./constants";
+export * from "./constantsFirstLast";
+export * from "./enums/HealthType";
+export * from "./enums/ModCallbackCustom";
+export * from "./enums/PocketItemType";
+export * from "./enums/SerializationType";
+export {
+  ConversionHeartSubType,
+  registerCharacterHealthConversion,
+} from "./features/characterHealthConversion";
+export { registerCharacterStats } from "./features/characterStats";
+export * from "./features/debugDisplay/exports";
+export {
+  deployJSONRoom,
+  deployRandomJSONRoom,
+  emptyRoom,
+} from "./features/deployJSONRoom";
+export {
+  disableAllInputs,
+  disableAllInputsExceptFor,
+  disableMovementInputs,
+  disableShootingInputs,
+  enableAllInputs,
+  enableAllInputsExceptFor,
+} from "./features/disableInputs";
+export { disableAllSound, enableAllSound } from "./features/disableSound";
+export {
+  addConsoleCommand,
+  enableExtraConsoleCommands,
+  removeConsoleCommand,
+} from "./features/extraConsoleCommands/init";
+export { removeFadeIn, restoreFadeIn } from "./features/fadeInRemover";
+export { disableFastReset, enableFastReset } from "./features/fastReset";
+export { forgottenSwitch } from "./features/forgottenSwitch";
+export { getCollectibleItemPoolType } from "./features/getCollectibleItemPoolType";
+export {
+  removePersistentEntity,
+  spawnPersistentEntity,
+} from "./features/persistentEntities";
+export { getPlayerInventory } from "./features/playerInventory";
+export * from "./features/ponyDetection";
+export { preventCollectibleRotation } from "./features/preventCollectibleRotation";
+export {
+  runInNGameFrames,
+  runInNRenderFrames,
+  runNextGameFrame,
+  runNextRenderFrame,
+} from "./features/runInNFrames";
+export * from "./features/saveDataManager/exports";
+export {
+  hasSirenStolenFamiliar,
+  setFamiliarNoSirenSteal,
+} from "./features/sirenHelpers";
+export { getTaintedLazarusSubPlayer } from "./features/taintedLazarusPlayers";
+export * from "./functions/ambush";
+export * from "./functions/array";
+export * from "./functions/benchmark";
+export * from "./functions/bitwise";
+export * from "./functions/bombs";
+export * from "./functions/boss";
+export * from "./functions/cacheFlag";
+export * from "./functions/cards";
+export * from "./functions/challenges";
+export * from "./functions/character";
+export * from "./functions/charge";
+export * from "./functions/chargeBar";
+export * from "./functions/collectibleCacheFlag";
+export * from "./functions/collectibles";
+export * from "./functions/collectibleSet";
+export * from "./functions/collectibleTag";
+export * from "./functions/color";
+export * from "./functions/debug";
+export { deepCopy } from "./functions/deepCopy";
+export { deepCopyTests } from "./functions/deepCopyTests";
+export * from "./functions/direction";
+export * from "./functions/doors";
+export * from "./functions/easing";
+export * from "./functions/eden";
+export * from "./functions/effects";
+export * from "./functions/entity";
+export * from "./functions/entitySpecific";
+export * from "./functions/entityTypes";
+export * from "./functions/enums";
+export * from "./functions/familiars";
+export * from "./functions/flag";
+export * from "./functions/flying";
+export * from "./functions/globals";
+export * from "./functions/gridEntity";
+export * from "./functions/gridEntitySpecific";
+export * from "./functions/input";
+export * from "./functions/isaacAPIClass";
+export * from "./functions/jsonHelpers";
+export * from "./functions/jsonRoom";
+export * from "./functions/kColor";
+export * from "./functions/language";
+export * from "./functions/level";
+export * from "./functions/log";
+export * from "./functions/map";
+export * from "./functions/math";
+export { mergeTests } from "./functions/mergeTests";
+export * from "./functions/npc";
+export * from "./functions/pickups";
+export * from "./functions/pickupVariants";
+export * from "./functions/pills";
+export * from "./functions/player";
+export * from "./functions/playerDataStructures";
+export * from "./functions/playerHealth";
+export * from "./functions/playerIndex";
+export * from "./functions/pocketItems";
+export * from "./functions/positionVelocity";
+export * from "./functions/random";
+export * from "./functions/revive";
+export * from "./functions/rng";
+export * from "./functions/roomData";
+export * from "./functions/roomGrid";
+export * from "./functions/rooms";
+export * from "./functions/roomShape";
+export * from "./functions/run";
+export * from "./functions/saveFile";
+export * from "./functions/seeds";
+export * from "./functions/serialization";
+export * from "./functions/set";
+export * from "./functions/sound";
+export * from "./functions/spawnCollectible";
+export * from "./functions/sprite";
+export * from "./functions/stage";
+export * from "./functions/string";
+export * from "./functions/table";
+export * from "./functions/tears";
+export * from "./functions/transformations";
+export * from "./functions/trinketCacheFlag";
+export * from "./functions/trinketGive";
+export * from "./functions/trinkets";
+export * from "./functions/tstlClass";
+export * from "./functions/types";
+export * from "./functions/ui";
+export * from "./functions/utils";
+export * from "./functions/vector";
+export * from "./interfaces/AddCallbackParameterCustom";
+export * from "./interfaces/ChargeBarSprites";
+export * from "./interfaces/JSONDoor";
+export * from "./interfaces/JSONEntity";
+export * from "./interfaces/JSONRoom";
+export * from "./interfaces/JSONRooms";
+export * from "./interfaces/JSONSpawn";
+export * from "./interfaces/PlayerHealth";
+export * from "./interfaces/PocketItemDescription";
+export * from "./interfaces/SaveData";
+export * from "./interfaces/TrinketSituation";
+export * from "./maps/cardMap";
+export * from "./maps/characterMap";
+export * from "./maps/pillEffectMap";
+export * from "./maps/roomTypeMap";
+export * from "./objects/colors";
+export * from "./types/AnyEntity";
+export * from "./types/CollectibleIndex";
+export * from "./types/PickingUpItem";
+export * from "./types/PlayerIndex";
+export * from "./upgradeMod";

package/initCustomCallbacks.ts

@@ -0,0 +1,132 @@
+import { customReviveCallbacksInit } from "./callbacks/customRevive";
+import { itemPickupCallbacksInit } from "./callbacks/itemPickup";
+import { postAmbushCallbacksInit } from "./callbacks/postAmbush";
+import { postBombExplodedInit } from "./callbacks/postBombExploded";
+import { postBombInitLateInit } from "./callbacks/postBombInitLate";
+import { postBoneSwingInit } from "./callbacks/postBoneSwing";
+import { postCollectibleInitFirstInit } from "./callbacks/postCollectibleInitFirst";
+import { postCursedTeleportInit } from "./callbacks/postCursedTeleport";
+import { postCustomDoorEnterInit } from "./callbacks/postCustomDoorEnter";
+import { postDiceRoomActivatedInit } from "./callbacks/postDiceRoomActivated";
+import { postDoorRenderInit } from "./callbacks/postDoorRender";
+import { postDoorUpdateInit } from "./callbacks/postDoorUpdate";
+import { postEffectInitLateInit } from "./callbacks/postEffectInitLate";
+import { postEffectStateChangedInit } from "./callbacks/postEffectStateChanged";
+import { postEsauJrCallbacksInit } from "./callbacks/postEsauJr";
+import { postFamiliarInitLateInit } from "./callbacks/postFamiliarInitLate";
+import { postFamiliarStateChangedInit } from "./callbacks/postFamiliarStateChanged";
+import { postFlipCallbacksInit } from "./callbacks/postFlip";
+import { postGreedModeWaveInit } from "./callbacks/postGreedModeWave";
+import { postGridEntityCallbacksInit } from "./callbacks/postGridEntity";
+import { postGridEntityCollisionInit } from "./callbacks/postGridEntityCollision";
+import { postGridEntityRenderInit } from "./callbacks/postGridEntityRender";
+import { postHolyMantleRemovedInit } from "./callbacks/postHolyMantleRemoved";
+import { postItemDischargeInit } from "./callbacks/postItemDischarged";
+import { postKnifeInitLateInit } from "./callbacks/postKnifeInitLate";
+import { postLaserInitLateInit } from "./callbacks/postLaserInitLate";
+import { postNPCInitLateInit } from "./callbacks/postNPCInitLate";
+import { postNPCStateChangedInit } from "./callbacks/postNPCStateChanged";
+import { postPickupCollectInit } from "./callbacks/postPickupCollect";
+import { postPickupInitFirstInit } from "./callbacks/postPickupInitFirst";
+import { postPickupInitLateInit } from "./callbacks/postPickupInitLate";
+import { postPickupStateChangedInit } from "./callbacks/postPickupStateChanged";
+import { postPitRenderInit } from "./callbacks/postPitRender";
+import { postPitUpdateInit } from "./callbacks/postPitUpdate";
+import { postPlayerChangeHealthInit } from "./callbacks/postPlayerChangeHealth";
+import { postPlayerChangeTypeInit } from "./callbacks/postPlayerChangeType";
+import { postPlayerCollectibleCallbacksInit } from "./callbacks/postPlayerCollectible";
+import { postPlayerFatalDamageInit } from "./callbacks/postPlayerFatalDamage";
+import { postPlayerInitLateInit } from "./callbacks/postPlayerInitLate";
+import { postPlayerReorderedCallbacksInit } from "./callbacks/postPlayerReordered";
+import { postPoopRenderInit } from "./callbacks/postPoopRender";
+import { postPoopUpdateInit } from "./callbacks/postPoopUpdate";
+import { postPressurePlateRenderInit } from "./callbacks/postPressurePlateRender";
+import { postPressurePlateUpdateInit } from "./callbacks/postPressurePlateUpdate";
+import { postProjectileInitLateInit } from "./callbacks/postProjectileInitLate";
+import { postPurchaseInit } from "./callbacks/postPurchase";
+import { postRockRenderInit } from "./callbacks/postRockRender";
+import { postRockUpdateInit } from "./callbacks/postRockUpdate";
+import { postRoomClearChangedInit } from "./callbacks/postRoomClearChanged";
+import { postSacrificeInit } from "./callbacks/postSacrifice";
+import { postSlotDestroyedInit } from "./callbacks/postSlotDestroyed";
+import { postSlotInitUpdateCallbacksInit } from "./callbacks/postSlotInitUpdate";
+import { postSlotRenderCallbacksInit } from "./callbacks/postSlotRender";
+import { postSpikesRenderInit } from "./callbacks/postSpikesRender";
+import { postSpikesUpdateInit } from "./callbacks/postSpikesUpdate";
+import { postTearInitLateInit } from "./callbacks/postTearInitLate";
+import { postTearInitVeryLateInit } from "./callbacks/postTearInitVeryLate";
+import { postTNTRenderInit } from "./callbacks/postTNTRender";
+import { postTNTUpdateInit } from "./callbacks/postTNTUpdate";
+import { postTransformationInit } from "./callbacks/postTransformation";
+import { postTrinketBreakInit } from "./callbacks/postTrinketBreak";
+import { preBerserkDeathInit } from "./callbacks/preBerserkDeath";
+import { preNewLevelInit } from "./callbacks/preNewLevel";
+import { reorderedCallbacksInit } from "./callbacks/reorderedCallbacks";
+import { ModUpgraded } from "./classes/ModUpgraded";
+
+export function initCustomCallbacks(mod: ModUpgraded): void {
+  customReviveCallbacksInit(mod);
+  itemPickupCallbacksInit(mod);
+  postAmbushCallbacksInit(mod);
+  postBombExplodedInit(mod);
+  postBombInitLateInit(mod);
+  postBoneSwingInit(mod);
+  postCollectibleInitFirstInit(mod);
+  postCursedTeleportInit(mod);
+  postCustomDoorEnterInit();
+  postDiceRoomActivatedInit(mod);
+  postDoorRenderInit(mod);
+  postDoorUpdateInit(mod);
+  postEffectInitLateInit(mod);
+  postEffectStateChangedInit(mod);
+  postEsauJrCallbacksInit(mod);
+  postFamiliarInitLateInit(mod);
+  postFamiliarStateChangedInit(mod);
+  postFlipCallbacksInit(mod);
+  postGreedModeWaveInit(mod);
+  postGridEntityCallbacksInit(mod);
+  postGridEntityCollisionInit(mod);
+  postGridEntityRenderInit(mod);
+  postHolyMantleRemovedInit(mod);
+  postItemDischargeInit(mod);
+  postLaserInitLateInit(mod);
+  postKnifeInitLateInit(mod);
+  postNPCInitLateInit(mod);
+  postNPCStateChangedInit(mod);
+  postPickupCollectInit(mod);
+  postPickupInitFirstInit(mod);
+  postPickupInitLateInit(mod);
+  postPickupStateChangedInit(mod);
+  postPitRenderInit(mod);
+  postPitUpdateInit(mod);
+  postPlayerChangeHealthInit(mod);
+  postPlayerChangeTypeInit(mod);
+  postPlayerCollectibleCallbacksInit(mod);
+  postPlayerFatalDamageInit(mod);
+  postPlayerInitLateInit(mod);
+  postPlayerReorderedCallbacksInit(mod);
+  postPoopRenderInit(mod);
+  postPoopUpdateInit(mod);
+  postPressurePlateRenderInit(mod);
+  postPressurePlateUpdateInit(mod);
+  postProjectileInitLateInit(mod);
+  postPurchaseInit(mod);
+  postRockRenderInit(mod);
+  postRockUpdateInit(mod);
+  postRoomClearChangedInit(mod);
+  postSacrificeInit(mod);
+  postSlotDestroyedInit(mod);
+  postSlotInitUpdateCallbacksInit(mod);
+  postSlotRenderCallbacksInit(mod);
+  postSpikesRenderInit(mod);
+  postSpikesUpdateInit(mod);
+  postTearInitLateInit(mod);
+  postTearInitVeryLateInit(mod);
+  postTNTRenderInit(mod);
+  postTNTUpdateInit(mod);
+  postTransformationInit(mod);
+  postTrinketBreakInit(mod);
+  preBerserkDeathInit(mod);
+  preNewLevelInit(mod);
+  reorderedCallbacksInit(mod);
+}