isaacscript-common 2.0.34 → 2.3.0

package/src/callbacks/postNewRoomEarly.ts

@@ -0,0 +1,90 @@
+import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { getTopLeftWallGridIndex, spawnGrid } from "../functions/gridEntity";
+import { logError } from "../functions/log";
+import {
+  postNewRoomEarlyFire,
+  postNewRoomEarlyHasSubscriptions,
+} from "./subscriptions/postNewRoomEarly";
+
+let currentRoomTopLeftWallPtrHash: PtrHash | null = null;
+
+/**
+ * The wall entity directly to the right of the top-left wall. We use this as a test to see if it
+ * improves the consistency of the callback firing.
+ */
+let currentRoomTopLeftWallPtrHash2: PtrHash | null = null;
+
+/** @internal */
+export function postNewRoomEarlyCallbackInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_NEW_ROOM, postNewRoom); // 19
+  mod.AddCallback(ModCallback.PRE_ENTITY_SPAWN, preEntitySpawn); // 24
+}
+
+function hasSubscriptions() {
+  return postNewRoomEarlyHasSubscriptions();
+}
+
+// ModCallback.POST_NEW_ROOM (19)
+function postNewRoom() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  checkRoomChanged();
+}
+
+// ModCallback.PRE_ENTITY_SPAWN (24)
+function preEntitySpawn() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  checkRoomChanged();
+}
+
+function checkRoomChanged() {
+  const room = game.GetRoom();
+  const topLeftWallGridIndex = getTopLeftWallGridIndex();
+  const rightOfTopWallGridIndex = topLeftWallGridIndex + 1;
+
+  let topLeftWall = room.GetGridEntity(topLeftWallGridIndex);
+  let topLeftWall2 = room.GetGridEntity(rightOfTopWallGridIndex);
+
+  // Sometimes, the PreEntitySpawn callback can fire before any grid entities in the room have
+  // spawned, which means that the top-left wall will not exist. If ths is the case, then simply
+  // spawn the top-left wall early.
+  if (topLeftWall === undefined) {
+    topLeftWall = spawnGrid(GridEntityType.WALL, topLeftWallGridIndex);
+    if (topLeftWall === undefined) {
+      logError(
+        "Failed to spawn a new wall (1) for the PostNewRoomEarly callback.",
+      );
+      return;
+    }
+  }
+
+  // For some reason, the above check will rarely fail. We duplicate the check with another wall
+  // segment to go from 99% to 100% reliability.
+  if (topLeftWall2 === undefined) {
+    topLeftWall2 = spawnGrid(GridEntityType.WALL, rightOfTopWallGridIndex);
+    if (topLeftWall2 === undefined) {
+      logError(
+        "Failed to spawn a new wall (2) for the PostNewRoomEarly callback.",
+      );
+      return;
+    }
+  }
+
+  const topLeftWallPtrHash = GetPtrHash(topLeftWall);
+  const topLeftWallPtrHash2 = GetPtrHash(topLeftWall2);
+  if (
+    topLeftWallPtrHash !== currentRoomTopLeftWallPtrHash ||
+    topLeftWallPtrHash2 !== currentRoomTopLeftWallPtrHash2
+  ) {
+    currentRoomTopLeftWallPtrHash = topLeftWallPtrHash;
+    currentRoomTopLeftWallPtrHash2 = topLeftWallPtrHash2;
+
+    postNewRoomEarlyFire();
+  }
+}

package/src/callbacks/postPickupCollect.ts

@@ -0,0 +1,48 @@
+// Some pickup properties cannot be retrieved properly in the PostPickupInit callback and must be
+// checked in the PostPickupUpdate callback. This fires on the first update frame.
+
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getClosestPlayer } from "../functions/player";
+import {
+  postPickupCollectFire,
+  postPickupCollectHasSubscriptions,
+} from "./subscriptions/postPickupCollect";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postPickupCollectCallbackInit(mod: Mod): void {
+  saveDataManager("postPickupCollect", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_RENDER, postPickupRender); // 36
+}
+
+function hasSubscriptions() {
+  return postPickupCollectHasSubscriptions();
+}
+
+// ModCallback.POST_PICKUP_RENDER (36)
+function postPickupRender(pickup: EntityPickup) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const sprite = pickup.GetSprite();
+  const animation = sprite.GetAnimation();
+  if (animation !== "Collect") {
+    return;
+  }
+
+  const index = GetPtrHash(pickup);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+
+    const player = getClosestPlayer(pickup.Position);
+    postPickupCollectFire(pickup, player);
+  }
+}

