isaacscript-common 87.9.6 → 87.9.8

package/src/classes/callbacks/PostAmbushStarted.ts

@@ -12,19 +12,6 @@ const v = {
 };
 
 export class PostAmbushStarted extends CustomCallback<ModCallbackCustom.POST_AMBUSH_STARTED> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 1
-      [ModCallback.POST_UPDATE, this.postUpdate],
-    ];
-  }
-
-  protected override shouldFire = shouldFireAmbush;
-
   private readonly postUpdate = (): void => {
     if (v.room.ambushActive) {
       return;
@@ -42,4 +29,17 @@ export class PostAmbushStarted extends CustomCallback<ModCallbackCustom.POST_AMB
       this.fire(ambushType);
     }
   };
+
+  public override v = v;
+
+  protected override shouldFire = shouldFireAmbush;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 1
+      [ModCallback.POST_UPDATE, this.postUpdate],
+    ];
+  }
 }

package/src/classes/callbacks/PostBombExploded.ts

@@ -5,6 +5,15 @@ import { shouldFireBomb } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostBombExploded extends CustomCallback<ModCallbackCustom.POST_BOMB_EXPLODED> {
+  // ModCallback.POST_BOMB_UPDATE (58)
+  private readonly postBombUpdate = (bomb: EntityBomb): void => {
+    if (bomb.FrameCount === BOMB_EXPLODE_FRAME) {
+      this.fire(bomb);
+    }
+  };
+
+  protected override shouldFire = shouldFireBomb;
+
   constructor() {
     super();
 
@@ -13,13 +22,4 @@ export class PostBombExploded extends CustomCallback<ModCallbackCustom.POST_BOMB
       [ModCallback.POST_BOMB_UPDATE, this.postBombUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireBomb;
-
-  // ModCallback.POST_BOMB_UPDATE (58)
-  private readonly postBombUpdate = (bomb: EntityBomb): void => {
-    if (bomb.FrameCount === BOMB_EXPLODE_FRAME) {
-      this.fire(bomb);
-    }
-  };
 }

package/src/classes/callbacks/PostBombInitFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireBomb } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostBombInitFilter extends CustomCallback<ModCallbackCustom.POST_BOMB_INIT_FILTER> {
+  // ModCallback.POST_BOMB_INIT (57)
+  private readonly postBombInit = (bomb: EntityBomb) => {
+    this.fire(bomb);
+  };
+
+  protected override shouldFire = shouldFireBomb;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostBombInitFilter extends CustomCallback<ModCallbackCustom.POST_BO
       [ModCallback.POST_BOMB_INIT, this.postBombInit],
     ];
   }
-
-  protected override shouldFire = shouldFireBomb;
-
-  // ModCallback.POST_BOMB_INIT (57)
-  private readonly postBombInit = (bomb: EntityBomb) => {
-    this.fire(bomb);
-  };
 }

package/src/classes/callbacks/PostBombInitLate.ts

