isaacscript-common 87.9.6 → 87.9.8

package/src/classes/callbacks/PostItemDischarge.ts

@@ -42,8 +42,71 @@ const v = {
 };
 
 export class PostItemDischarge extends CustomCallback<T> {
+  // ModCallback.PRE_NPC_COLLISION (30)
+  // EntityType.SUCKER (61)
+  private readonly preNPCCollisionSucker = (
+    npc: EntityNPC,
+    collider: Entity,
+  ): boolean | undefined => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+    if (npc.Variant === SuckerVariant.BULB) {
+      return this.preNPCCollisionBulb(npc, collider);
+    }
+
+    return undefined;
+  };
+
+  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+  private readonly postPEffectUpdateReordered = (player: EntityPlayer) => {
+    const activeItemMap = defaultMapGetPlayer(
+      v.run.playersActiveItemMap,
+      player,
+    );
+    const chargeMap = defaultMapGetPlayer(v.run.playersActiveChargeMap, player);
+
+    for (const activeSlot of ACTIVE_SLOT_VALUES) {
+      const currentActiveItem = player.GetActiveItem();
+      let previousActiveItem = activeItemMap.get(activeSlot);
+      previousActiveItem ??= currentActiveItem;
+      activeItemMap.set(activeSlot, currentActiveItem);
+
+      if (currentActiveItem !== previousActiveItem) {
+        // The player swapped out their active item for something else, so it should be impossible
+        // for the discharge callback to fire on this frame.
+        continue;
+      }
+
+      const currentCharge = getTotalCharge(player, activeSlot);
+      let previousCharge = chargeMap.get(activeSlot);
+      previousCharge ??= currentCharge;
+      chargeMap.set(activeSlot, currentCharge);
+
+      if (this.playerRecentlyCollidedWithBulb(player)) {
+        continue;
+      }
+
+      if (currentCharge < previousCharge) {
+        const collectibleType = player.GetActiveItem(activeSlot);
+        this.fire(player, collectibleType, activeSlot);
+      }
+    }
+  };
+
   public override v = v;
 
