isaacscript-common 13.3.4 → 14.0.0

package/src/classes/callbacks/PostCursedTeleport.ts

@@ -0,0 +1,183 @@
+import {
+  CollectibleType,
+  DamageFlag,
+  EntityType,
+  ModCallback,
+  PlayerVariant,
+  RoomType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { hasFlag } from "../../functions/flag";
+import {
+  mapGetPlayer,
+  mapSetPlayer,
+} from "../../functions/playerDataStructures";
+import { getPlayerNumHitsRemaining } from "../../functions/players";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.POST_CURSED_TELEPORT> {
+  override v = {
+    run: {
+      playersDamageFrameMap: new Map<
+        PlayerIndex,
+        [lastDamageFrame: int, callbackFiredOnThisFrame: boolean]
+      >(),
+    },
+
+    level: {
+      numSacrifices: 0,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [
+        ModCallback.ENTITY_TAKE_DMG,
+        [this.entityTakeDmgPlayer, EntityType.PLAYER],
+      ], // 11
+      [
+        ModCallback.POST_PLAYER_RENDER,
+        // Co-op babies cannot perform Cursed Eye teleports.
+        [this.postPlayerRenderPlayer, PlayerVariant.PLAYER],
+      ], // 32
+    ];
+  }
+
+  // ModCallback.ENTITY_TAKE_DMG (11)
+  // EntityType.PLAYER (1)
+  entityTakeDmgPlayer = (
+    entity: Entity,
+    _amount: float,
+    damageFlags: BitFlags<DamageFlag>,
+    _source: EntityRef,
+    _countdownFrames: int,
+  ): boolean | undefined => {
+    this.incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame.
+    this.setDamageFrame(entity, damageFlags);
+
+    return undefined;
+  };
+
+  setDamageFrame(entity: Entity, damageFlags: BitFlags<DamageFlag>): void {
+    const gameFrameCount = game.GetFrameCount();
+
+    const player = entity.ToPlayer();
+    if (player === undefined) {
+      return;
+    }
+
+    // Don't do anything if we already activated the callback on this frame.
+    const trackingArray = mapGetPlayer(
+      this.v.run.playersDamageFrameMap,
+      player,
+    );
+    if (trackingArray !== undefined) {
+      const [lastDamageFrame, callbackFiredOnThisFrame] = trackingArray;
+      if (lastDamageFrame === gameFrameCount && callbackFiredOnThisFrame) {
+        return;
+      }
+    }
+
+    // Don't do anything if this could be a Sacrifice Room teleport.
+    if (this.isPotentialNaturalTeleportFromSacrificeRoom(damageFlags)) {
+      return;
+    }
+
+    const newTrackingArray = [gameFrameCount, false];
+    mapSetPlayer(this.v.run.playersDamageFrameMap, player, newTrackingArray);
+  }
+
+  isPotentialNaturalTeleportFromSacrificeRoom(
+    damageFlags: BitFlags<DamageFlag>,
+  ): boolean {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+    // Don't record the frame if we are potentially going to the Angel Room or the Dark Room from a
+    // Sacrifice Room.
+    return (
+      roomType === RoomType.SACRIFICE &&
+      isSpikeDamage &&
+      (this.v.level.numSacrifices === 6 || this.v.level.numSacrifices >= 12)
+    );
+  }
+
+  incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>): void {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+    if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
+      this.v.level.numSacrifices++;
+    }
+  }
+
+  // ModCallback.POST_PLAYER_RENDER (32)
+  // PlayerVariant.PLAYER (0)
+  postPlayerRenderPlayer = (
+    player: EntityPlayer,
+    _renderOffset: Vector,
+  ): void => {
+    // Retrieve information about this player.
+    const trackingArray = mapGetPlayer(
+      this.v.run.playersDamageFrameMap,
+      player,
+    );
+    if (trackingArray === undefined) {
+      return;
+    }
+    const [lastDamageFrame, callbackActivatedOnThisFrame] = trackingArray;
+
+    if (!playerIsTeleportingFromCursedTeleport(player, lastDamageFrame)) {
+      return;
+    }
+
+    // Do nothing if the callback already fired on this frame.
+    if (callbackActivatedOnThisFrame) {
+      return;
+    }
+
+    const gameFrameCount = game.GetFrameCount();
+    const newTrackingArray = [gameFrameCount, true];
+    mapSetPlayer(this.v.run.playersDamageFrameMap, player, newTrackingArray);
+
+    this.fire(player);
+  };
+}
+
+function playerIsTeleportingFromCursedTeleport(
+  player: EntityPlayer,
+  lastDamageFrame: int,
+) {
+  // Check to see if this is the frame that we last took damage.
+  const gameFrameCount = game.GetFrameCount();
+  if (gameFrameCount !== lastDamageFrame) {
+    return false;
+  }
+
+  // Check to see if this is the 1st frame that we are teleporting.
+  const sprite = player.GetSprite();
+  if (
+    !sprite.IsPlaying("TeleportUp") ||
+    sprite.GetFrame() !== 1 // The 0th frame never fires
+  ) {
+    return false;
+  }
+
+  if (player.HasCollectible(CollectibleType.CURSED_EYE)) {
+    return true;
+  }
+
+  const numHitsRemaining = getPlayerNumHitsRemaining(player);
+  if (player.HasTrinket(TrinketType.CURSED_SKULL) && numHitsRemaining === 1) {
+    return true;
+  }
+
+  return false;
+}

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> {
+  override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_KNIFE_UPDATE, [this.postKnifeUpdate]], // 51
+    ];
+  }
+
+  // ModCallback.POST_KNIFE_UPDATE (51)
+  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/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> {
+  currentRoomTopLeftWallPtrHash: PtrHash | null = null;
+
+  /** The wall entity directly to the right of the top-left wall. */
+  currentRoomTopLeftWallPtrHash2: PtrHash | null = null;
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
+      [ModCallback.PRE_ENTITY_SPAWN, [this.preEntitySpawn]], // 24
+    ];
+  }
+
+  // ModCallback.POST_NEW_ROOM (19)
+  postNewRoom = (): void => {
+    this.checkRoomChanged();
+  };
+
+  // ModCallback.PRE_ENTITY_SPAWN (24)
+  preEntitySpawn = (): [EntityType, int, int, int] | undefined => {
+    this.checkRoomChanged();
+    return undefined;
+  };
+
+  checkRoomChanged(): void {
+    if (this.isNewRoom()) {
+      this.fire();
+    }
+  }
+
+  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/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.otherCallbacksUsed = [
+      [ModCallback.POST_RENDER, [this.postRender]], // 2
+    ];
+  }
+
+  // ModCallback.POST_RENDER (2)
+  postRender = (): void => {
+    for (const pit of getPits()) {
+      this.fire(pit);
+    }
+  };
+}

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> {
+  override v = {
+    room: {
+      cleared: false,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  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)
+  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.otherCallbacksUsed = [
+      [ModCallback.POST_RENDER, [this.postRender]], // 2
+    ];
+  }
+
+  // ModCallback.POST_RENDER (2)
+  postRender = (): void => {
+    for (const spikes of getSpikes()) {
+      this.fire(spikes);
+    }
+  };
+}