@@ -10,8 +10,19 @@ const v = {
 };
 
 export class PostBombInitLate extends CustomCallback<ModCallbackCustom.POST_BOMB_INIT_LATE> {
+  // ModCallback.POST_BOMB_UPDATE (58)
+  private readonly postBombUpdate = (bomb: EntityBomb): void => {
+    const ptrHash = GetPtrHash(bomb);
+    if (!v.room.firedSet.has(ptrHash)) {
+      v.room.firedSet.add(ptrHash);
+      this.fire(bomb);
+    }
+  };
+
   public override v = v;
 
+  protected override shouldFire = shouldFireBomb;
+
   constructor() {
     super();
 
@@ -20,15 +31,4 @@ export class PostBombInitLate extends CustomCallback<ModCallbackCustom.POST_BOMB
       [ModCallback.POST_BOMB_UPDATE, this.postBombUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireBomb;
-
-  // ModCallback.POST_BOMB_UPDATE (58)
-  private readonly postBombUpdate = (bomb: EntityBomb): void => {
-    const ptrHash = GetPtrHash(bomb);
-    if (!v.room.firedSet.has(ptrHash)) {
-      v.room.firedSet.add(ptrHash);
-      this.fire(bomb);
-    }
-  };
 }

package/src/classes/callbacks/PostBombRenderFilter.ts

@@ -4,6 +4,16 @@ import { shouldFireBomb } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostBombRenderFilter extends CustomCallback<ModCallbackCustom.POST_BOMB_RENDER_FILTER> {
+  // ModCallback.POST_BOMB_RENDER (59)
+  private readonly postBombUpdate = (
+    bomb: EntityBomb,
+    renderOffset: Vector,
+  ) => {
+    this.fire(bomb, renderOffset);
+  };
+
+  protected override shouldFire = shouldFireBomb;
+
   constructor() {
     super();
 
@@ -12,14 +22,4 @@ export class PostBombRenderFilter extends CustomCallback<ModCallbackCustom.POST_
       [ModCallback.POST_BOMB_RENDER, this.postBombUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireBomb;
-
-  // ModCallback.POST_BOMB_RENDER (59)
-  private readonly postBombUpdate = (
-    bomb: EntityBomb,
-    renderOffset: Vector,
-  ) => {
-    this.fire(bomb, renderOffset);
-  };
 }

package/src/classes/callbacks/PostBombUpdateFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireBomb } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostBombUpdateFilter extends CustomCallback<ModCallbackCustom.POST_BOMB_UPDATE_FILTER> {
+  // ModCallback.POST_BOMB_UPDATE (58)
+  private readonly postBombUpdate = (bomb: EntityBomb) => {
+    this.fire(bomb);
+  };
+
+  protected override shouldFire = shouldFireBomb;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostBombUpdateFilter extends CustomCallback<ModCallbackCustom.POST_
       [ModCallback.POST_BOMB_UPDATE, this.postBombUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireBomb;
-
-  // ModCallback.POST_BOMB_UPDATE (58)
-  private readonly postBombUpdate = (bomb: EntityBomb) => {
-    this.fire(bomb);
-  };
 }

package/src/classes/callbacks/PostBoneSwing.ts

@@ -16,6 +16,15 @@ const v = {
 };
 
 export class PostBoneSwing extends CustomCallback<ModCallbackCustom.POST_BONE_SWING> {
+  // ModCallback.POST_KNIFE_RENDER (52)
+  private readonly postKnifeRender = (knife: EntityKnife): void => {
+    // The tertiary argument of the `POST_KNIFE_RENDER` callback takes sub-types instead of knife
+    // variants.
+    if (knife.Variant === KnifeVariant.BONE_CLUB) {
+      this.postKnifeRenderBoneClub(knife);
+    }
+  };
+
   public override v = v;
 
   constructor() {
@@ -27,15 +36,6 @@ export class PostBoneSwing extends CustomCallback<ModCallbackCustom.POST_BONE_SW
     ];
   }
 
-  // ModCallback.POST_KNIFE_RENDER (52)
-  private readonly postKnifeRender = (knife: EntityKnife): void => {
-    // The tertiary argument of the `POST_KNIFE_RENDER` callback takes sub-types instead of knife
-    // variants.
-    if (knife.Variant === KnifeVariant.BONE_CLUB) {
-      this.postKnifeRenderBoneClub(knife);
-    }
-  };
-
   // ModCallback.POST_KNIFE_RENDER (52)
   // KnifeVariant.BONE_CLUB (1)
   private postKnifeRenderBoneClub(knife: EntityKnife): void {

package/src/classes/callbacks/PostCollectibleEmpty.ts

@@ -16,20 +16,24 @@ const v = {
 };
 
 export class PostCollectibleEmpty extends CustomCallback<T> {
-  public override v = v;
+  // ModCallback.POST_PICKUP_UPDATE (35)
+  // PickupVariant.COLLECTIBLE (100)
+  private readonly postPickupUpdateCollectible = (
+    pickup: EntityPickup,
+  ): void => {
+    const collectible = pickup as EntityPickupCollectible;
 
-  constructor() {
-    super();
+    const ptrHash = GetPtrHash(collectible);
+    let oldCollectibleType = v.room.collectibleTypeMap.get(ptrHash);
+    oldCollectibleType ??= collectible.SubType;
+    v.room.collectibleTypeMap.set(ptrHash, collectible.SubType);
 
-    this.callbacksUsed = [
-      // 35
-      [
-        ModCallback.POST_PICKUP_UPDATE,
-        this.postPickupUpdateCollectible,
-        [PickupVariant.COLLECTIBLE],
-      ],
-    ];
-  }
+    if (oldCollectibleType !== collectible.SubType) {
+      this.collectibleTypeChanged(collectible, oldCollectibleType);
+    }
+  };
+
+  public override v = v;
 
   protected override shouldFire = (
     fireArgs: FireArgs<T>,
@@ -44,22 +48,18 @@ export class PostCollectibleEmpty extends CustomCallback<T> {
     );
   };
 
-  // ModCallback.POST_PICKUP_UPDATE (35)
-  // PickupVariant.COLLECTIBLE (100)
-  private readonly postPickupUpdateCollectible = (
-    pickup: EntityPickup,
-  ): void => {
-    const collectible = pickup as EntityPickupCollectible;
-
-    const ptrHash = GetPtrHash(collectible);
-    let oldCollectibleType = v.room.collectibleTypeMap.get(ptrHash);
-    oldCollectibleType ??= collectible.SubType;
-    v.room.collectibleTypeMap.set(ptrHash, collectible.SubType);
+  constructor() {
+    super();
 
-    if (oldCollectibleType !== collectible.SubType) {
-      this.collectibleTypeChanged(collectible, oldCollectibleType);
-    }
-  };
+    this.callbacksUsed = [
+      // 35
+      [
+        ModCallback.POST_PICKUP_UPDATE,
+        this.postPickupUpdateCollectible,
+        [PickupVariant.COLLECTIBLE],
+      ],
+    ];
+  }
 
   private collectibleTypeChanged(
     collectible: EntityPickupCollectible,

package/src/classes/callbacks/PostCursedTeleport.ts

@@ -32,6 +32,49 @@ const v = {
 };
 
 export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CURSED_TELEPORT> {
+  // ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER
+  private readonly entityTakeDmgPlayer = (
+    player: EntityPlayer,
+    _amount: float,
+    damageFlags: BitFlags<DamageFlag>,
+    _source: EntityRef,
+    _countdownFrames: int,
+  ): boolean | undefined => {
+    this.incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame.
+    this.setDamageFrame(player, damageFlags);
+
+    return undefined;
+  };
+
+  // ModCallbackCustom.POST_PLAYER_RENDER_REORDERED
+  // PlayerVariant.PLAYER (0)
+  private readonly postPlayerRenderReorderedPlayer = (
+    player: EntityPlayer,
+    _renderOffset: Vector,
+  ): void => {
+    // Retrieve information about this player.
+    const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
+    if (trackingArray === undefined) {
+      return;
+    }
+    const [lastDamageFrame, callbackActivatedOnThisFrame] = trackingArray;
+
+    if (!this.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(v.run.playersDamageFrameMap, player, newTrackingArray);
+
+    this.fire(player);
+  };
+
   public override v = v;
 
   protected override shouldFire = shouldFirePlayer;
@@ -49,26 +92,12 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     ];
   }
 
-  // ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER
-  private readonly entityTakeDmgPlayer = (
-    player: EntityPlayer,
-    _amount: float,
-    damageFlags: BitFlags<DamageFlag>,
-    _source: EntityRef,
-    _countdownFrames: int,
-  ): boolean | undefined => {
-    this.incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame.
-    this.setDamageFrame(player, damageFlags);
-
-    return undefined;
-  };
-
   private incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>): void {
     const room = game.GetRoom();
     const roomType = room.GetType();
     const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
 
-    if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
+    if (isSpikeDamage && roomType === RoomType.SACRIFICE) {
       v.level.numSacrifices++;
     }
   }
@@ -113,35 +142,6 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     );
   }
 
-  // ModCallbackCustom.POST_PLAYER_RENDER_REORDERED
-  // PlayerVariant.PLAYER (0)
-  private readonly postPlayerRenderReorderedPlayer = (
-    player: EntityPlayer,
-    _renderOffset: Vector,
-  ): void => {
-    // Retrieve information about this player.
-    const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
-    if (trackingArray === undefined) {
-      return;
-    }
-    const [lastDamageFrame, callbackActivatedOnThisFrame] = trackingArray;
-
-    if (!this.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(v.run.playersDamageFrameMap, player, newTrackingArray);
-
-    this.fire(player);
-  };
-
   private playerIsTeleportingFromCursedTeleport(
     player: EntityPlayer,
     lastDamageFrame: int,
@@ -165,10 +165,8 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     }
 
     const numHitsRemaining = getPlayerNumHitsRemaining(player);
-    if (player.HasTrinket(TrinketType.CURSED_SKULL) && numHitsRemaining === 1) {
-      return true;
-    }
-
-    return false;
+    return (
+      player.HasTrinket(TrinketType.CURSED_SKULL) && numHitsRemaining === 1
+    );
   }
 }

package/src/classes/callbacks/PostCustomRevive.ts

@@ -6,12 +6,6 @@ import { CustomCallback } from "../private/CustomCallback";
 type T = ModCallbackCustom.POST_CUSTOM_REVIVE;
 
 export class PostCustomRevive extends CustomCallback<ModCallbackCustom.POST_CUSTOM_REVIVE> {
-  constructor() {
-    super();
-
-    this.featuresUsed = [ISCFeature.CUSTOM_REVIVE];
-  }
-
   protected override shouldFire = (
     fireArgs: FireArgs<T>,
     optionalArgs: OptionalArgs<T>,
@@ -23,4 +17,10 @@ export class PostCustomRevive extends CustomCallback<ModCallbackCustom.POST_CUST
       callbackRevivalType === undefined || revivalType === callbackRevivalType
     );
   };
+
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.CUSTOM_REVIVE];
+  }
 }