package/src/callbacks/postPickupInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postPickupInitLateFire,
+  postPickupInitLateHasSubscriptions,
+} from "./subscriptions/postPickupInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postPickupInitLateCallbackInit(mod: Mod): void {
+  saveDataManager("postPickupInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdate); // 35
+}
+
+function hasSubscriptions() {
+  return postPickupInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_PICKUP_UPDATE (35)
+function postPickupUpdate(pickup: EntityPickup) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(pickup);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postPickupInitLateFire(pickup);
+  }
+}

package/src/callbacks/postPickupStateChanged.ts

@@ -0,0 +1,43 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postPickupStateChangedFire,
+  postPickupStateChangedHasSubscriptions,
+} from "./subscriptions/postPickupStateChanged";
+
+const v = {
+  run: {
+    pickupStateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+  },
+};
+
+/** @internal */
+export function postPickupStateChangedCallbackInit(mod: Mod): void {
+  saveDataManager("postPickupStateChanged", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdate); // 35
+}
+
+function hasSubscriptions() {
+  return postPickupStateChangedHasSubscriptions();
+}
+
+// ModCallback.POST_PICKUP_UPDATE (35)
+function postPickupUpdate(pickup: EntityPickup) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const ptrHash = GetPtrHash(pickup);
+  const previousState = v.run.pickupStateMap.getAndSetDefault(
+    ptrHash,
+    pickup.State,
+  );
+  const currentState = pickup.State;
+  v.run.pickupStateMap.set(ptrHash, currentState);
+
+  if (previousState !== currentState) {
+    postPickupStateChangedFire(pickup, previousState, currentState);
+  }
+}

package/src/callbacks/postPitRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPits } from "../functions/gridEntitySpecific";
+import {
+  postPitRenderFire,
+  postPitRenderHasSubscriptions,
+} from "./subscriptions/postPitRender";
+
+/** @internal */
+export function postPitRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postPitRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const pit of getPits()) {
+    postPitRenderFire(pit);
+  }
+}

package/src/callbacks/postPitUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPits } from "../functions/gridEntitySpecific";
+import {
+  postPitUpdateFire,
+  postPitUpdateHasSubscriptions,
+} from "./subscriptions/postPitUpdate";
+
+/** @internal */
+export function postPitUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postPitUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const pit of getPits()) {
+    postPitUpdateFire(pit);
+  }
+}

package/src/callbacks/postPlayerChangeHealth.ts

@@ -0,0 +1,62 @@
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { HealthType } from "../enums/HealthType";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getEnumValues } from "../functions/enums";
+import { getPlayerHealthType } from "../functions/playerHealth";
+import { getPlayerIndex } from "../functions/playerIndex";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postPlayerChangeHealthFire,
+  postPlayerChangeHealthHasSubscriptions,
+} from "./subscriptions/postPlayerChangeHealth";
+
+const v = {
+  run: {
+    playersHealthMap: new DefaultMap<PlayerIndex, Map<HealthType, int>>(
+      () => new Map(),
+    ),
+  },
+};
+
+/** @internal */
+export function postPlayerChangeHealthCallbackInit(mod: ModUpgraded): void {
+  saveDataManager("postPlayerChangeHealth", v, hasSubscriptions);
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
+}
+
+function hasSubscriptions() {
+  return postPlayerChangeHealthHasSubscriptions();
+}
+
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // We call the "getPlayerIndex" function with the "differentiateForgottenAndSoul" argument. If we
+  // don't differentiate between The Forgotten and The Soul, the callback will fire every time the
+  // player switches between the two.
+  const playerIndex = getPlayerIndex(player, true);
+  const playerHealthMap = v.run.playersHealthMap.getAndSetDefault(playerIndex);
+
+  for (const healthType of getEnumValues(HealthType)) {
+    const storedHealthValue = playerHealthMap.get(healthType);
+    const currentHealthValue = getPlayerHealthType(player, healthType);
+    playerHealthMap.set(healthType, currentHealthValue);
+
+    if (
+      storedHealthValue !== undefined &&
+      storedHealthValue !== currentHealthValue
+    ) {
+      const amount = currentHealthValue - storedHealthValue;
+      postPlayerChangeHealthFire(player, healthType, amount);
+    }
+  }
+}

