isaacscript-common 13.3.4 → 14.1.0

package/src/classes/callbacks/PostGridEntityCustomCollision.ts

@@ -0,0 +1,53 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_COLLISION;
+
+export class PostGridEntityCustomCollision extends CustomCallback<T> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [_gridEntity, gridEntityTypeCustom, entity] = fireArgs;
+    const [
+      callbackGridEntityTypeCustom,
+      callbackEntityType,
+      callbackEntityVariant,
+    ] = optionalArgs;
+
+    if (
+      callbackGridEntityTypeCustom !== undefined &&
+      callbackGridEntityTypeCustom !== gridEntityTypeCustom
+    ) {
+      return false;
+    }
+
+    if (
+      callbackEntityType !== undefined &&
+      callbackEntityType !== entity.Type
+    ) {
+      return false;
+    }
+
+    if (
+      callbackEntityVariant !== undefined &&
+      callbackEntityVariant !== entity.Variant
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/classes/callbacks/PostGridEntityCustomInit.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntityCustom } from "./validation/CustomCallbackGridEntityCustom";
+
+export class PostGridEntityCustomInit extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_INIT> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}

package/src/classes/callbacks/PostGridEntityCustomRemove.ts

@@ -0,0 +1,32 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_REMOVE;
+
+export class PostGridEntityCustomRemove extends CustomCallback<T> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackGridEntityTypeCustom] = optionalArgs;
+
+    if (callbackGridEntityTypeCustom === undefined) {
+      return true;
+    }
+
+    const [_gridIndex, gridEntityTypeCustom] = fireArgs;
+    return gridEntityTypeCustom === callbackGridEntityTypeCustom;
+  }
+}

package/src/classes/callbacks/PostGridEntityCustomStateChanged.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntityCustom } from "./validation/CustomCallbackGridEntityCustom";
+
+export class PostGridEntityCustomStateChanged extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}

package/src/classes/callbacks/PostGridEntityCustomUpdate.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntityCustom } from "./validation/CustomCallbackGridEntityCustom";
+
+export class PostGridEntityCustomUpdate extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_UPDATE> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}

package/src/classes/callbacks/PostGridEntityInit.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntity } from "./validation/CustomCallbackGridEntity";
+
+export class PostGridEntityInit extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_INIT> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}

package/src/classes/callbacks/PostGridEntityRemove.ts

@@ -0,0 +1,39 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_GRID_ENTITY_REMOVE;
+
+export class PostGridEntityRemove extends CustomCallback<T> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [_gridIndex, gridEntityType, variant] = fireArgs;
+    const [callbackGridEntityType, callbackVariant] = optionalArgs;
+
+    if (
+      callbackGridEntityType !== undefined &&
+      callbackGridEntityType !== gridEntityType
+    ) {
+      return false;
+    }
+
+    if (callbackVariant !== undefined && callbackVariant !== variant) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/classes/callbacks/PostGridEntityStateChanged.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntity } from "./validation/CustomCallbackGridEntity";
+
+export class PostGridEntityStateChanged extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_STATE_CHANGED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}

package/src/classes/callbacks/PostGridEntityUpdate.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntity } from "./validation/CustomCallbackGridEntity";
+
+export class PostGridEntityUpdate extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_UPDATE> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}

package/src/classes/callbacks/PostHolyMantleRemoved.ts

@@ -0,0 +1,45 @@
+import { CollectibleType } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  defaultMapGetPlayer,
+  mapSetPlayer,
+} from "../../functions/playerDataStructures";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostHolyMantleRemoved extends CustomCallback<ModCallbackCustom2.POST_HOLY_MANTLE_REMOVED> {
+  public override v = {
+    run: {
+      playersHolyMantleMap: new DefaultMap<PlayerIndex, int>(0),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED,
+        [this.postPEffectUpdateReordered],
+      ],
+    ];
+  }
+
+  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+  private postPEffectUpdateReordered = (player: EntityPlayer): void => {
+    const effects = player.GetEffects();
+    const newNumHolyMantles = effects.GetCollectibleEffectNum(
+      CollectibleType.HOLY_MANTLE,
+    );
+    const oldNumHolyMantles = defaultMapGetPlayer(
+      this.v.run.playersHolyMantleMap,
+      player,
+    );
+    mapSetPlayer(this.v.run.playersHolyMantleMap, player, newNumHolyMantles);
+
+    if (newNumHolyMantles < oldNumHolyMantles) {
+      this.fire(player, oldNumHolyMantles, newNumHolyMantles);
+    }
+  };
+}

