isaacscript-common 87.9.6 → 87.9.7

package/src/classes/features/callbackLogic/PlayerReorderedCallbacks.ts

@@ -18,8 +18,8 @@ import type { PostPlayerUpdateReordered } from "../../callbacks/PostPlayerUpdate
 import { Feature } from "../../private/Feature";
 
 interface QueueElement {
-  playerIndex: PlayerIndex;
-  renderOffset: Vector;
+  readonly playerIndex: PlayerIndex;
+  readonly renderOffset: Readonly<Vector>;
 }
 
 const v = {
@@ -33,45 +33,10 @@ const v = {
 };
 
 export class PlayerReorderedCallbacks extends Feature {
-  public override v = v;
-
   private readonly postPEffectUpdateReordered: PostPEffectUpdateReordered;
   private readonly postPlayerRenderReordered: PostPlayerRenderReordered;
   private readonly postPlayerUpdateReordered: PostPlayerUpdateReordered;
 
-  constructor(
-    postPEffectUpdateReordered: PostPEffectUpdateReordered,
-    postPlayerRenderReordered: PostPlayerRenderReordered,
-    postPlayerUpdateReordered: PostPlayerUpdateReordered,
-  ) {
-    super();
-
-    this.callbacksUsed = [
-      // 4
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      [ModCallback.POST_PEFFECT_UPDATE, this.postPEffectUpdate],
-
-      // 31
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      [ModCallback.POST_PLAYER_UPDATE, this.postPlayerUpdate],
-
-      // 32
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      [ModCallback.POST_PLAYER_RENDER, this.postPlayerRender],
-    ];
-
-    this.customCallbacksUsed = [
-      [
-        ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST,
-        this.postGameStartedReorderedLast,
-      ],
-    ];
-
-    this.postPEffectUpdateReordered = postPEffectUpdateReordered;
-    this.postPlayerRenderReordered = postPlayerRenderReordered;
-    this.postPlayerUpdateReordered = postPlayerUpdateReordered;
-  }
-
   // ModCallback.POST_PEFFECT_UPDATE (4)
   private readonly postPEffectUpdate = (player: EntityPlayer): void => {
     if (v.run.postGameStartedFiredOnThisRun) {
@@ -110,7 +75,10 @@ export class PlayerReorderedCallbacks extends Feature {
     } else {
       // Defer callback execution until the `POST_GAME_STARTED` callback fires.
       const playerIndex = getPlayerIndex(player);
-      v.run.postPlayerRenderQueue.push({ playerIndex, renderOffset });
+      v.run.postPlayerRenderQueue.push({
+        playerIndex,
+        renderOffset,
+      });
     }
   };
 
@@ -122,6 +90,41 @@ export class PlayerReorderedCallbacks extends Feature {
     dequeue(v.run.postPlayerUpdateQueue, this.postPlayerUpdateReordered.fire);
     dequeue(v.run.postPlayerRenderQueue, this.postPlayerRenderReordered.fire);
   };
+
+  public override v = v;
+
+  constructor(
+    postPEffectUpdateReordered: PostPEffectUpdateReordered,
+    postPlayerRenderReordered: PostPlayerRenderReordered,
+    postPlayerUpdateReordered: PostPlayerUpdateReordered,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      // 4
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      [ModCallback.POST_PEFFECT_UPDATE, this.postPEffectUpdate],
+
+      // 31
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      [ModCallback.POST_PLAYER_UPDATE, this.postPlayerUpdate],
+
+      // 32
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      [ModCallback.POST_PLAYER_RENDER, this.postPlayerRender],
+    ];
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST,
+        this.postGameStartedReorderedLast,
+      ],
+    ];
+
+    this.postPEffectUpdateReordered = postPEffectUpdateReordered;
+    this.postPlayerRenderReordered = postPlayerRenderReordered;
+    this.postPlayerUpdateReordered = postPlayerUpdateReordered;
+  }
 }
 
 function dequeue(

package/src/classes/features/callbackLogic/SlotDestroyedDetection.ts

@@ -31,11 +31,41 @@ const v = {
 };
 
 export class SlotDestroyedDetection extends Feature {
-  public override v = v;
-
   private readonly postSlotDestroyed: PostSlotDestroyed;
   private readonly roomHistory: RoomHistory;
 
+  // ModCallback.POST_ENTITY_REMOVE (67)
+  // EntityType.SLOT (6)
+  private readonly postEntityRemoveSlot = (entity: Entity) => {
+    // The `POST_ENTITY_REMOVE` callback will fire for slots that are naturally despawning as a
+    // player leaves a room. We want to ignore all slots that despawn for this reason.
+    if (this.roomHistory.isLeavingRoom()) {
+      return;
+    }
+
+    const slot = entity as EntitySlot;
+
+    if (isSlotMachine(slot)) {
+      this.postEntityRemoveSlotMachine(slot);
+    } else {
+      this.postEntityRemoveBeggar(slot);
+    }
+  };
+
+  // ModCallbackCustom.POST_SLOT_UPDATE
+  private readonly postSlotUpdate = (slot: EntitySlot) => {
+    const ptrHash = GetPtrHash(slot);
+
+    const alreadyDestroyed = v.room.destroyedSlotSet.has(ptrHash);
+    if (alreadyDestroyed) {
+      return;
+    }
+
+    this.checkDestroyedFromCollisionClass(slot);
+  };
+
+  public override v = v;
+
   constructor(postSlotDestroyed: PostSlotDestroyed, roomHistory: RoomHistory) {
     super();
 
@@ -58,24 +88,6 @@ export class SlotDestroyedDetection extends Feature {
     this.roomHistory = roomHistory;
   }
 
-  // ModCallback.POST_ENTITY_REMOVE (67)
-  // EntityType.SLOT (6)
-  private readonly postEntityRemoveSlot = (entity: Entity) => {
-    const slot = entity as EntitySlot;
-
-    // The `POST_ENTITY_REMOVE` callback will fire for slots that are naturally despawning as a
-    // player leaves a room. We want to ignore all slots that despawn for this reason.
-    if (this.roomHistory.isLeavingRoom()) {
-      return;
-    }
-
-    if (isSlotMachine(slot)) {
-      this.postEntityRemoveSlotMachine(slot);
-    } else {
-      this.postEntityRemoveBeggar(slot);
-    }
-  };
-
   private postEntityRemoveSlotMachine(slot: EntitySlot) {
     this.postSlotDestroyed.fire(slot, SlotDestructionType.COLLECTIBLE_PAYOUT);
   }
@@ -90,18 +102,6 @@ export class SlotDestroyedDetection extends Feature {
     this.postSlotDestroyed.fire(slot, slotDestructionType);
   }
 
-  // ModCallbackCustom.POST_SLOT_UPDATE
-  private readonly postSlotUpdate = (slot: EntitySlot) => {
-    const ptrHash = GetPtrHash(slot);
-
-    const alreadyDestroyed = v.room.destroyedSlotSet.has(ptrHash);
-    if (alreadyDestroyed) {
-      return;
-    }
-
-    this.checkDestroyedFromCollisionClass(slot);
-  };
-
   /**
    * Slots normally have an entity collision class of `EntityCollisionClass.ALL` (4) and a grid
    * collision class of `EntityGridCollisionClass.NONE` (0). When they are destroyed with a bomb,
@@ -109,10 +109,12 @@ export class SlotDestroyedDetection extends Feature {
    * `EntityGridCollisionClass.GROUND` (5).
    */
   private checkDestroyedFromCollisionClass(slot: EntitySlot) {
-    if (slot.GridCollisionClass === EntityGridCollisionClass.GROUND) {
-      const ptrHash = GetPtrHash(slot);
-      v.room.destroyedSlotSet.add(ptrHash);
-      this.postSlotDestroyed.fire(slot, SlotDestructionType.NORMAL);
+    if (slot.GridCollisionClass !== EntityGridCollisionClass.GROUND) {
+      return;
     }
+
+    const ptrHash = GetPtrHash(slot);
+    v.room.destroyedSlotSet.add(ptrHash);
+    this.postSlotDestroyed.fire(slot, SlotDestructionType.NORMAL);
   }
 }

package/src/classes/features/callbackLogic/SlotRenderDetection.ts

@@ -18,11 +18,19 @@ const v = {
 };
 
 export class SlotRenderDetection extends Feature {
-  public override v = v;
-
   private readonly postSlotRender: PostSlotRender;
   private readonly postSlotAnimationChanged: PostSlotAnimationChanged;
 
+  // ModCallback.POST_RENDER (2)
+  private readonly postRender = () => {
+    for (const slot of getSlots()) {
+      this.postSlotRender.fire(slot);
+      this.checkSlotAnimationChanged(slot);
+    }
+  };
+
+  public override v = v;
+
   constructor(
     postSlotRender: PostSlotRender,
     postSlotAnimationChanged: PostSlotAnimationChanged,
@@ -38,14 +46,6 @@ export class SlotRenderDetection extends Feature {
     this.postSlotAnimationChanged = postSlotAnimationChanged;
   }
 
-  // ModCallback.POST_RENDER (2)
-  private readonly postRender = () => {
-    for (const slot of getSlots()) {
-      this.postSlotRender.fire(slot);
-      this.checkSlotAnimationChanged(slot);
-    }
-  };
-
   private checkSlotAnimationChanged(slot: EntitySlot) {
     const sprite = slot.GetSprite();
     const currentAnimation = sprite.GetAnimation();

package/src/classes/features/callbackLogic/SlotUpdateDetection.ts

@@ -12,11 +12,26 @@ const v = {
 };
 
 export class SlotUpdateDetection extends Feature {
-  public override v = v;
-
   private readonly postSlotInit: PostSlotInit;
   private readonly postSlotUpdate: PostSlotUpdate;
 
+  // ModCallback.POST_UPDATE (1)
+  private readonly postUpdate = () => {
+    for (const slot of getSlots()) {
+      this.checkNewEntity(slot);
+      this.postSlotUpdate.fire(slot);
+    }
+  };
+
+  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+  private readonly postNewRoomReordered = () => {
+    for (const slot of getSlots()) {
+      this.checkNewEntity(slot);
+    }
+  };
+
+  public override v = v;
+
   constructor(postSlotInit: PostSlotInit, postSlotUpdate: PostSlotUpdate) {
     super();
 
@@ -35,21 +50,6 @@ export class SlotUpdateDetection extends Feature {
     this.postSlotUpdate = postSlotUpdate;
   }
 
-  // ModCallback.POST_UPDATE (1)
-  private readonly postUpdate = () => {
-    for (const slot of getSlots()) {
-      this.checkNewEntity(slot);
-      this.postSlotUpdate.fire(slot);
-    }
-  };
-
-  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
-  private readonly postNewRoomReordered = () => {
-    for (const slot of getSlots()) {
-      this.checkNewEntity(slot);
-    }
-  };
-
   private checkNewEntity(slot: EntitySlot) {
     const ptrHash = GetPtrHash(slot);
     if (!v.room.initializedSlots.has(ptrHash)) {

package/src/classes/features/other/CharacterHealthConversion.ts

@@ -16,27 +16,6 @@ export class CharacterHealthConversion extends Feature {
     ConversionHeartSubType
   >();
 
-  /** @internal */
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 38
-      [
-        ModCallback.PRE_PICKUP_COLLISION,
-        this.prePickupCollisionHeart,
-        [PickupVariant.HEART],
-      ],
-    ];
-
-    this.customCallbacksUsed = [
-      [
-        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-        this.postPEffectUpdateReordered,
-      ],
-    ];
-  }
-
   // ModCallback.PRE_PICKUP_COLLISION (38)
   // PickupVariant.HEART (10)
   private readonly prePickupCollisionHeart = (
@@ -77,6 +56,27 @@ export class CharacterHealthConversion extends Feature {
     removeRedHearts(player);
   };
 
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 38
+      [
+        ModCallback.PRE_PICKUP_COLLISION,
+        this.prePickupCollisionHeart,
+        [PickupVariant.HEART],
+      ],
+    ];
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+        this.postPEffectUpdateReordered,
+      ],
+    ];
+  }
+
   /**
    * Helper function to make a character that has the same health mechanic as Blue Baby (red heart
    * containers --> soul hearts) or Dark Judas (red heart containers --> black hearts).
@@ -112,7 +112,7 @@ function convertRedHeartContainers(
     return;
   }
 
-  player.AddMaxHearts(maxHearts * -1, false);
+  player.AddMaxHearts(-maxHearts, false);
 
   switch (heartSubType) {
     case HeartSubType.SOUL: {
@@ -134,6 +134,6 @@ function convertRedHeartContainers(
 function removeRedHearts(player: EntityPlayer) {
   const hearts = player.GetHearts();
   if (hearts > 0) {
-    player.AddHearts(hearts * -1);
+    player.AddHearts(-hearts);
   }
 }

package/src/classes/features/other/CharacterStats.ts

@@ -10,16 +10,6 @@ type StatMap = ReadonlyMap<CacheFlag, number>;
 export class CharacterStats extends Feature {
   private readonly charactersStatMap = new Map<PlayerType, StatMap>();
 
-  /** @internal */
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 8
-      [ModCallback.EVALUATE_CACHE, this.evaluateCache],
-    ];
-  }
-
   // ModCallback.EVALUATE_CACHE (8)
   private readonly evaluateCache = (
     player: EntityPlayer,
@@ -41,6 +31,16 @@ export class CharacterStats extends Feature {
     addPlayerStat(player, cacheFlag, delta);
   };
 
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 8
+      [ModCallback.EVALUATE_CACHE, this.evaluateCache],
+    ];
+  }
+
   /**
    * Helper function to manage the stats for a vanilla or custom character. Call this function once
    * at the beginning of your mod to declare the starting stats.

package/src/classes/features/other/CollectibleItemPoolType.ts

@@ -17,11 +17,24 @@ const v = {
 };
 
 export class CollectibleItemPoolType extends Feature {
+  private readonly pickupIndexCreation: PickupIndexCreation;
+
+  // ModCallback.POST_PICKUP_INIT (34)
+  // PickupVariant.COLLECTIBLE (100)
+  private readonly postPickupInitCollectible = (collectible: EntityPickup) => {
+    const pickupIndex = this.pickupIndexCreation.getPickupIndex(collectible);
+
+    if (!v.run.collectibleItemPoolTypeMap.has(pickupIndex)) {
+      const itemPool = game.GetItemPool();
+      const lastItemPoolType = itemPool.GetLastPool();
+
+      v.run.collectibleItemPoolTypeMap.set(pickupIndex, lastItemPoolType);
+    }
+  };
+
   /** @internal */
   public override v = v;
 
-  private readonly pickupIndexCreation: PickupIndexCreation;
-
   /** @internal */
   constructor(pickupIndexCreation: PickupIndexCreation) {
     super();
@@ -40,19 +53,6 @@ export class CollectibleItemPoolType extends Feature {
     this.pickupIndexCreation = pickupIndexCreation;
   }
 
-  // ModCallback.POST_PICKUP_INIT (34)
-  // PickupVariant.COLLECTIBLE (100)
-  private readonly postPickupInitCollectible = (collectible: EntityPickup) => {
-    const pickupIndex = this.pickupIndexCreation.getPickupIndex(collectible);
-
-    if (!v.run.collectibleItemPoolTypeMap.has(pickupIndex)) {
-      const itemPool = game.GetItemPool();
-      const lastItemPoolType = itemPool.GetLastPool();
-
-      v.run.collectibleItemPoolTypeMap.set(pickupIndex, lastItemPoolType);
-    }
-  };
-
   /**
    * Helper function to get the item pool type that a given collectible came from. Since there is no
    * native method in the API to get this, we listen in the `POST_PICKUP_INIT` callback for

package/src/classes/features/other/CustomHotkeys.ts

@@ -22,16 +22,6 @@ export class CustomHotkeys extends Feature {
 
   private readonly keyPressedMap = new DefaultMap<Keyboard, boolean>(false);
 
-  /** @internal */
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 2
-      [ModCallback.POST_RENDER, this.postRender],
-    ];
-  }
-
   // ModCallback.POST_RENDER (2)
   private readonly postRender = () => {
     for (const [keyboard, triggerFunc] of this.staticHotkeyFunctionMap) {
@@ -46,6 +36,16 @@ export class CustomHotkeys extends Feature {
     }
   };
 
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 2
+      [ModCallback.POST_RENDER, this.postRender],
+    ];
+  }
+
   private checkIfTriggered(keyboard: Keyboard, triggerFunc: () => void) {
     const isPressed = isKeyboardPressed(keyboard);
     const wasPreviouslyPressed = this.keyPressedMap.getAndSetDefault(keyboard);

package/src/classes/features/other/CustomItemPools.ts

@@ -25,6 +25,12 @@ const customItemPoolMap = new Map<
 >();
 
 export class CustomItemPools extends Feature {
+  // ModCallbackCustom.POST_GAME_STARTED_REORDERED
+  // false
+  private readonly postGameStartedReorderedFalse = () => {
+    v.run.customItemPools = copyMap(customItemPoolMap);
+  };
+
   /** @internal */
   public override v = v;
 
@@ -41,12 +47,6 @@ export class CustomItemPools extends Feature {
     ];
   }
 
-  // ModCallbackCustom.POST_GAME_STARTED_REORDERED
-  // false
-  private readonly postGameStartedReorderedFalse = () => {
-    v.run.customItemPools = copyMap(customItemPoolMap);
-  };
-
   /**
    * Helper function to register a custom item pool. Use this function once when your mod first
    * loads to declare the items that you want to be in the item pools. Then, in the middle of a run,

package/src/classes/features/other/CustomPickups.ts

@@ -14,8 +14,12 @@ import { spawnEffect } from "../../../functions/entitiesSpecific";
 import { Feature } from "../../private/Feature";
 
 interface CustomPickupFunctions {
-  collectFunc: (this: void, pickup: EntityPickup, player: EntityPlayer) => void;
-  collisionFunc: (
+  readonly collectFunc: (
+    this: void,
+    pickup: EntityPickup,
+    player: EntityPlayer,
+  ) => void;
+  readonly collisionFunc: (
     this: void,
     pickup: EntityPickup,
     player: EntityPlayer,
@@ -40,23 +44,6 @@ export class CustomPickups extends Feature {
     CustomPickupFunctions
   >();
 
-  /** @internal */
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 38
-      [ModCallback.PRE_PICKUP_COLLISION, this.prePickupCollision],
-
-      // 56
-      [
-        ModCallback.POST_EFFECT_RENDER,
-        this.postEffectRenderPickupEffect,
-        [PICKUP_EFFECT_VARIANT],
-      ],
-    ];
-  }
-
   // ModCallback.PRE_PICKUP_COLLISION (38)
   private readonly prePickupCollision = (
     pickup: EntityPickup,
@@ -111,6 +98,23 @@ export class CustomPickups extends Feature {
     }
   };
 
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 38
+      [ModCallback.PRE_PICKUP_COLLISION, this.prePickupCollision],
+
+      // 56
+      [
+        ModCallback.POST_EFFECT_RENDER,
+        this.postEffectRenderPickupEffect,
+        [PICKUP_EFFECT_VARIANT],
+      ],
+    ];
+  }
+
   /**
    * Helper function to register a custom pickup with the IsaacScript standard library. Use this
    * feature for custom pickups that are intended to be picked up by the player, like bombs and