isaacscript-common 14.1.3 → 14.2.0

package/src/classes/callbacks/PostPlayerInitFirst.ts

@@ -0,0 +1,44 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getPlayers, isChildPlayer } from "../../functions/playerIndex";
+import { inGenesisRoom } from "../../functions/rooms";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerInitFirst extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_INIT_FIRST> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
+    ];
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom2.POST_PLAYER_INIT_LATE, [this.postPlayerInitLate]],
+    ];
+  }
+
+  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+  private postNewRoom = () => {
+    // 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()) {
+      this.fire(player);
+    }
+  };
+
+  // ModCallbackCustom.POST_PLAYER_INIT_LATE
+  private postPlayerInitLate = (player: EntityPlayer) => {
+    // We want to exclude non-real players like the Strawman keeper.
+    if (!isChildPlayer(player)) {
+      return;
+    }
+
+    this.fire(player);
+  };
+}

package/src/classes/callbacks/PostPlayerInitLate.ts

@@ -0,0 +1,32 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  setAddPlayer,
+  setHasPlayer,
+} from "../../functions/playerDataStructures";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerInitLate extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_INIT_LATE> {
+  public override v = {
+    run: {
+      playersFiredSet: new Set<PlayerIndex>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
+    ];
+  }
+
+  // ModCallback.POST_PEFFECT_UPDATE
+  private postPEffectUpdate = (player: EntityPlayer) => {
+    if (!setHasPlayer(this.v.run.playersFiredSet, player)) {
+      setAddPlayer(this.v.run.playersFiredSet, player);
+      this.fire(player);
+    }
+  };
+}

package/src/classes/callbacks/PostPoopRender.ts

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

package/src/classes/callbacks/PostPoopUpdate.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getPoops } from "../../functions/gridEntitiesSpecific";
+import { CustomCallbackPoop } from "./validation/CustomCallbackPoop";
+
+export class PostPoopUpdate extends CustomCallbackPoop<ModCallbackCustom2.POST_POOP_UPDATE> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    for (const poop of getPoops()) {
+      this.fire(poop);
+    }
+  };
+}

package/src/classes/callbacks/PostPressurePlateRender.ts

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

package/src/classes/callbacks/PostPressurePlateUpdate.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getPressurePlates } from "../../functions/gridEntitiesSpecific";
+import { CustomCallbackPressurePlate } from "./validation/CustomCallbackPressurePlate";
+
+export class PostPressurePlateUpdate extends CustomCallbackPressurePlate<ModCallbackCustom2.POST_PRESSURE_PLATE_UPDATE> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    for (const pressurePlate of getPressurePlates()) {
+      this.fire(pressurePlate);
+    }
+  };
+}

package/src/classes/callbacks/PostProjectileInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackProjectile } from "./validation/CustomCallbackProjectile";
+
+export class PostProjectileInitLate extends CustomCallbackProjectile<ModCallbackCustom2.POST_PROJECTILE_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PROJECTILE_UPDATE, [this.postProjectileUpdate]], // 44
+    ];
+  }
+
+  // ModCallback.POST_PROJECTILE_UPDATE (44)
+  private postProjectileUpdate = (projectile: EntityProjectile): void => {
+    const ptrHash = GetPtrHash(projectile);
+    if (!this.v.room.firedSet.has(ptrHash)) {
+      this.v.room.firedSet.add(ptrHash);
+      this.fire(projectile);
+    }
+  };
+}

package/src/classes/callbacks/PostPurchase.ts