package/src/classes/callbacks/PostKnifeInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackKnife } from "./validation/CustomCallbackKnife";
+
+export class PostKnifeInitLate extends CustomCallbackKnife<ModCallbackCustom2.POST_KNIFE_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_KNIFE_UPDATE, [this.postKnifeUpdate]], // 51
+    ];
+  }
+
+  // ModCallback.POST_KNIFE_UPDATE (51)
+  private postKnifeUpdate = (knife: EntityKnife): void => {
+    const ptrHash = GetPtrHash(knife);
+    if (!this.v.room.firedSet.has(ptrHash)) {
+      this.v.room.firedSet.add(ptrHash);
+      this.fire(knife);
+    }
+  };
+}

package/src/classes/callbacks/PostNewLevelReordered.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostNewLevelReordered extends CustomCallback<ModCallbackCustom2.POST_NEW_LEVEL_REORDERED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GAME_REORDERED_CALLBACKS];
+  }
+}

package/src/classes/callbacks/PostNewRoomEarly.ts

@@ -0,0 +1,93 @@
+import {
+  EntityType,
+  GridEntityType,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  getTopLeftWallGridIndex,
+  spawnGridEntity,
+} from "../../functions/gridEntities";
+import { logError } from "../../functions/logMisc";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostNewRoomEarly extends CustomCallback<ModCallbackCustom2.POST_NEW_ROOM_EARLY> {
+  private currentRoomTopLeftWallPtrHash: PtrHash | null = null;
+
+  /** The wall entity directly to the right of the top-left wall. */
+  private currentRoomTopLeftWallPtrHash2: PtrHash | null = null;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
+      [ModCallback.PRE_ENTITY_SPAWN, [this.preEntitySpawn]], // 24
+    ];
+  }
+
+  // ModCallback.POST_NEW_ROOM (19)
+  private postNewRoom = (): void => {
+    this.checkRoomChanged();
+  };
+
+  // ModCallback.PRE_ENTITY_SPAWN (24)
+  private preEntitySpawn = (): [EntityType, int, int, int] | undefined => {
+    this.checkRoomChanged();
+    return undefined;
+  };
+
+  private checkRoomChanged(): void {
+    if (this.isNewRoom()) {
+      this.fire();
+    }
+  }
+
+  private isNewRoom(): boolean {
+    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 = spawnGridEntity(GridEntityType.WALL, topLeftWallGridIndex);
+      if (topLeftWall === undefined) {
+        logError(
+          "Failed to spawn a new wall (1) for the POST_NEW_ROOM_EARLY callback.",
+        );
+        return false;
+      }
+    }
+
+    // For some reason, the above check will rarely fail. We duplicate the check with another wall
+    // segment to increase the reliability.
+    if (topLeftWall2 === undefined) {
+      topLeftWall2 = spawnGridEntity(
+        GridEntityType.WALL,
+        rightOfTopWallGridIndex,
+      );
+      if (topLeftWall2 === undefined) {
+        logError(
+          "Failed to spawn a new wall (2) for the POST_NEW_ROOM_EARLY callback.",
+        );
+        return false;
+      }
+    }
+
+    const oldTopLeftWallPtrHash = this.currentRoomTopLeftWallPtrHash;
+    const oldTopLeftWallPtrHash2 = this.currentRoomTopLeftWallPtrHash2;
+    this.currentRoomTopLeftWallPtrHash = GetPtrHash(topLeftWall);
+    this.currentRoomTopLeftWallPtrHash2 = GetPtrHash(topLeftWall2);
+
+    return (
+      oldTopLeftWallPtrHash !== this.currentRoomTopLeftWallPtrHash ||
+      oldTopLeftWallPtrHash2 !== this.currentRoomTopLeftWallPtrHash2
+    );
+  }
+}

package/src/classes/callbacks/PostNewRoomReordered.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostNewRoomReordered extends CustomCallback<ModCallbackCustom2.POST_NEW_ROOM_REORDERED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GAME_REORDERED_CALLBACKS];
+  }
+}

package/src/classes/callbacks/PostPEffectUpdateReordered.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPEffectUpdateReordered extends CustomCallbackPlayer<ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.PLAYER_REORDERED_CALLBACKS];
+  }
+}

package/src/classes/callbacks/PostPitRender.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getPits } from "../../functions/gridEntitiesSpecific";
+import { CustomCallbackPit } from "./validation/CustomCallbackPit";
+
+export class PostPitRender extends CustomCallbackPit<ModCallbackCustom2.POST_PIT_RENDER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_RENDER, [this.postRender]], // 2
+    ];
+  }
+
+  // ModCallback.POST_RENDER (2)
+  private postRender = (): void => {
+    for (const pit of getPits()) {
+      this.fire(pit);
+    }
+  };
+}

package/src/classes/callbacks/PostPlayerFatalDamage.ts