package/src/classes/callbacks/PostDiceRoomActivated.ts

@@ -15,34 +15,6 @@ const v = {
 };
 
 export class PostDiceRoomActivated extends CustomCallback<T> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 55
-      [
-        ModCallback.POST_EFFECT_UPDATE,
-        this.postEffectUpdateDiceFloor,
-        [EffectVariant.DICE_FLOOR],
-      ],
-    ];
-  }
-
-  protected override shouldFire = (
-    fireArgs: FireArgs<T>,
-    optionalArgs: OptionalArgs<T>,
-  ): boolean => {
-    const [_player, diceFloorSubType] = fireArgs;
-    const [callbackDiceFloorSubType] = optionalArgs;
-
-    return (
-      callbackDiceFloorSubType === undefined
-      || diceFloorSubType === callbackDiceFloorSubType
-    );
-  };
-
   // ModCallback.POST_EFFECT_UPDATE (55)
   // EffectVariant.DICE_FLOOR (76)
   private readonly postEffectUpdateDiceFloor = (effect: EntityEffect): void => {
@@ -59,7 +31,37 @@ export class PostDiceRoomActivated extends CustomCallback<T> {
     const closestPlayer = getClosestPlayer(effect.Position);
     if (isCloseEnoughToTriggerDiceFloor(closestPlayer, effect)) {
       v.room.diceRoomActivated = true;
-      this.fire(closestPlayer, effect.SubType as DiceFloorSubType);
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+      const diceFloorSubType = effect.SubType as DiceFloorSubType;
+      this.fire(closestPlayer, diceFloorSubType);
     }
   };
+
+  public override v = v;
+
+  protected override shouldFire = (
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean => {
+    const [_player, diceFloorSubType] = fireArgs;
+    const [callbackDiceFloorSubType] = optionalArgs;
+
+    return (
+      callbackDiceFloorSubType === undefined
+      || diceFloorSubType === callbackDiceFloorSubType
+    );
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 55
+      [
+        ModCallback.POST_EFFECT_UPDATE,
+        this.postEffectUpdateDiceFloor,
+        [EffectVariant.DICE_FLOOR],
+      ],
+    ];
+  }
 }