package/src/classes/callbacks/validation/CustomCallbackAmbush.ts

@@ -0,0 +1,28 @@
+import { AmbushType } from "packages/isaacscript-common/src/enums/AmbushType";
+import { MatchingCallbackCustom } from "packages/isaacscript-common/src/types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureAmbush = (ambushType: AmbushType) => void;
+type ModCallbackCustomAmbush = MatchingCallbackCustom<CallbackSignatureAmbush>;
+
+export class CustomCallbackAmbush<
+  T extends ModCallbackCustomAmbush,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackAmbushType] = optionalArgs;
+    if (callbackAmbushType === undefined) {
+      return true;
+    }
+
+    const [ambushType] = fireArgs;
+    return ambushType === callbackAmbushType;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackBomb.ts

@@ -0,0 +1,27 @@
+import { MatchingCallbackCustom } from "packages/isaacscript-common/src/types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureBomb = (bomb: EntityBomb) => void;
+type ModCallbackCustomBomb = MatchingCallbackCustom<CallbackSignatureBomb>;
+
+export class CustomCallbackBomb<
+  T extends ModCallbackCustomBomb,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackBombVariant] = optionalArgs;
+    if (callbackBombVariant === undefined) {
+      return true;
+    }
+
+    const [bomb] = fireArgs;
+    return bomb.Variant === callbackBombVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackCollectible.ts

@@ -0,0 +1,30 @@
+import { MatchingCallbackCustom } from "packages/isaacscript-common/src/types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureCollectible = (
+  collectible: EntityPickupCollectible,
+) => void;
+type ModCallbackCustomCollectible =
+  MatchingCallbackCustom<CallbackSignatureCollectible>;
+
+export class CustomCallbackCollectible<
+  T extends ModCallbackCustomCollectible,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackCollectibleType] = optionalArgs;
+    if (callbackCollectibleType === undefined) {
+      return true;
+    }
+
+    const [collectible] = fireArgs;
+    return collectible.SubType === callbackCollectibleType;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackKnife.ts