@@ -0,0 +1,127 @@
+import {
+  ActiveSlot,
+  BossID,
+  CollectibleType,
+  DamageFlag,
+  DamageFlagZero,
+  EntityType,
+  ModCallback,
+  UseFlag,
+} from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  mapGetPlayer,
+  mapSetPlayer,
+} from "../../functions/playerDataStructures";
+import { isChildPlayer } from "../../functions/playerIndex";
+import {
+  isDamageToPlayerFatal,
+  willPlayerRevive,
+} from "../../functions/revive";
+import { inBossRoomOf } from "../../functions/rooms";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerFatalDamage extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_FATAL_DAMAGE> {
+  public override v = {
+    run: {
+      /** Needed to detect if Glass Cannon will kill the player or not. */
+      playersLastDamageGameFrame: new Map<PlayerIndex, int>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.ENTITY_TAKE_DMG,
+        [this.entityTakeDmgPlayer, EntityType.PLAYER],
+      ], // 11
+      [ModCallback.PRE_USE_ITEM, [this.preUseItemBible, CollectibleType.BIBLE]], // 23
+    ];
+  }
+
+  // ModCallback.ENTITY_TAKE_DMG (11)
+  // EntityType.PLAYER (1)
+  private entityTakeDmgPlayer = (
+    entity: Entity,
+    amount: float,
+    damageFlags: BitFlags<DamageFlag>,
+    source: EntityRef,
+    countdownFrames: int,
+  ): boolean | undefined => {
+    const player = entity.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(
+      this.v.run.playersLastDamageGameFrame,
+      player,
+    );
+    mapSetPlayer(this.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, amount, source, lastDamageGameFrame)) {
+      return undefined;
+    }
+
+    const shouldSustainDeath = this.fire(
+      player,
+      amount,
+      damageFlags,
+      source,
+      countdownFrames,
+    );
+    if (shouldSustainDeath !== undefined) {
+      return shouldSustainDeath;
+    }
+
+    return undefined;
+  };
+
+  // ModCallback.PRE_USE_ITEM (23)
+  // CollectibleType.BIBLE (33)
+  private preUseItemBible = (
+    _collectibleType: CollectibleType,
+    _rng: RNG,
+    player: EntityPlayer,
+    _useFlags: BitFlags<UseFlag>,
+    _activeSlot: ActiveSlot,
+    _customVarData: int,
+  ): boolean | undefined => {
+    // Using The Bible on Satan is one of the few ways to die without taking damage, so we need to
+    // handle this case.
+    if (!inBossRoomOf(BossID.SATAN)) {
+      return undefined;
+    }
+
+    const shouldSustainDeath = this.fire(
+      player,
+      0,
+      DamageFlagZero,
+      EntityRef(player),
+      0,
+    );
+    if (shouldSustainDeath !== undefined) {
+      // End-users will return false to stop the damage from being fatal. We have to return true to
+      // prevent the Bible from firing.
+      return !shouldSustainDeath;
+    }
+
+    return undefined;
+  };
+}

package/src/classes/callbacks/PostPlayerRenderReordered.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerRenderReordered extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_RENDER_REORDERED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.PLAYER_REORDERED_CALLBACKS];
+  }
+}

package/src/classes/callbacks/PostPlayerUpdateReordered.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerUpdateReordered extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_UPDATE_REORDERED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.PLAYER_REORDERED_CALLBACKS];
+  }
+}

package/src/classes/callbacks/PostRoomClearChanged.ts

@@ -0,0 +1,40 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostRoomClearChanged extends CustomCallback<ModCallbackCustom2.POST_ROOM_CLEAR_CHANGED> {
+  public override v = {
+    room: {
+      cleared: false,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    const room = game.GetRoom();
+    const roomClear = room.IsClear();
+
+    if (roomClear !== this.v.room.cleared) {
+      this.v.room.cleared = roomClear;
+      this.fire(roomClear);
+    }
+  };
+
+  // ModCallback.POST_NEW_ROOM (19)
+  private postNewRoom = (): void => {
+    const room = game.GetRoom();
+    const roomClear = room.IsClear();
+
+    this.v.room.cleared = roomClear;
+  };
+}

package/src/classes/callbacks/PostSpikesRender.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getSpikes } from "../../functions/gridEntitiesSpecific";
+import { CustomCallbackSpikes } from "./validation/CustomCallbackSpikes";
+
+export class PostSpikesRender extends CustomCallbackSpikes<ModCallbackCustom2.POST_SPIKES_RENDER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_RENDER, [this.postRender]], // 2
+    ];
+  }
+
+  // ModCallback.POST_RENDER (2)
+  private postRender = (): void => {
+    for (const spikes of getSpikes()) {
+      this.fire(spikes);
+    }
+  };
+}