package/src/callbacks/postPlayerChangeType.ts

@@ -0,0 +1,56 @@
+import { PlayerType } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  defaultMapGetPlayer,
+  mapSetPlayer,
+} from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postPlayerChangeTypeFire,
+  postPlayerChangeTypeHasSubscriptions,
+} from "./subscriptions/postPlayerChangeType";
+
+const v = {
+  run: {
+    playersCharacterMap: new DefaultMap<
+      PlayerIndex,
+      PlayerType,
+      [character: PlayerType]
+    >((character: PlayerType) => character), // eslint-disable-line isaacscript/strict-enums
+  },
+};
+
+/** @internal */
+export function postPlayerChangeTypeCallbackInit(mod: ModUpgraded): void {
+  saveDataManager("postPlayerChangeType", v, hasSubscriptions);
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
+}
+
+function hasSubscriptions() {
+  return postPlayerChangeTypeHasSubscriptions();
+}
+
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const character = player.GetPlayerType();
+  const storedCharacter = defaultMapGetPlayer(
+    v.run.playersCharacterMap,
+    player,
+    character,
+  );
+  if (character !== storedCharacter) {
+    mapSetPlayer(v.run.playersCharacterMap, player, character);
+    postPlayerChangeTypeFire(player, storedCharacter, character);
+  }
+}

package/src/callbacks/postPlayerFatalDamage.ts

@@ -0,0 +1,98 @@
+import {
+  DamageFlag,
+  EntityType,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { mapGetPlayer, mapSetPlayer } from "../functions/playerDataStructures";
+import { isChildPlayer } from "../functions/playerIndex";
+import { isDamageToPlayerFatal, willPlayerRevive } from "../functions/revive";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postPlayerFatalDamageFire,
+  postPlayerFatalDamageHasSubscriptions,
+} from "./subscriptions/postPlayerFatalDamage";
+
+const v = {
+  run: {
+    /** Needed to detect if Glass Cannon will kill the player or not. */
+    playersLastDamageGameFrame: new Map<PlayerIndex, int>(),
+  },
+};
+
+/** @internal */
+export function postPlayerFatalDamageCallbackInit(mod: Mod): void {
+  saveDataManager("postPlayerFatalDamage", v);
+
+  mod.AddCallback(
+    ModCallback.ENTITY_TAKE_DMG,
+    entityTakeDmgPlayer,
+    EntityType.PLAYER,
+  );
+}
+
+function hasSubscriptions() {
+  return postPlayerFatalDamageHasSubscriptions();
+}
+
+// ModCallback.ENTITY_TAKE_DMG (11)
+// EntityType.PLAYER (1)
+function entityTakeDmgPlayer(
+  tookDamage: Entity,
+  damageAmount: float,
+  damageFlags: BitFlags<DamageFlag>,
+  damageSource: EntityRef,
+  damageCountdownFrames: int,
+): boolean | void {
+  if (!hasSubscriptions()) {
+    return undefined;
+  }
+
+  const player = tookDamage.ToPlayer();
+  if (player === undefined) {
+    return undefined;
+  }
+
+  // This callback should not trigger for the Strawman Keeper and other players that are "child"
+  // players.
+  if (isChildPlayer(player)) {
+    return undefined;
+  }
+
+  const gameFrameCount = game.GetFrameCount();
+  const lastDamageGameFrame = mapGetPlayer(
+    v.run.playersLastDamageGameFrame,
+    player,
+  );
+  mapSetPlayer(v.run.playersLastDamageGameFrame, player, gameFrameCount);
+
+  // If the player has a revival item such as Dead Cat, this will not be fatal damage.
+  if (willPlayerRevive(player)) {
+    return undefined;
+  }
+
+  if (
+    !isDamageToPlayerFatal(
+      player,
+      damageAmount,
+      damageSource,
+      lastDamageGameFrame,
+    )
+  ) {
+    return undefined;
+  }
+
+  const shouldSustainDeath = postPlayerFatalDamageFire(
+    player,
+    damageAmount,
+    damageFlags,
+    damageSource,
+    damageCountdownFrames,
+  );
+  if (shouldSustainDeath !== undefined) {
+    return shouldSustainDeath;
+  }
+
+  return undefined;
+}

package/src/callbacks/postPlayerInitLate.ts