package/src/classes/callbacks/PostDoorRender.ts

@@ -5,6 +5,15 @@ import { shouldFireDoor } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostDoorRender extends CustomCallback<ModCallbackCustom.POST_DOOR_RENDER> {
+  // ModCallback.POST_RENDER (2)
+  private readonly postRender = (): void => {
+    for (const door of getDoors()) {
+      this.fire(door);
+    }
+  };
+
+  protected override shouldFire = shouldFireDoor;
+
   constructor() {
     super();
 
@@ -13,13 +22,4 @@ export class PostDoorRender extends CustomCallback<ModCallbackCustom.POST_DOOR_R
       [ModCallback.POST_RENDER, this.postRender],
     ];
   }
-
-  protected override shouldFire = shouldFireDoor;
-
-  // ModCallback.POST_RENDER (2)
-  private readonly postRender = (): void => {
-    for (const door of getDoors()) {
-      this.fire(door);
-    }
-  };
 }

package/src/classes/callbacks/PostDoorUpdate.ts

@@ -5,6 +5,15 @@ import { shouldFireDoor } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostDoorUpdate extends CustomCallback<ModCallbackCustom.POST_DOOR_UPDATE> {
+  // ModCallback.POST_UPDATE (1)
+  private readonly postUpdate = (): void => {
+    for (const door of getDoors()) {
+      this.fire(door);
+    }
+  };
+
+  protected override shouldFire = shouldFireDoor;
+
   constructor() {
     super();
 
@@ -13,13 +22,4 @@ export class PostDoorUpdate extends CustomCallback<ModCallbackCustom.POST_DOOR_U
       [ModCallback.POST_UPDATE, this.postUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireDoor;
-
-  // ModCallback.POST_UPDATE (1)
-  private readonly postUpdate = (): void => {
-    for (const door of getDoors()) {
-      this.fire(door);
-    }
-  };
 }

package/src/classes/callbacks/PostEffectInitFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireEffect } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostEffectInitFilter extends CustomCallback<ModCallbackCustom.POST_EFFECT_INIT_FILTER> {
+  // ModCallback.POST_EFFECT_INIT (54)
+  private readonly postEffectInit = (effect: EntityEffect) => {
+    this.fire(effect);
+  };
+
+  protected override shouldFire = shouldFireEffect;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostEffectInitFilter extends CustomCallback<ModCallbackCustom.POST_
       [ModCallback.POST_EFFECT_INIT, this.postEffectInit],
     ];
   }