@@ -0,0 +1,87 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getPickups } from "../../functions/entitiesSpecific";
+import {
+  defaultMapGetPlayer,
+  mapSetPlayer,
+} from "../../functions/playerDataStructures";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { DefaultMap } from "../DefaultMap";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_PURCHASE;
+
+export class PostPurchase extends CustomCallback<T> {
+  public override v = {
+    room: {
+      playersHoldingItemOnLastFrameMap: new DefaultMap<PlayerIndex, boolean>(
+        false,
+      ),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
+    ];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [_player, pickup] = fireArgs;
+    const [callbackPickupVariant, callbackPickupSubType] = optionalArgs;
+
+    if (
+      callbackPickupVariant !== undefined &&
+      callbackPickupVariant !== pickup.Variant
+    ) {
+      return false;
+    }
+
+    if (
+      callbackPickupSubType !== undefined &&
+      callbackPickupSubType !== pickup.SubType
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffectUpdate = (player: EntityPlayer) => {
+    const isHoldingItem = player.IsHoldingItem();
+    const wasHoldingItemOnLastFrame = defaultMapGetPlayer(
+      this.v.room.playersHoldingItemOnLastFrameMap,
+      player,
+    );
+    mapSetPlayer(
+      this.v.room.playersHoldingItemOnLastFrameMap,
+      player,
+      isHoldingItem,
+    );
+
+    if (!wasHoldingItemOnLastFrame && isHoldingItem) {
+      this.playerPickedUpNewItem(player);
+    }
+  };
+
+  private playerPickedUpNewItem(player: EntityPlayer) {
+    const pickups = getPickups();
+    const disappearingPickup = pickups.find(
+      (pickup) => !pickup.Exists() && pickup.Price !== 0,
+    );
+    if (disappearingPickup !== undefined) {
+      this.fire(player, disappearingPickup);
+    }
+  }
+}

package/src/classes/callbacks/PostRockRender.ts

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

package/src/classes/callbacks/PostRockUpdate.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getRocks } from "../../functions/gridEntitiesSpecific";
+import { CustomCallbackRock } from "./validation/CustomCallbackRock";
+
+export class PostRockUpdate extends CustomCallbackRock<ModCallbackCustom2.POST_ROCK_UPDATE> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    for (const rock of getRocks()) {
+      this.fire(rock);
+    }
+  };
+}

package/src/classes/callbacks/PostSacrifice.ts

@@ -0,0 +1,89 @@
+import {
+  DamageFlag,
+  EntityType,
+  ModCallback,
+  RoomType,
+} from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { hasFlag } from "../../functions/flag";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_SACRIFICE;
+
+// We don't extend from `CustomCallbackPlayer` since there is a function type overlap with
+// `ModCallbackCustom2.POST_CUSTOM_REVIVE`. (Even though that callback does not extend from
+// `CustomCallbackPlayer`, including this callback's signature in the list of function signatures
+// will cause it to match.)
+export class PostSacrifice extends CustomCallback<T> {
+  public override v = {
+    level: {
+      numSacrifices: 0,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.ENTITY_TAKE_DMG,
+        [this.entityTakeDmgPlayer, EntityType.PLAYER],
+      ], // 11
+    ];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected 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;
+  }
+
+  // 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;
+    }
+
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+    if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
+      this.v.level.numSacrifices++;
+      this.fire(player, this.v.level.numSacrifices);
+    }
+
+    return undefined;
+  };
+}

package/src/classes/callbacks/PostSlotAnimationChanged.ts

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

package/src/classes/callbacks/PostSlotCollision.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { isSlot } from "../../functions/entityTypes";
+import { CustomCallbackSlot } from "./validation/CustomCallbackSlot";
+
+export class PostSlotCollision extends CustomCallbackSlot<ModCallbackCustom2.POST_SLOT_COLLISION> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.PRE_PLAYER_COLLISION, [this.prePlayerCollision]], // 33
+    ];
+  }
+
+  // ModCallback.PRE_PLAYER_COLLISION (33)
+  private prePlayerCollision = (
+    player: EntityPlayer,
+    collider: Entity,
+  ): boolean | undefined => {
+    if (isSlot(collider)) {
+      this.fire(collider, player);
+    }
+
+    return undefined;
+  };
+}

package/src/classes/callbacks/PostSlotDestroyed.ts

