isaacscript-common 6.11.0 → 6.12.0

package/src/callbacks/itemPickup.ts

@@ -1,6 +1,6 @@
-// This provides the logic for:
-// - PRE_ITEM_PICKUP
-// - POST_ITEM_PICKUP
+// This provides the logic for the following callbacks:
+// - `PRE_ITEM_PICKUP`
+// - `POST_ITEM_PICKUP`
 
 import {
   CollectibleType,

package/src/callbacks/postAmbush.ts

@@ -1,6 +1,6 @@
-// This provides the logic for:
-// - POST_AMBUSH_STARTED
-// - POST_AMBUSH_FINISHED
+// This provides the logic for the following callbacks:
+// - `POST_AMBUSH_STARTED`
+// - `POST_AMBUSH_FINISHED`
 
 import { ModCallback, RoomType } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";

package/src/callbacks/postEsauJr.ts

@@ -1,6 +1,6 @@
-// This provides the logic for:
-// - POST_ESAU_JR
-// - POST_FIRST_ESAU_JR
+// This provides the logic for the following callbacks:
+// - `POST_ESAU_JR`
+// - `POST_FIRST_ESAU_JR`
 
 import {
   CollectibleType,

package/src/callbacks/postFlip.ts

@@ -1,6 +1,6 @@
-// This provides the logic for:
-// - POST_FLIP
-// - POST_FIRST_FLIP
+// This provides the logic for the following callbacks:
+// - `POST_FLIP`
+// - `POST_FIRST_FLIP`
 
 import {
   CollectibleType,
@@ -21,6 +21,7 @@ import {
 
 const v = {
   run: {
+    /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
     usedFlipAtLeastOnce: false,
   },
 };
@@ -63,10 +64,10 @@ function useItemFlip(
 
   if (!v.run.usedFlipAtLeastOnce) {
     v.run.usedFlipAtLeastOnce = true;
-    postFirstFlipFire(newLazarus);
+    postFirstFlipFire(newLazarus, player);
   }
 
-  postFlipFire(newLazarus);
+  postFlipFire(newLazarus, player);
 
   return undefined;
 }

package/src/callbacks/postGridEntity.ts

@@ -1,9 +1,9 @@
 // This provides the logic for the following callbacks:
-// - PostGridEntityInit
-// - PostGridEntityUpdate
-// - PostGridEntityRemove
-// - PostGridEntityStateChanged
-// - PostGridEntityBroken
+// - `POST_GRID_ENTITY_INIT`
+// - `POST_GRID_ENTITY_UPDATE`
+// - `POST_GRID_ENTITY_REMOVE`
+// - `POST_GRID_ENTITY_STATE_CHANGED`
+// - `POST_GRID_ENTITY_BROKEN`
 
 import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../classes/ModUpgraded";

package/src/callbacks/postGridEntityCustomRender.ts

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

package/src/callbacks/postGridEntityCustomUpdate.ts

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

package/src/callbacks/postNewRoomEarly.ts

@@ -67,7 +67,7 @@ function checkRoomChanged() {
     topLeftWall = spawnGridEntity(GridEntityType.WALL, topLeftWallGridIndex);
     if (topLeftWall === undefined) {
       logError(
-        "Failed to spawn a new wall (1) for the PostNewRoomEarly callback.",
+        "Failed to spawn a new wall (1) for the POST_NEW_ROOM_EARLY callback.",
       );
       return;
     }
@@ -82,7 +82,7 @@ function checkRoomChanged() {
     );
     if (topLeftWall2 === undefined) {
       logError(
-        "Failed to spawn a new wall (2) for the PostNewRoomEarly callback.",
+        "Failed to spawn a new wall (2) for the POST_NEW_ROOM_EARLY callback.",
       );
       return;
     }

package/src/callbacks/postPickupInitFirst.ts

@@ -1,31 +1,13 @@
-import {
-  GameStateFlag,
-  ModCallback,
-  RoomType,
-} from "isaac-typescript-definitions";
+import { ModCallback } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
-import { saveDataManager } from "../features/saveDataManager/exports";
 import { getRoomVisitedCount } from "../functions/roomData";
 import {
   postPickupInitFirstFire,
   postPickupInitFirstHasSubscriptions,
 } from "./subscriptions/postPickupInitFirst";
 
-const POST_ASCENT_ROOM_TYPES: ReadonlySet<RoomType> = new Set([
-  RoomType.TREASURE,
-  RoomType.BOSS,
-]);
-
-const v = {
-  run: {
-    postAscentPickupInitSeeds: new Set<int>(),
-  },
-};
-
 /** @internal */
 export function postPickupInitFirstInit(mod: Mod): void {
-  saveDataManager("postPickupInitFirst", v, hasSubscriptions);
-
   mod.AddCallback(ModCallback.POST_PICKUP_INIT, postPickupInit); // 34
 }
 
@@ -40,15 +22,8 @@ function postPickupInit(pickup: EntityPickup) {
   }
 
   const room = game.GetRoom();
-  const roomType = room.GetType();
   const roomFrameCount = room.GetFrameCount();
 
-  // First, keep track of pickups in rooms that could appear again in The Ascent.
-  const previouslySeen = v.run.postAscentPickupInitSeeds.has(pickup.InitSeed);
-  if (POST_ASCENT_ROOM_TYPES.has(roomType)) {
-    v.run.postAscentPickupInitSeeds.add(pickup.InitSeed);
-  }
-
   if (roomFrameCount > 0) {
     postPickupInitFirstFire(pickup);
     return;
@@ -59,12 +34,6 @@ function postPickupInit(pickup: EntityPickup) {
     return;
   }
 
-  // Handle the special case of a post-Ascent Treasure Room or Boss Room.
-  const onAscent = game.GetStateFlag(GameStateFlag.BACKWARDS_PATH);
-  if (onAscent && POST_ASCENT_ROOM_TYPES.has(roomType) && previouslySeen) {
-    return;
-  }
-
   // We are entering a brand-new room.
   postPickupInitFirstFire(pickup);
 }

package/src/callbacks/postPlayerCollectible.ts

@@ -1,6 +1,6 @@
 // This provides the logic for the following callbacks:
-// - PostPlayerCollectibleAdded
-// - PostPlayerCollectibleRemoved
+// - `POST_PLAYER_COLLECTIBLE_ADDED`
+// - `POST_PLAYER_COLLECTIBLE_REMOVED`
 
 import { CollectibleType, ModCallback } from "isaac-typescript-definitions";
 import { DefaultMap } from "../classes/DefaultMap";

package/src/callbacks/postPlayerFatalDamage.ts

@@ -1,10 +1,12 @@
 import {
+  ActiveSlot,
   BossID,
   CollectibleType,
   DamageFlag,
   DamageFlagZero,
   EntityType,
   ModCallback,
+  UseFlag,
 } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
 import { saveDataManager } from "../features/saveDataManager/exports";
@@ -113,6 +115,9 @@ function preUseItemBible(
   _collectibleType: CollectibleType,
   _rng: RNG,
   player: EntityPlayer,
+  _useFlags: BitFlags<UseFlag>,
+  _activeSlot: ActiveSlot,
+  _customVarData: int,
 ): boolean | undefined {
   if (!hasSubscriptions()) {
     return undefined;

package/src/callbacks/postPlayerInitFirst.ts

@@ -0,0 +1,57 @@
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { getPlayers, isChildPlayer } from "../functions/playerIndex";
+import { inGenesisRoom } from "../functions/rooms";
+import {
+  postPlayerInitFirstFire,
+  postPlayerInitFirstHasSubscriptions,
+} from "./subscriptions/postPlayerInitFirst";
+
+/** @internal */
+export function postPlayerInitFirstInit(mod: ModUpgraded): void {
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
+    postNewRoomReordered,
+  );
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PLAYER_INIT_LATE,
+    postPlayerInitLate,
+  );
+}
+
+function hasSubscriptions() {
+  return postPlayerInitFirstHasSubscriptions();
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // When a player uses the Genesis collectible, they will lose all of their collectibles, trinkets,
+  // pocket items, and stats, so they will need to be re-initialized like they would be at the
+  // beginning of a run. However, in this case, the `POST_PLAYER_INIT_FIRST` callback will not fire,
+  // because that only fires once per run. Thus, we explicitly handle this special case.
+  if (!inGenesisRoom()) {
+    return;
+  }
+
+  for (const player of getPlayers()) {
+    postPlayerInitFirstFire(player);
+  }
+}
+
+// ModCallback.POST_PEFFECT_UPDATE (4)
+function postPlayerInitLate(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // We want to exclude non-real players like the Strawman keeper.
+  if (isChildPlayer(player)) {
+    return;
+  }
+
+  postPlayerInitFirstFire(player);
+}

package/src/callbacks/postPlayerInitLate.ts

@@ -1,4 +1,5 @@
-import { ModCallback } from "isaac-typescript-definitions";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { saveDataManager } from "../features/saveDataManager/exports";
 import { setAddPlayer, setHasPlayer } from "../functions/playerDataStructures";
 import { PlayerIndex } from "../types/PlayerIndex";
@@ -14,18 +15,21 @@ const v = {
 };
 
 /** @internal */
-export function postPlayerInitLateInit(mod: Mod): void {
+export function postPlayerInitLateInit(mod: ModUpgraded): void {
   saveDataManager("postPlayerInitLate", v, hasSubscriptions);
 
-  mod.AddCallback(ModCallback.POST_PLAYER_UPDATE, postPlayerUpdate); // 31
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
 }
 
 function hasSubscriptions() {
   return postPlayerInitLateHasSubscriptions();
 }
 
-// ModCallback.POST_PLAYER_UPDATE (31)
-function postPlayerUpdate(player: EntityPlayer) {
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
   if (!hasSubscriptions()) {
     return;
   }

package/src/callbacks/{postPlayerReordered.ts → postPlayerReorderedCallbacks.ts}

@@ -1,3 +1,8 @@
+// This handles logic for the following callbacks:
+// - POST_PEFFECT_UPDATE_REORDERED
+// - POST_PLAYER_RENDER_REORDERED
+// - POST_PLAYER_UPDATE_REORDERED
+
 import { ModCallback } from "isaac-typescript-definitions";
 import { saveDataManager } from "../features/saveDataManager/exports";
 import { emptyArray } from "../functions/array";
@@ -7,10 +12,6 @@ import {
   postPEffectUpdateReorderedFire,
   postPEffectUpdateReorderedHasSubscriptions,
 } from "./subscriptions/postPEffectUpdateReordered";
-import {
-  postPlayerInitReorderedFire,
-  postPlayerInitReorderedHasSubscriptions,
-} from "./subscriptions/postPlayerInitReordered";
 import {
   postPlayerRenderReorderedFire,
   postPlayerRenderReorderedHasSubscriptions,
@@ -24,7 +25,6 @@ const v = {
   run: {
     postGameStartedFiredOnThisRun: false,
 
-    postPlayerInitQueue: [] as PlayerIndex[],
     postPEffectUpdateQueue: [] as PlayerIndex[],
     postPlayerUpdateQueue: [] as PlayerIndex[],
     postPlayerRenderQueue: [] as PlayerIndex[],
@@ -36,16 +36,13 @@ export function postPlayerReorderedCallbacksInit(mod: Mod): void {
   saveDataManager("postPlayerReordered", v, hasSubscriptions);
 
   mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
-  mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit); // 9
+  mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
   mod.AddCallback(ModCallback.POST_PLAYER_UPDATE, postPlayerUpdate); // 31
   mod.AddCallback(ModCallback.POST_PLAYER_RENDER, postPlayerRender); // 32
-
-  mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
 }
 
 function hasSubscriptions() {
   return (
-    postPlayerInitReorderedHasSubscriptions() ||
     postPEffectUpdateReorderedHasSubscriptions() ||
     postPlayerUpdateReorderedHasSubscriptions() ||
     postPlayerRenderReorderedHasSubscriptions()
@@ -61,27 +58,12 @@ function postPEffectUpdate(player: EntityPlayer) {
   if (v.run.postGameStartedFiredOnThisRun) {
     postPEffectUpdateReorderedFire(player);
   } else {
-    // Defer callback execution until the PostGameStarted callback fires.
+    // Defer callback execution until the `POST_GAME_STARTED` callback fires.
     const playerIndex = getPlayerIndex(player);
     v.run.postPEffectUpdateQueue.push(playerIndex);
   }
 }
 
-// ModCallback.POST_PLAYER_INIT (9)
-function postPlayerInit(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (v.run.postGameStartedFiredOnThisRun) {
-    postPlayerInitReorderedFire(player);
-  } else {
-    // Defer callback execution until the PostGameStarted callback fires.
-    const playerIndex = getPlayerIndex(player);
-    v.run.postPlayerInitQueue.push(playerIndex);
-  }
-}
-
 // ModCallback.POST_PLAYER_UPDATE (31)
 function postPlayerUpdate(player: EntityPlayer) {
   if (!hasSubscriptions()) {
@@ -91,7 +73,7 @@ function postPlayerUpdate(player: EntityPlayer) {
   if (v.run.postGameStartedFiredOnThisRun) {
     postPlayerUpdateReorderedFire(player);
   } else {
-    // Defer callback execution until the PostGameStarted callback fires.
+    // Defer callback execution until the `POST_GAME_STARTED` callback fires.
     const playerIndex = getPlayerIndex(player);
     v.run.postPlayerUpdateQueue.push(playerIndex);
   }
@@ -106,7 +88,7 @@ function postPlayerRender(player: EntityPlayer) {
   if (v.run.postGameStartedFiredOnThisRun) {
     postPlayerRenderReorderedFire(player);
   } else {
-    // Defer callback execution until the PostGameStarted callback fires.
+    // Defer callback execution until the `POST_GAME_STARTED` callback fires.
     const playerIndex = getPlayerIndex(player);
     v.run.postPlayerRenderQueue.push(playerIndex);
   }
@@ -120,7 +102,7 @@ function postGameStarted() {
 
   v.run.postGameStartedFiredOnThisRun = true;
 
-  dequeue(v.run.postPlayerInitQueue, postPlayerInitReorderedFire);
+  dequeue(v.run.postPEffectUpdateQueue, postPEffectUpdateReorderedFire);
   dequeue(v.run.postPlayerUpdateQueue, postPlayerUpdateReorderedFire);
   dequeue(v.run.postPlayerRenderQueue, postPlayerRenderReorderedFire);
 }
@@ -131,11 +113,9 @@ function dequeue(
 ) {
   for (const playerIndex of playerIndexes) {
     const player = getPlayerFromIndex(playerIndex);
-    if (player === undefined) {
-      continue;
+    if (player !== undefined) {
+      fireFunction(player);
     }
-
-    fireFunction(player);
   }
 
   emptyArray(playerIndexes);

package/src/callbacks/postSlotInitUpdate.ts

@@ -1,5 +1,8 @@
-// This provides the logic for the PostSlotInit and PostSlotUpdate callbacks. (The other slot
-// callbacks are handled in a different file.)
+// This provides the logic for the following callbacks:
+// - `POST_SLOT_INIT`
+// - `POST_SLOT_UPDATE`
+
+// (The other slot callbacks are handled in a different file.)
 
 import { ModCallback } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../classes/ModUpgraded";

package/src/callbacks/postSlotRender.ts

@@ -1,6 +1,6 @@
 // This provides the logic for the following callbacks:
-// - PostSlotRender
-// - PostSlotAnimationChanged
+// - `POST_SLOT_RENDER`
+// - `POST_SLOT_ANIMATION_CHANGED`
 
 import { ModCallback } from "isaac-typescript-definitions";
 import { DefaultMap } from "../classes/DefaultMap";

package/src/callbacks/reorderedCallbacks.ts

@@ -1,4 +1,4 @@
-// This provides the logic for:
+// This provides the logic for the following callbacks:
 // - `POST_GAME_STARTED_REORDERED`
 // - `POST_NEW_LEVEL_REORDERED`
 // - `POST_NEW_ROOM_REORDERED`
@@ -61,7 +61,7 @@ function hasSubscriptions() {
 // CollectibleType.GLOWING_HOUR_GLASS (422)
 function useItemGlowingHourGlass(): boolean | undefined {
   // If Glowing Hour Glass is used on the first room of a floor, it will send the player to the
-  // previous floor without triggering the PostNewLevel callback. Manually check for this.
+  // previous floor without triggering the `POST_NEW_LEVEL` callback. Manually check for this.
   usedGlowingHourGlass = true;
 
   return undefined;
@@ -88,7 +88,7 @@ function postNewLevelVanilla() {
   const gameFrameCount = game.GetFrameCount();
 
   if (gameFrameCount === 0 && !forceNewLevel) {
-    // Wait for the PostGameStarted callback to fire.
+    // Wait for the `POST_GAME_STARTED` callback to fire.
     return;
   }
   forceNewLevel = false;
@@ -114,7 +114,8 @@ function postNewRoomVanilla() {
 
     if (currentStage !== stage || currentStageType !== stageType) {
       // The player has used the Glowing Hour Glass to take them to the previous floor (which does
-      // not trigger the PostNewLevel callback). Emulate what happens in the PostNewLevel callback.
+      // not trigger the `POST_NEW_LEVEL` callback). Emulate what happens in the `POST_NEW_LEVEL`
+      // callback.
       recordCurrentStage();
       postNewLevelReorderedFire();
       postNewRoomReorderedFire();
@@ -149,9 +150,9 @@ function recordCurrentStage() {
  * callback.
  *
  * If some specific cases, mods can change the current level during run initialization on the 0th
- * frame. However, due to how the callback reordering works, the custom PostNewLevel callback will
- * never fire on the 0th frame. To get around this, call this function before changing levels to
- * temporarily force the callback to fire.
+ * frame. However, due to how the callback reordering works, the custom `POST_NEW_LEVEL` callback
+ * will never fire on the 0th frame. To get around this, call this function before changing levels
+ * to temporarily force the callback to fire.
  */
 export function forceNewLevelCallback(): void {
   forceNewLevel = true;
@@ -162,8 +163,8 @@ export function forceNewLevelCallback(): void {
  * callback.
  *
  * If some specific cases, mods can change the current room during run initialization on the 0th
- * frame. However, due to how the callback reordering works, the custom PostNewRoom callback will
- * never fire on the 0th frame. To get around this, call this function before changing rooms to
+ * frame. However, due to how the callback reordering works, the custom `POST_NEW_ROOM` callback
+ * will never fire on the 0th frame. To get around this, call this function before changing rooms to
  * temporarily force the callback to fire.
  */
 export function forceNewRoomCallback(): void {

package/src/callbacks/subscriptions/postFirstFlip.ts

@@ -1,5 +1,5 @@
 export type PostFirstFlipRegisterParameters = [
-  callback: (player: EntityPlayer) => void,
+  callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void,
 ];
 
 const subscriptions: PostFirstFlipRegisterParameters[] = [];
@@ -17,8 +17,11 @@ export function postFirstFlipRegister(
 }
 
 /** @internal */
-export function postFirstFlipFire(player: EntityPlayer): void {
+export function postFirstFlipFire(
+  newLazarus: EntityPlayer,
+  oldLazarus: EntityPlayer,
+): void {
   for (const [callback] of subscriptions) {
-    callback(player);
+    callback(newLazarus, oldLazarus);
   }
 }

package/src/callbacks/subscriptions/postFlip.ts

@@ -1,5 +1,5 @@
 export type PostFlipRegisterParameters = [
-  callback: (player: EntityPlayer) => void,
+  callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void,
 ];
 
 const subscriptions: PostFlipRegisterParameters[] = [];
@@ -15,8 +15,11 @@ export function postFlipRegister(...args: PostFlipRegisterParameters): void {
 }
 
 /** @internal */
-export function postFlipFire(player: EntityPlayer): void {
+export function postFlipFire(
+  newLazarus: EntityPlayer,
+  oldLazarus: EntityPlayer,
+): void {
   for (const [callback] of subscriptions) {
-    callback(player);
+    callback(newLazarus, oldLazarus);
   }
 }

package/src/callbacks/subscriptions/postGridEntityCustomRender.ts

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