-
-  protected override shouldFire = shouldFireEffect;
-
-  // ModCallback.POST_EFFECT_INIT (54)
-  private readonly postEffectInit = (effect: EntityEffect) => {
-    this.fire(effect);
-  };
 }

package/src/classes/callbacks/PostEffectInitLate.ts

@@ -10,8 +10,19 @@ const v = {
 };
 
 export class PostEffectInitLate extends CustomCallback<ModCallbackCustom.POST_EFFECT_INIT_LATE> {
+  // ModCallback.POST_EFFECT_UPDATE (55)
+  private readonly postEffectUpdate = (effect: EntityEffect): void => {
+    const index = GetPtrHash(effect);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
+      this.fire(effect);
+    }
+  };
+
   public override v = v;
 
+  protected override shouldFire = shouldFireEffect;
+
   constructor() {
     super();
 
@@ -20,15 +31,4 @@ export class PostEffectInitLate extends CustomCallback<ModCallbackCustom.POST_EF
       [ModCallback.POST_EFFECT_UPDATE, this.postEffectUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireEffect;
-
-  // ModCallback.POST_EFFECT_UPDATE (55)
-  private readonly postEffectUpdate = (effect: EntityEffect): void => {
-    const index = GetPtrHash(effect);
-    if (!v.room.firedSet.has(index)) {
-      v.room.firedSet.add(index);
-      this.fire(effect);
-    }
-  };
 }

package/src/classes/callbacks/PostEffectRenderFilter.ts

@@ -4,6 +4,16 @@ import { shouldFireEffect } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostEffectRenderFilter extends CustomCallback<ModCallbackCustom.POST_EFFECT_RENDER_FILTER> {
+  // ModCallback.POST_EFFECT_RENDER (56)
+  private readonly postEffectRender = (
+    effect: EntityEffect,
+    renderOffset: Vector,
+  ) => {
+    this.fire(effect, renderOffset);
+  };
+
+  protected override shouldFire = shouldFireEffect;
+
   constructor() {
     super();
 
@@ -12,14 +22,4 @@ export class PostEffectRenderFilter extends CustomCallback<ModCallbackCustom.POS
       [ModCallback.POST_EFFECT_RENDER, this.postEffectRender],
     ];
   }
-
-  protected override shouldFire = shouldFireEffect;
-
-  // ModCallback.POST_EFFECT_RENDER (56)
-  private readonly postEffectRender = (
-    effect: EntityEffect,
-    renderOffset: Vector,
-  ) => {
-    this.fire(effect, renderOffset);
-  };
 }