@@ -0,0 +1,79 @@
+import {
+  EntityGridCollisionClass,
+  EntityType,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { SlotDestructionType } from "../../enums/SlotDestructionType";
+import { CustomCallbackSlot } from "./validation/CustomCallbackSlot";
+
+const PRIZE_GAME_FRAME_DELAY_UNTIL_REMOVAL = 3;
+
+export class PostSlotDestroyed extends CustomCallbackSlot<ModCallbackCustom2.POST_SLOT_DESTROYED> {
+  public override v = {
+    room: {
+      brokenSlots: new Set<PtrHash>(),
+      slotPrizeAnimationGameFrame: new Map<PtrHash, int>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.POST_ENTITY_REMOVE,
+        [this.postEntityRemoveSlot, EntityType.SLOT],
+      ],
+    ];
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom2.POST_SLOT_ANIMATION_CHANGED,
+        [this.postSlotAnimationChanged],
+      ],
+    ];
+  }
+
+  // ModCallback.POST_ENTITY_REMOVE (67)
+  // EntityType.SLOT (6)
+  private postEntityRemoveSlot = (entity: Entity) => {
+    const slot = entity as EntitySlot;
+    const ptrHash = GetPtrHash(slot);
+    const gameFrameCount = game.GetFrameCount();
+
+    const prizeFrame = this.v.room.slotPrizeAnimationGameFrame.get(ptrHash);
+    if (prizeFrame === undefined) {
+      return;
+    }
+
+    if (prizeFrame + PRIZE_GAME_FRAME_DELAY_UNTIL_REMOVAL === gameFrameCount) {
+      this.fire(slot, SlotDestructionType.COLLECTIBLE_PAYOUT);
+    }
+  };
+
+  // ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED
+  private postSlotAnimationChanged = (slot: EntitySlot) => {
+    const ptrHash = GetPtrHash(slot);
+    const gameFrameCount = game.GetFrameCount();
+
+    const alreadyBroken = this.v.room.brokenSlots.has(ptrHash);
+    if (alreadyBroken) {
+      return;
+    }
+
+    if (slot.GridCollisionClass === EntityGridCollisionClass.GROUND) {
+      this.v.room.brokenSlots.add(ptrHash);
+      this.fire(slot, SlotDestructionType.NORMAL);
+    }
+
+    const sprite = slot.GetSprite();
+    const animation = sprite.GetAnimation();
+    if (animation === "Prize") {
+      this.v.room.slotPrizeAnimationGameFrame.set(ptrHash, gameFrameCount);
+    } else {
+      this.v.room.slotPrizeAnimationGameFrame.delete(ptrHash);
+    }
+  };
+}

package/src/classes/callbacks/PostSlotInit.ts

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

package/src/classes/callbacks/PostSlotRender.ts

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

package/src/classes/callbacks/PostSlotUpdate.ts

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

package/src/classes/callbacks/PostSpikesUpdate.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 PostSpikesUpdate extends CustomCallbackSpikes<ModCallbackCustom2.POST_SPIKES_RENDER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    for (const spikes of getSpikes()) {
+      this.fire(spikes);
+    }
+  };
+}

package/src/classes/callbacks/PostTNTRender.ts

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

package/src/classes/callbacks/PostTNTUpdate.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getTNT } from "../../functions/gridEntitiesSpecific";
+import { CustomCallbackTNT } from "./validation/CustomCallbackTNT";
+
+export class PostTNTUpdate extends CustomCallbackTNT<ModCallbackCustom2.POST_TNT_UPDATE> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    for (const tnt of getTNT()) {
+      this.fire(tnt);
+    }
+  };
+}

package/src/classes/callbacks/PostTearInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackTear } from "./validation/CustomCallbackTear";
+
+export class PostTearInitLate extends CustomCallbackTear<ModCallbackCustom2.POST_TEAR_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_TEAR_UPDATE, [this.postTearUpdate]], // 40
+    ];
+  }
+
+  // ModCallback.POST_TEAR_UPDATE (40)
+  private postTearUpdate = (tear: EntityTear): void => {
+    const ptrHash = GetPtrHash(tear);
+    if (!this.v.room.firedSet.has(ptrHash)) {
+      this.v.room.firedSet.add(ptrHash);
+      this.fire(tear);
+    }
+  };
+}