+  protected override shouldFire = (
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean => {
+    const [_player, collectibleType] = fireArgs;
+    const [callbackCollectibleType] = optionalArgs;
+
+    return (
+      callbackCollectibleType === undefined
+      || callbackCollectibleType === collectibleType
+    );
+  };
+
   constructor() {
     super();
 
@@ -64,33 +127,6 @@ export class PostItemDischarge extends CustomCallback<T> {
     ];
   }
 
-  protected override shouldFire = (
-    fireArgs: FireArgs<T>,
-    optionalArgs: OptionalArgs<T>,
-  ): boolean => {
-    const [_player, collectibleType] = fireArgs;
-    const [callbackCollectibleType] = optionalArgs;
-
-    return (
-      callbackCollectibleType === undefined
-      || callbackCollectibleType === collectibleType
-    );
-  };
-
-  // ModCallback.PRE_NPC_COLLISION (30)
-  // EntityType.SUCKER (61)
-  private readonly preNPCCollisionSucker = (
-    npc: EntityNPC,
-    collider: Entity,
-  ): boolean | undefined => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
-    if (npc.Variant === SuckerVariant.BULB) {
-      return this.preNPCCollisionBulb(npc, collider);
-    }
-
-    return undefined;
-  };
-
   // ModCallback.PRE_NPC_COLLISION (30)
   // EntityType.SUCKER (61)
   private preNPCCollisionBulb(
@@ -122,42 +158,6 @@ export class PostItemDischarge extends CustomCallback<T> {
     mapSetPlayer(v.room.playersBulbLastCollisionFrame, player, gameFrameCount);
   }
 
-  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-  private readonly postPEffectUpdateReordered = (player: EntityPlayer) => {
-    const activeItemMap = defaultMapGetPlayer(
-      v.run.playersActiveItemMap,
-      player,
-    );
-    const chargeMap = defaultMapGetPlayer(v.run.playersActiveChargeMap, player);
-
-    for (const activeSlot of ACTIVE_SLOT_VALUES) {
-      const currentActiveItem = player.GetActiveItem();
-      let previousActiveItem = activeItemMap.get(activeSlot);
-      previousActiveItem ??= currentActiveItem;
-      activeItemMap.set(activeSlot, currentActiveItem);
-
-      if (currentActiveItem !== previousActiveItem) {
-        // The player swapped out their active item for something else, so it should be impossible
-        // for the discharge callback to fire on this frame.
-        continue;
-      }
-
-      const currentCharge = getTotalCharge(player, activeSlot);
-      let previousCharge = chargeMap.get(activeSlot);
-      previousCharge ??= currentCharge;
-      chargeMap.set(activeSlot, currentCharge);
-
-      if (this.playerRecentlyCollidedWithBulb(player)) {
-        continue;
-      }
-
-      if (currentCharge < previousCharge) {
-        const collectibleType = player.GetActiveItem(activeSlot);
-        this.fire(player, collectibleType, activeSlot);
-      }
-    }
-  };
-
   /**
    * If the player collided with a Bulb on either this frame or the last frame, then assume a zap
    * has occurred. (We do not want to fire the discharge callback if this is the case.)

package/src/classes/callbacks/PostItemPickup.ts

@@ -4,11 +4,10 @@ import { shouldFireItemPickup } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostItemPickup extends CustomCallback<ModCallbackCustom.POST_ITEM_PICKUP> {
+  protected override shouldFire = shouldFireItemPickup;
   constructor() {
     super();
 
     this.featuresUsed = [ISCFeature.ITEM_PICKUP_DETECTION];
   }
-
-  protected override shouldFire = shouldFireItemPickup;
 }

package/src/classes/callbacks/PostKeyboardChanged.ts

@@ -15,16 +15,29 @@ const v = {
 };
 
 export class PostKeyboardChanged extends CustomCallback<T> {
-  public override v = v;
+  private readonly postRender = () => {
+    for (const keyboard of v.run.pressedKeys) {
+      if (isKeyboardPressed(keyboard)) {
+        continue;
+      }
 
-  constructor() {
-    super();
+      v.run.pressedKeys.delete(keyboard);
+      this.fire(keyboard, false);
+    }
 
-    this.callbacksUsed = [
-      // 2
-      [ModCallback.POST_RENDER, this.postRender],
-    ];
-  }
+    for (const keyboard of KEYBOARD_VALUES) {
+      if (v.run.pressedKeys.has(keyboard)) {
+        continue;
+      }
+
+      if (isKeyboardPressed(keyboard)) {
+        v.run.pressedKeys.add(keyboard);
+        this.fire(keyboard, true);
+      }
+    }
+  };
+
+  public override v = v;
 
   protected override shouldFire = (
     fireArgs: FireArgs<T>,
@@ -39,23 +52,12 @@ export class PostKeyboardChanged extends CustomCallback<T> {
     );
   };
 
-  private readonly postRender = () => {
-    for (const keyboard of v.run.pressedKeys) {
-      if (!isKeyboardPressed(keyboard)) {
-        v.run.pressedKeys.delete(keyboard);
-        this.fire(keyboard, false);
-      }
-    }
-
-    for (const keyboard of KEYBOARD_VALUES) {
-      if (v.run.pressedKeys.has(keyboard)) {
-        continue;
-      }
+  constructor() {
+    super();
 
-      if (isKeyboardPressed(keyboard)) {
-        v.run.pressedKeys.add(keyboard);
-        this.fire(keyboard, true);
-      }
-    }
-  };
+    this.callbacksUsed = [
+      // 2
+      [ModCallback.POST_RENDER, this.postRender],
+    ];
+  }
 }

package/src/classes/callbacks/PostKnifeInitFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireKnife } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostKnifeInitFilter extends CustomCallback<ModCallbackCustom.POST_KNIFE_INIT_FILTER> {
+  // ModCallback.POST_KNIFE_INIT (50)
+  private readonly postKnifeInit = (knife: EntityKnife) => {
+    this.fire(knife);
+  };
+
+  protected override shouldFire = shouldFireKnife;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostKnifeInitFilter extends CustomCallback<ModCallbackCustom.POST_K
       [ModCallback.POST_KNIFE_INIT, this.postKnifeInit],
     ];
   }
-
-  protected override shouldFire = shouldFireKnife;
-
-  // ModCallback.POST_KNIFE_INIT (50)
-  private readonly postKnifeInit = (knife: EntityKnife) => {
-    this.fire(knife);
-  };
 }

package/src/classes/callbacks/PostKnifeInitLate.ts

@@ -10,8 +10,19 @@ const v = {
 };
 
 export class PostKnifeInitLate extends CustomCallback<ModCallbackCustom.POST_KNIFE_INIT_LATE> {
+  // ModCallback.POST_KNIFE_UPDATE (51)
+  private readonly postKnifeUpdate = (knife: EntityKnife): void => {
+    const ptrHash = GetPtrHash(knife);
+    if (!v.room.firedSet.has(ptrHash)) {
+      v.room.firedSet.add(ptrHash);
+      this.fire(knife);
+    }
+  };
+
   public override v = v;
 
+  protected override shouldFire = shouldFireKnife;
+
   constructor() {
     super();
 
@@ -20,15 +31,4 @@ export class PostKnifeInitLate extends CustomCallback<ModCallbackCustom.POST_KNI
       [ModCallback.POST_KNIFE_UPDATE, this.postKnifeUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireKnife;
-
-  // ModCallback.POST_KNIFE_UPDATE (51)
-  private readonly postKnifeUpdate = (knife: EntityKnife): void => {
-    const ptrHash = GetPtrHash(knife);
-    if (!v.room.firedSet.has(ptrHash)) {
-      v.room.firedSet.add(ptrHash);
-      this.fire(knife);
-    }
-  };
 }

package/src/classes/callbacks/PostKnifeRenderFilter.ts

@@ -4,6 +4,16 @@ import { shouldFireKnife } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostKnifeRenderFilter extends CustomCallback<ModCallbackCustom.POST_KNIFE_RENDER_FILTER> {
+  // ModCallback.POST_KNIFE_RENDER (52)
+  private readonly postKnifeRender = (
+    knife: EntityKnife,
+    renderOffset: Vector,
+  ) => {
+    this.fire(knife, renderOffset);
+  };
+
+  protected override shouldFire = shouldFireKnife;
+
   constructor() {
     super();
 
@@ -12,14 +22,4 @@ export class PostKnifeRenderFilter extends CustomCallback<ModCallbackCustom.POST
       [ModCallback.POST_KNIFE_RENDER, this.postKnifeRender],
     ];
   }
-
-  protected override shouldFire = shouldFireKnife;
-
-  // ModCallback.POST_KNIFE_RENDER (52)
-  private readonly postKnifeRender = (
-    knife: EntityKnife,
-    renderOffset: Vector,
-  ) => {
-    this.fire(knife, renderOffset);
-  };
 }

package/src/classes/callbacks/PostKnifeUpdateFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireKnife } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostKnifeUpdateFilter extends CustomCallback<ModCallbackCustom.POST_KNIFE_UPDATE_FILTER> {
+  // ModCallback.POST_KNIFE_UPDATE (51)
+  private readonly postKnifeUpdate = (knife: EntityKnife) => {
+    this.fire(knife);
+  };
+
+  protected override shouldFire = shouldFireKnife;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostKnifeUpdateFilter extends CustomCallback<ModCallbackCustom.POST
       [ModCallback.POST_KNIFE_UPDATE, this.postKnifeUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireKnife;
-
-  // ModCallback.POST_KNIFE_UPDATE (51)
-  private readonly postKnifeUpdate = (knife: EntityKnife) => {
-    this.fire(knife);
-  };
 }

package/src/classes/callbacks/PostLaserInitFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireLaser } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostLaserInitFilter extends CustomCallback<ModCallbackCustom.POST_LASER_INIT_FILTER> {
+  // ModCallback.POST_LASER_INIT (47)
+  private readonly postLaserInit = (laser: EntityLaser) => {
+    this.fire(laser);
+  };
+
+  protected override shouldFire = shouldFireLaser;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostLaserInitFilter extends CustomCallback<ModCallbackCustom.POST_L
       [ModCallback.POST_LASER_INIT, this.postLaserInit],
     ];
   }
-
-  protected override shouldFire = shouldFireLaser;
-
-  // ModCallback.POST_LASER_INIT (47)
-  private readonly postLaserInit = (laser: EntityLaser) => {
-    this.fire(laser);
-  };
 }

package/src/classes/callbacks/PostLaserInitLate.ts

@@ -10,8 +10,19 @@ const v = {
 };
 
 export class PostLaserInitLate extends CustomCallback<ModCallbackCustom.POST_LASER_INIT_LATE> {
+  // ModCallback.POST_LASER_UPDATE (48)
+  private readonly postLaserUpdate = (laser: EntityLaser) => {
+    const index = GetPtrHash(laser);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
+      this.fire(laser);
+    }
+  };
+
   public override v = v;
 
+  protected override shouldFire = shouldFireLaser;
+
   constructor() {
     super();
 
@@ -20,15 +31,4 @@ export class PostLaserInitLate extends CustomCallback<ModCallbackCustom.POST_LAS
       [ModCallback.POST_LASER_UPDATE, this.postLaserUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireLaser;
-
-  // ModCallback.POST_LASER_UPDATE (48)
-  private readonly postLaserUpdate = (laser: EntityLaser) => {
-    const index = GetPtrHash(laser);
-    if (!v.room.firedSet.has(index)) {
-      v.room.firedSet.add(index);
-      this.fire(laser);
-    }
-  };
 }

package/src/classes/callbacks/PostLaserRenderFilter.ts

@@ -4,6 +4,16 @@ import { shouldFireLaser } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostLaserRenderFilter extends CustomCallback<ModCallbackCustom.POST_LASER_RENDER_FILTER> {
+  // ModCallback.POST_LASER_RENDER (49)
+  private readonly postLaserRender = (
+    laser: EntityLaser,
+    renderOffset: Vector,
+  ) => {
+    this.fire(laser, renderOffset);
+  };
+
+  protected override shouldFire = shouldFireLaser;
+
   constructor() {
     super();
 
@@ -12,14 +22,4 @@ export class PostLaserRenderFilter extends CustomCallback<ModCallbackCustom.POST
       [ModCallback.POST_LASER_RENDER, this.postLaserRender],
     ];
   }
-
-  protected override shouldFire = shouldFireLaser;
-
-  // ModCallback.POST_LASER_RENDER (49)
-  private readonly postLaserRender = (
-    laser: EntityLaser,
-    renderOffset: Vector,
-  ) => {
-    this.fire(laser, renderOffset);
-  };
 }

package/src/classes/callbacks/PostLaserUpdateFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireLaser } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostLaserUpdateFilter extends CustomCallback<ModCallbackCustom.POST_LASER_UPDATE_FILTER> {
+  // ModCallback.POST_LASER_UPDATE (48)
+  private readonly postLaserUpdate = (laser: EntityLaser) => {
+    this.fire(laser);
+  };
+
+  protected override shouldFire = shouldFireLaser;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostLaserUpdateFilter extends CustomCallback<ModCallbackCustom.POST
       [ModCallback.POST_LASER_UPDATE, this.postLaserUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireLaser;
-
-  // ModCallback.POST_LASER_UPDATE (48)
-  private readonly postLaserUpdate = (laser: EntityLaser) => {
-    this.fire(laser);
-  };
 }

package/src/classes/callbacks/PostNPCDeathFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireNPC } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostNPCDeathFilter extends CustomCallback<ModCallbackCustom.POST_NPC_DEATH_FILTER> {
+  // ModCallback.POST_NPC_DEATH (29)
+  private readonly postNPCDeath = (npc: EntityNPC) => {
+    this.fire(npc);
+  };
+
+  protected override shouldFire = shouldFireNPC;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostNPCDeathFilter extends CustomCallback<ModCallbackCustom.POST_NP
       [ModCallback.POST_NPC_DEATH, this.postNPCDeath],
     ];
   }
-
-  protected override shouldFire = shouldFireNPC;
-
-  // ModCallback.POST_NPC_DEATH (29)
-  private readonly postNPCDeath = (npc: EntityNPC) => {
-    this.fire(npc);
-  };
 }

package/src/classes/callbacks/PostNPCInitFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireNPC } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostNPCInitFilter extends CustomCallback<ModCallbackCustom.POST_NPC_INIT_FILTER> {
+  // ModCallback.POST_NPC_INIT (27)
+  private readonly postNPCInit = (npc: EntityNPC) => {
+    this.fire(npc);
+  };
+
+  protected override shouldFire = shouldFireNPC;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostNPCInitFilter extends CustomCallback<ModCallbackCustom.POST_NPC
       [ModCallback.POST_NPC_INIT, this.postNPCInit],
     ];
   }
-
-  protected override shouldFire = shouldFireNPC;
-
-  // ModCallback.POST_NPC_INIT (27)
-  private readonly postNPCInit = (npc: EntityNPC) => {
-    this.fire(npc);
-  };
 }

package/src/classes/callbacks/PostNPCInitLate.ts

@@ -10,8 +10,19 @@ const v = {
 };
 
 export class PostNPCInitLate extends CustomCallback<ModCallbackCustom.POST_NPC_INIT_LATE> {
+  // ModCallback.POST_NPC_UPDATE (0)
+  private readonly postNPCUpdate = (npc: EntityNPC) => {
+    const index = GetPtrHash(npc);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
+      this.fire(npc);
+    }
+  };
+
   public override v = v;
 
+  protected override shouldFire = shouldFireNPC;
+
   constructor() {
     super();
 
@@ -20,15 +31,4 @@ export class PostNPCInitLate extends CustomCallback<ModCallbackCustom.POST_NPC_I
       [ModCallback.POST_NPC_UPDATE, this.postNPCUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireNPC;
-
-  // ModCallback.POST_NPC_UPDATE (0)
-  private readonly postNPCUpdate = (npc: EntityNPC) => {
-    const index = GetPtrHash(npc);
-    if (!v.room.firedSet.has(index)) {
-      v.room.firedSet.add(index);
-      this.fire(npc);
-    }
-  };
 }

package/src/classes/callbacks/PostNPCRenderFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireNPC } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostNPCRenderFilter extends CustomCallback<ModCallbackCustom.POST_NPC_RENDER_FILTER> {
+  // ModCallback.POST_NPC_RENDER (28)
+  private readonly postNPCRender = (npc: EntityNPC, renderOffset: Vector) => {
+    this.fire(npc, renderOffset);
+  };
+
+  protected override shouldFire = shouldFireNPC;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostNPCRenderFilter extends CustomCallback<ModCallbackCustom.POST_N
       [ModCallback.POST_NPC_RENDER, this.postNPCRender],
     ];
   }
-
-  protected override shouldFire = shouldFireNPC;
-
-  // ModCallback.POST_NPC_RENDER (28)
-  private readonly postNPCRender = (npc: EntityNPC, renderOffset: Vector) => {
-    this.fire(npc, renderOffset);
-  };
 }

package/src/classes/callbacks/PostNPCStateChanged.ts

@@ -14,19 +14,6 @@ const v = {
 };
 
 export class PostNPCStateChanged extends CustomCallback<ModCallbackCustom.POST_NPC_STATE_CHANGED> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 0
-      [ModCallback.POST_NPC_UPDATE, this.postNPCUpdate],
-    ];
-  }
-
-  protected override shouldFire = shouldFireNPC;
-
   // ModCallback.POST_NPC_UPDATE (0)
   private readonly postNPCUpdate = (npc: EntityNPC) => {
     const ptrHash = GetPtrHash(npc);
@@ -38,4 +25,17 @@ export class PostNPCStateChanged extends CustomCallback<ModCallbackCustom.POST_N
       this.fire(npc, previousState, currentState);
     }
   };
+
+  public override v = v;
+
+  protected override shouldFire = shouldFireNPC;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 0
+      [ModCallback.POST_NPC_UPDATE, this.postNPCUpdate],
+    ];
+  }
 }

package/src/classes/callbacks/PostNPCUpdateFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireNPC } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostNPCUpdateFilter extends CustomCallback<ModCallbackCustom.POST_NPC_UPDATE_FILTER> {
+  // ModCallback.POST_NPC_INIT (0)
+  private readonly postNPCUpdate = (npc: EntityNPC) => {
+    this.fire(npc);
+  };
+
+  protected override shouldFire = shouldFireNPC;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostNPCUpdateFilter extends CustomCallback<ModCallbackCustom.POST_N
       [ModCallback.POST_NPC_UPDATE, this.postNPCUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireNPC;
-
-  // ModCallback.POST_NPC_INIT (0)
-  private readonly postNPCUpdate = (npc: EntityNPC) => {
-    this.fire(npc);
-  };
 }

package/src/classes/callbacks/PostNewLevelReordered.ts

@@ -4,11 +4,10 @@ import { shouldFireLevel } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostNewLevelReordered extends CustomCallback<ModCallbackCustom.POST_NEW_LEVEL_REORDERED> {
+  protected override shouldFire = shouldFireLevel;
   constructor() {
     super();
 
     this.featuresUsed = [ISCFeature.GAME_REORDERED_CALLBACKS];
   }
-
-  protected override shouldFire = shouldFireLevel;
 }