@@ -0,0 +1,27 @@
+import { MatchingCallbackCustom } from "packages/isaacscript-common/src/types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureKnife = (knife: EntityKnife) => void;
+type ModCallbackCustomKnife = MatchingCallbackCustom<CallbackSignatureKnife>;
+
+export class CustomCallbackKnife<
+  T extends ModCallbackCustomKnife,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackKnifeVariant] = optionalArgs;
+    if (callbackKnifeVariant === undefined) {
+      return true;
+    }
+
+    const [knife] = fireArgs;
+    return knife.Variant === callbackKnifeVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackPit.ts

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "packages/isaacscript-common/src/types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignaturePit = (pit: GridEntityPit) => void;
+type ModCallbackCustomPit = MatchingCallbackCustom<CallbackSignaturePit>;
+
+export class CustomCallbackPit<
+  T extends ModCallbackCustomPit,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackPitVariant] = optionalArgs;
+    if (callbackPitVariant === undefined) {
+      return true;
+    }
+
+    const [pit] = fireArgs;
+    const pitVariant = pit.GetVariant();
+    return pitVariant === callbackPitVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackPlayer.ts

@@ -0,0 +1,37 @@
+import { MatchingCallbackCustom } from "packages/isaacscript-common/src/types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignaturePlayer = (player: EntityPlayer) => void;
+type ModCallbackCustomPlayer = MatchingCallbackCustom<CallbackSignaturePlayer>;
+
+export class CustomCallbackPlayer<
+  T extends ModCallbackCustomPlayer,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [player] = fireArgs;
+    const [callbackPlayerVariant, callbackCharacter] = optionalArgs;
+
+    if (
+      callbackPlayerVariant !== undefined &&
+      callbackPlayerVariant !== player.Variant
+    ) {
+      return false;
+    }
+
+    const character = player.GetPlayerType();
+
+    if (callbackCharacter !== undefined && callbackCharacter !== character) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackSpikes.ts

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "packages/isaacscript-common/src/types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureSpikes = (spikes: GridEntitySpikes) => void;
+type ModCallbackCustomSpikes = MatchingCallbackCustom<CallbackSignatureSpikes>;
+
+export class CustomCallbackSpikes<
+  T extends ModCallbackCustomSpikes,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackSpikesVariant] = optionalArgs;
+    if (callbackSpikesVariant === undefined) {
+      return true;
+    }
+
+    const [spikes] = fireArgs;
+    const spikesVariant = spikes.GetVariant();
+    return spikesVariant === callbackSpikesVariant;
+  }
+}

package/src/classes/private/CustomCallback.ts

@@ -0,0 +1,79 @@
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { AddCallbackParametersCustom2 } from "../../interfaces/private/AddCallbackParametersCustom2";
+import { SaveData } from "../../interfaces/SaveData";
+import { AllButFirst } from "../../types/private/AllButFirst";
+import {
+  CallbackTuple,
+  CustomCallbackTuple,
+} from "../../types/private/CallbackTuple";
+
+export type FireArgs<T extends ModCallbackCustom2> = Parameters<
+  AddCallbackParametersCustom2[T][0]
+>;
+export type OptionalArgs<T extends ModCallbackCustom2> = AllButFirst<
+  AddCallbackParametersCustom2[T]
+>;
+
+/**
+ * The base class for a custom callback. Individual custom callbacks (and validation callbacks) will
+ * extend from this class.
+ */
+export abstract class CustomCallback<T extends ModCallbackCustom2> {
+  /** This is manually managed by the `ModUpgraded` class. */
+  initialized = false;
+
+  subscriptions: Array<AddCallbackParametersCustom2[T]> = [];
+
+  otherCallbacksUsed?: CallbackTuple[];
+  otherCustomCallbacksUsed?: CustomCallbackTuple[];
+  v?: SaveData;
+
+  hasSubscriptions(): boolean {
+    return this.subscriptions.length > 0;
+  }
+
+  add(...args: AddCallbackParametersCustom2[T]): void {
+    this.subscriptions.push(args);
+  }
+
+  /**
+   * If the submitted function does not match any of the existing subscriptions, this method will do
+   * nothing.
+   */
+  remove(callback: AddCallbackParametersCustom2[T][0]): void {
+    const subscriptionIndexMatchingCallback = this.subscriptions.findIndex(
+      (subscription) => {
+        const subscriptionCallback = subscription[0];
+        return callback === subscriptionCallback;
+      },
+    );
+    if (subscriptionIndexMatchingCallback !== -1) {
+      this.subscriptions.splice(subscriptionIndexMatchingCallback, 1);
+    }
+  }
+
+  fire(...fireArgs: FireArgs<T>): void {
+    for (const [callback, ...optionalArgs] of this.subscriptions) {
+      // @ts-expect-error The compiler is not smart enough to know that the arguments should match
+      // the method.
+      if (this.shouldFire(fireArgs, optionalArgs)) {
+        // @ts-expect-error The compiler is not smart enough to know that the arguments should match
+        // the callback.
+        callback(...fireArgs);
+      }
+    }
+  }
+
+  /**
+   * This method needs to be overwritten for any callback that has optional filtration arguments.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  shouldFire(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    fireArgs: FireArgs<T>,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    return true;
+  }
+}