@@ -0,0 +1,37 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { setAddPlayer, setHasPlayer } from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postPlayerInitLateFire,
+  postPlayerInitLateHasSubscriptions,
+} from "./subscriptions/postPlayerInitLate";
+
+const v = {
+  run: {
+    playersFiredSet: new Set<PlayerIndex>(),
+  },
+};
+
+/** @internal */
+export function postPlayerInitLateCallbackInit(mod: Mod): void {
+  saveDataManager("postPlayerInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PLAYER_UPDATE, postPlayerUpdate); // 31
+}
+
+function hasSubscriptions() {
+  return postPlayerInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_PLAYER_UPDATE (31)
+function postPlayerUpdate(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  if (!setHasPlayer(v.run.playersFiredSet, player)) {
+    setAddPlayer(v.run.playersFiredSet, player);
+    postPlayerInitLateFire(player);
+  }
+}

package/src/callbacks/postPlayerReordered.ts

@@ -0,0 +1,142 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { emptyArray } from "../functions/array";
+import { getPlayerFromIndex, getPlayerIndex } from "../functions/playerIndex";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postPEffectUpdateReorderedFire,
+  postPEffectUpdateReorderedHasSubscriptions,
+} from "./subscriptions/postPEffectUpdateReordered";
+import {
+  postPlayerInitReorderedFire,
+  postPlayerInitReorderedHasSubscriptions,
+} from "./subscriptions/postPlayerInitReordered";
+import {
+  postPlayerRenderReorderedFire,
+  postPlayerRenderReorderedHasSubscriptions,
+} from "./subscriptions/postPlayerRenderReordered";
+import {
+  postPlayerUpdateReorderedFire,
+  postPlayerUpdateReorderedHasSubscriptions,
+} from "./subscriptions/postPlayerUpdateReordered";
+
+const v = {
+  run: {
+    postGameStartedFiredOnThisRun: false,
+
+    postPlayerInitQueue: [] as PlayerIndex[],
+    postPEffectUpdateQueue: [] as PlayerIndex[],
+    postPlayerUpdateQueue: [] as PlayerIndex[],
+    postPlayerRenderQueue: [] as PlayerIndex[],
+  },
+};
+
+/** @internal */
+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_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()
+  );
+}
+
+// ModCallback.POST_PEFFECT_UPDATE (4)
+function postPEffectUpdate(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  if (v.run.postGameStartedFiredOnThisRun) {
+    postPEffectUpdateReorderedFire(player);
+  } else {
+    // Defer callback execution until the PostGameStarted 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()) {
+    return;
+  }
+
+  if (v.run.postGameStartedFiredOnThisRun) {
+    postPlayerUpdateReorderedFire(player);
+  } else {
+    // Defer callback execution until the PostGameStarted callback fires.
+    const playerIndex = getPlayerIndex(player);
+    v.run.postPlayerUpdateQueue.push(playerIndex);
+  }
+}
+
+// ModCallback.POST_PLAYER_RENDER (32)
+function postPlayerRender(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  if (v.run.postGameStartedFiredOnThisRun) {
+    postPlayerRenderReorderedFire(player);
+  } else {
+    // Defer callback execution until the PostGameStarted callback fires.
+    const playerIndex = getPlayerIndex(player);
+    v.run.postPlayerRenderQueue.push(playerIndex);
+  }
+}
+
+// ModCallback.POST_GAME_STARTED (15)
+function postGameStarted() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  v.run.postGameStartedFiredOnThisRun = true;
+
+  dequeue(v.run.postPlayerInitQueue, postPlayerInitReorderedFire);
+  dequeue(v.run.postPlayerUpdateQueue, postPlayerUpdateReorderedFire);
+  dequeue(v.run.postPlayerRenderQueue, postPlayerRenderReorderedFire);
+}
+
+function dequeue(
+  playerIndexes: PlayerIndex[],
+  fireFunction: (player: EntityPlayer) => void,
+) {
+  for (const playerIndex of playerIndexes) {
+    const player = getPlayerFromIndex(playerIndex);
+    if (player === undefined) {
+      continue;
+    }
+
+    fireFunction(player);
+  }
+
+  emptyArray(playerIndexes);
+}

package/src/callbacks/postPoopRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPoops } from "../functions/gridEntitySpecific";
+import {
+  postPoopRenderFire,
+  postPoopRenderHasSubscriptions,
+} from "./subscriptions/postPoopRender";
+
+/** @internal */
+export function postPoopRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postPoopRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const poop of getPoops()) {
+    postPoopRenderFire(poop);
+  }
+}