isaacscript-common 87.9.6 → 87.9.7

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

@@ -39,48 +39,6 @@ export class GameReorderedCallbacks extends Feature {
   private readonly postNewRoomReordered: PostNewRoomReordered;
   private readonly postGameStartedReorderedLast: PostGameStartedReorderedLast;
 
-  /** @internal */
-  constructor(
-    postGameStartedReordered: PostGameStartedReordered,
-    postNewLevelReordered: PostNewLevelReordered,
-    postNewRoomReordered: PostNewRoomReordered,
-    postGameStartedReorderedLast: PostGameStartedReorderedLast,
-  ) {
-    super();
-
-    this.callbacksUsed = [
-      // 3
-      [
-        ModCallback.POST_USE_ITEM,
-        this.postUseItemGlowingHourGlass,
-        [CollectibleType.GLOWING_HOUR_GLASS],
-      ],
-
-      // 9
-      [ModCallback.POST_PLAYER_INIT, this.postPlayerInit],
-
-      // 15
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      [ModCallback.POST_GAME_STARTED, this.postGameStarted],
-
-      // 17
-      [ModCallback.PRE_GAME_EXIT, this.preGameExit],
-
-      // 18
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      [ModCallback.POST_NEW_LEVEL, this.postNewLevel],
-
-      // 19
-      // eslint-disable-next-line @typescript-eslint/no-deprecated
-      [ModCallback.POST_NEW_ROOM, this.postNewRoom],
-    ];
-
-    this.postGameStartedReordered = postGameStartedReordered;
-    this.postNewLevelReordered = postNewLevelReordered;
-    this.postNewRoomReordered = postNewRoomReordered;
-    this.postGameStartedReorderedLast = postGameStartedReorderedLast;
-  }
-
   // ModCallback.POST_USE_ITEM (3)
   // CollectibleType.GLOWING_HOUR_GLASS (422)
   private readonly postUseItemGlowingHourGlass = (): boolean | undefined => {
@@ -122,18 +80,18 @@ export class GameReorderedCallbacks extends Feature {
 
   // ModCallback.POST_NEW_LEVEL (18)
   private readonly postNewLevel = (): void => {
-    const level = game.GetLevel();
-    const stage = level.GetStage();
-    const stageType = level.GetStageType();
-    const room = game.GetRoom();
-    const roomType = room.GetType();
-
     if (onGameFrame(0) && !this.forceNewLevel) {
       // Wait for the `POST_GAME_STARTED` callback to fire.
       return;
     }
     this.forceNewLevel = false;
 
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+
     this.recordCurrentStage();
     this.postNewLevelReordered.fire(stage, stageType);
     this.postNewRoomReordered.fire(roomType);
@@ -175,6 +133,48 @@ export class GameReorderedCallbacks extends Feature {
     this.postNewRoomReordered.fire(roomType);
   };
 
+  /** @internal */
+  constructor(
+    postGameStartedReordered: PostGameStartedReordered,
+    postNewLevelReordered: PostNewLevelReordered,
+    postNewRoomReordered: PostNewRoomReordered,
+    postGameStartedReorderedLast: PostGameStartedReorderedLast,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      // 3
+      [
+        ModCallback.POST_USE_ITEM,
+        this.postUseItemGlowingHourGlass,
+        [CollectibleType.GLOWING_HOUR_GLASS],
+      ],
+
+      // 9
+      [ModCallback.POST_PLAYER_INIT, this.postPlayerInit],
+
+      // 15
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      [ModCallback.POST_GAME_STARTED, this.postGameStarted],
+
+      // 17
+      [ModCallback.PRE_GAME_EXIT, this.preGameExit],
+
+      // 18
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      [ModCallback.POST_NEW_LEVEL, this.postNewLevel],
+
+      // 19
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      [ModCallback.POST_NEW_ROOM, this.postNewRoom],
+    ];
+
+    this.postGameStartedReordered = postGameStartedReordered;
+    this.postNewLevelReordered = postNewLevelReordered;
+    this.postNewRoomReordered = postNewRoomReordered;
+    this.postGameStartedReorderedLast = postGameStartedReorderedLast;
+  }
+
   private recordCurrentStage(): void {
     const level = game.GetLevel();
     const stage = level.GetStage();

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

@@ -19,29 +19,10 @@ const v = {
 };
 
 export class GridEntityCollisionDetection extends Feature {
-  public override v = v;
-
   private readonly postGridEntityCollision: PostGridEntityCollision;
   private readonly postGridEntityCustomCollision: PostGridEntityCustomCollision;
   private readonly customGridEntities: CustomGridEntities;
 
-  constructor(
-    postGridEntityCollision: PostGridEntityCollision,
-    postGridEntityCustomCollision: PostGridEntityCustomCollision,
-    customGridEntities: CustomGridEntities,
-  ) {
-    super();
-
-    this.callbacksUsed = [
-      // 1
-      [ModCallback.POST_UPDATE, this.postUpdate],
-    ];
-
-    this.postGridEntityCollision = postGridEntityCollision;
-    this.postGridEntityCustomCollision = postGridEntityCustomCollision;
-    this.customGridEntities = customGridEntities;
-  }
-
   // ModCallback.POST_UPDATE (1)
   private readonly postUpdate = (): void => {
     const gridEntities = getGridEntities();
@@ -86,4 +67,23 @@ export class GridEntityCollisionDetection extends Feature {
       }
     }
   };
+
+  public override v = v;
+
+  constructor(
+    postGridEntityCollision: PostGridEntityCollision,
+    postGridEntityCustomCollision: PostGridEntityCustomCollision,
+    customGridEntities: CustomGridEntities,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      // 1
+      [ModCallback.POST_UPDATE, this.postUpdate],
+    ];
+
+    this.postGridEntityCollision = postGridEntityCollision;
+    this.postGridEntityCustomCollision = postGridEntityCustomCollision;
+    this.customGridEntities = customGridEntities;
+  }
 }

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

@@ -10,6 +10,20 @@ export class GridEntityRenderDetection extends Feature {
   private readonly postGridEntityCustomRender: PostGridEntityCustomRender;
   private readonly customGridEntities: CustomGridEntities;
 
+  // ModCallback.POST_RENDER (2)
+  private readonly postRender = () => {
+    for (const gridEntity of getGridEntities()) {
+      const gridIndex = gridEntity.GetGridIndex();
+      const gridEntityTypeCustom =
+        this.customGridEntities.getCustomGridEntityType(gridIndex);
+      if (gridEntityTypeCustom === undefined) {
+        this.postGridEntityRender.fire(gridEntity);
+      } else {
+        this.postGridEntityCustomRender.fire(gridEntity, gridEntityTypeCustom);
+      }
+    }
+  };
+
   constructor(
     postGridEntityRender: PostGridEntityRender,
     postGridEntityCustomRender: PostGridEntityCustomRender,
@@ -26,18 +40,4 @@ export class GridEntityRenderDetection extends Feature {
     this.postGridEntityCustomRender = postGridEntityCustomRender;
     this.customGridEntities = customGridEntities;
   }
-
-  // ModCallback.POST_RENDER (2)
-  private readonly postRender = () => {
-    for (const gridEntity of getGridEntities()) {
-      const gridIndex = gridEntity.GetGridIndex();
-      const gridEntityTypeCustom =
-        this.customGridEntities.getCustomGridEntityType(gridIndex);
-      if (gridEntityTypeCustom === undefined) {
-        this.postGridEntityRender.fire(gridEntity);
-      } else {
-        this.postGridEntityCustomRender.fire(gridEntity, gridEntityTypeCustom);
-      }
-    }
-  };
 }

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

@@ -33,8 +33,6 @@ const v = {
 };
 
 export class GridEntityUpdateDetection extends Feature {
-  public override v = v;
-
   private readonly postGridEntityInit: PostGridEntityInit;
   private readonly postGridEntityCustomInit: PostGridEntityCustomInit;
   private readonly postGridEntityUpdate: PostGridEntityUpdate;
@@ -47,6 +45,39 @@ export class GridEntityUpdateDetection extends Feature {
   private readonly postGridEntityCustomBroken: PostGridEntityCustomBroken;
   private readonly customGridEntities: CustomGridEntities;
 
+  // ModCallback.POST_UPDATE (1)
+  private readonly postUpdate = (): void => {
+    const gridEntitiesMap = getGridEntitiesMap();
+
+    // We check for removed grid entities first so that grid entities that change type will count as
+    // being removed and fire the PostGridEntityRemoved callback.
+    this.checkGridEntitiesRemoved(gridEntitiesMap);
+
+    for (const [gridIndex, gridEntity] of gridEntitiesMap) {
+      this.checkGridEntityStateChanged(gridIndex, gridEntity);
+      this.checkNewGridEntity(gridIndex, gridEntity);
+
+      const gridEntityTypeCustom =
+        this.customGridEntities.getCustomGridEntityType(gridIndex);
+      if (gridEntityTypeCustom === undefined) {
+        this.postGridEntityUpdate.fire(gridEntity);
+      } else {
+        this.postGridEntityCustomUpdate.fire(gridEntity, gridEntityTypeCustom);
+      }
+    }
+  };
+
+  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+  private readonly postNewRoomReordered = (): void => {
+    const gridEntitiesMap = getGridEntitiesMap();
+
+    for (const [gridIndex, gridEntity] of gridEntitiesMap) {
+      this.checkNewGridEntity(gridIndex, gridEntity);
+    }
+  };
+
+  public override v = v;
+
   constructor(
     postGridEntityInit: PostGridEntityInit,
     postGridEntityCustomInit: PostGridEntityCustomInit,
@@ -86,28 +117,6 @@ export class GridEntityUpdateDetection extends Feature {
     this.customGridEntities = customGridEntities;
   }
 
-  // ModCallback.POST_UPDATE (1)
-  private readonly postUpdate = (): void => {
-    const gridEntitiesMap = getGridEntitiesMap();
-
-    // We check for removed grid entities first so that grid entities that change type will count as
-    // being removed and fire the PostGridEntityRemoved callback.
-    this.checkGridEntitiesRemoved(gridEntitiesMap);
-
-    for (const [gridIndex, gridEntity] of gridEntitiesMap) {
-      this.checkGridEntityStateChanged(gridIndex, gridEntity);
-      this.checkNewGridEntity(gridIndex, gridEntity);
-
-      const gridEntityTypeCustom =
-        this.customGridEntities.getCustomGridEntityType(gridIndex);
-      if (gridEntityTypeCustom === undefined) {
-        this.postGridEntityUpdate.fire(gridEntity);
-      } else {
-        this.postGridEntityCustomUpdate.fire(gridEntity, gridEntityTypeCustom);
-      }
-    }
-  };
-
   private checkGridEntitiesRemoved(
     gridEntitiesMap: ReadonlyMap<int, GridEntity>,
   ): void {
@@ -208,13 +217,4 @@ export class GridEntityUpdateDetection extends Feature {
     ];
     v.room.initializedGridEntities.set(gridIndex, newTuple);
   }
-
-  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
-  private readonly postNewRoomReordered = (): void => {
-    const gridEntitiesMap = getGridEntitiesMap();
-
-    for (const [gridIndex, gridEntity] of gridEntitiesMap) {
-      this.checkNewGridEntity(gridIndex, gridEntity);
-    }
-  };
 }

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

@@ -27,25 +27,9 @@ const v = {
 };
 
 export class ItemPickupDetection extends Feature {
-  public override v = v;
-
   private readonly postItemPickup: PostItemPickup;
   private readonly preItemPickup: PreItemPickup;
 
-  constructor(postItemPickup: PostItemPickup, preItemPickup: PreItemPickup) {
-    super();
-
-    this.customCallbacksUsed = [
-      [
-        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-        this.postPEffectUpdateReordered,
-      ],
-    ];
-
-    this.postItemPickup = postItemPickup;
-    this.preItemPickup = preItemPickup;
-  }
-
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private readonly postPEffectUpdateReordered = (player: EntityPlayer) => {
     const pickingUpItem = defaultMapGetPlayer(
@@ -64,6 +48,22 @@ export class ItemPickupDetection extends Feature {
     }
   };
 
+  public override v = v;
+
+  constructor(postItemPickup: PostItemPickup, preItemPickup: PreItemPickup) {
+    super();
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+        this.postPEffectUpdateReordered,
+      ],
+    ];
+
+    this.postItemPickup = postItemPickup;
+    this.preItemPickup = preItemPickup;
+  }
+
   private queueEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
     if (
       pickingUpItem.itemType === ItemType.NULL

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

@@ -14,28 +14,9 @@ const v = {
 };
 
 export class PickupChangeDetection extends Feature {
-  public override v = v;
-
   private readonly postPickupChanged: PostPickupChanged;
   private readonly pickupIndexCreation: PickupIndexCreation;
 
-  constructor(
-    postPickupChanged: PostPickupChanged,
-    pickupIndexCreation: PickupIndexCreation,
-  ) {
-    super();
-
-    this.featuresUsed = [ISCFeature.PICKUP_INDEX_CREATION];
-
-    this.callbacksUsed = [
-      // 35
-      [ModCallback.POST_PICKUP_UPDATE, this.postPickupUpdate],
-    ];
-
-    this.postPickupChanged = postPickupChanged;
-    this.pickupIndexCreation = pickupIndexCreation;
-  }
-
   // ModCallback.POST_PICKUP_UPDATE (35)
   private readonly postPickupUpdate = (pickup: EntityPickup) => {
     const pickupIndex = this.pickupIndexCreation.getPickupIndex(pickup);
@@ -61,4 +42,23 @@ export class PickupChangeDetection extends Feature {
       );
     }
   };
+
+  public override v = v;
+
+  constructor(
+    postPickupChanged: PostPickupChanged,
+    pickupIndexCreation: PickupIndexCreation,
+  ) {
+    super();
+
+    this.featuresUsed = [ISCFeature.PICKUP_INDEX_CREATION];
+
+    this.callbacksUsed = [
+      // 35
+      [ModCallback.POST_PICKUP_UPDATE, this.postPickupUpdate],
+    ];
+
+    this.postPickupChanged = postPickupChanged;
+    this.pickupIndexCreation = pickupIndexCreation;
+  }
 }

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

@@ -42,98 +42,11 @@ const v = {
 };
 
 export class PlayerCollectibleDetection extends Feature {
-  public override v = v;
-
   private readonly postPlayerCollectibleAdded: PostPlayerCollectibleAdded;
   private readonly postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved;
   private readonly moddedElementSets: ModdedElementSets;
   private readonly runInNFrames: RunInNFrames;
 
-  constructor(
-    postPlayerCollectibleAdded: PostPlayerCollectibleAdded,
-    postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved,
-    moddedElementSets: ModdedElementSets,
-    runInNFrames: RunInNFrames,
-  ) {
-    super();
-
-    this.featuresUsed = [
-      ISCFeature.MODDED_ELEMENT_SETS,
-      ISCFeature.RUN_IN_N_FRAMES,
-    ];
-
-    this.callbacksUsed = [
-      // 3
-      [ModCallback.POST_USE_ITEM, this.postUseItemD4, [CollectibleType.D4]],
-    ];
-
-    this.customCallbacksUsed = [
-      [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
-      [ModCallbackCustom.POST_ITEM_PICKUP, this.postItemPickup],
-      [
-        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-        this.postPEffectUpdateReordered,
-      ],
-    ];
-
-    this.postPlayerCollectibleAdded = postPlayerCollectibleAdded;
-    this.postPlayerCollectibleRemoved = postPlayerCollectibleRemoved;
-    this.moddedElementSets = moddedElementSets;
-    this.runInNFrames = runInNFrames;
-  }
-
-  /**
-   * This is called when the collectible count changes and in situations where the entire build is
-   * rerolled.
-   *
-   * Since getting a new player collectible map is expensive, we want to only run this function when
-   * necessary, and not on e.g. every frame. Unfortunately, this has the side effect of missing out
-   * on collectible changes from mods that add and remove a collectible on the same frame.
-   *
-   * @param player The player to update.
-   * @param numCollectiblesChanged Pass undefined for situations where the entire build was
-   *                               rerolled.
-   */
-  private updateCollectibleMapAndFire(
-    player: EntityPlayer,
-    numCollectiblesChanged: int | undefined,
-  ) {
-    const oldCollectibleMap = defaultMapGetPlayer(
-      v.run.playersCollectibleMap,
-      player,
-    );
-    const newCollectibleMap =
-      this.moddedElementSets.getPlayerCollectibleMap(player);
-    mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
-
-    const collectibleTypesSet = new Set<CollectibleType>([
-      ...oldCollectibleMap.keys(),
-      ...newCollectibleMap.keys(),
-    ]);
-
-    let numFired = 0;
-    for (const collectibleType of collectibleTypesSet) {
-      const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
-      const newNum = newCollectibleMap.get(collectibleType) ?? 0;
-      const difference = newNum - oldNum;
-      const increased = difference > 0;
-      const absoluteDifference = Math.abs(difference);
-
-      repeat(absoluteDifference, () => {
-        if (increased) {
-          this.postPlayerCollectibleAdded.fire(player, collectibleType);
-        } else {
-          this.postPlayerCollectibleRemoved.fire(player, collectibleType);
-        }
-        numFired++;
-      });
-
-      if (numFired === numCollectiblesChanged) {
-        return;
-      }
-    }
-  }
-
   // ModCallback.POST_USE_ITEM (3)
   // CollectibleType.D4 (284)
   private readonly postUseItemD4 = (
@@ -226,12 +139,99 @@ export class PlayerCollectibleDetection extends Feature {
     if (difference > 0) {
       this.updateCollectibleMapAndFire(player, difference);
     } else if (difference < 0) {
-      this.updateCollectibleMapAndFire(player, difference * -1);
+      this.updateCollectibleMapAndFire(player, -difference);
     } else if (difference === 0) {
       this.checkActiveItemsChanged(player);
     }
   };
 
+  public override v = v;
+
+  constructor(
+    postPlayerCollectibleAdded: PostPlayerCollectibleAdded,
+    postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved,
+    moddedElementSets: ModdedElementSets,
+    runInNFrames: RunInNFrames,
+  ) {
+    super();
+
+    this.featuresUsed = [
+      ISCFeature.MODDED_ELEMENT_SETS,
+      ISCFeature.RUN_IN_N_FRAMES,
+    ];
+
+    this.callbacksUsed = [
+      // 3
+      [ModCallback.POST_USE_ITEM, this.postUseItemD4, [CollectibleType.D4]],
+    ];
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
+      [ModCallbackCustom.POST_ITEM_PICKUP, this.postItemPickup],
+      [
+        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+        this.postPEffectUpdateReordered,
+      ],
+    ];
+
+    this.postPlayerCollectibleAdded = postPlayerCollectibleAdded;
+    this.postPlayerCollectibleRemoved = postPlayerCollectibleRemoved;
+    this.moddedElementSets = moddedElementSets;
+    this.runInNFrames = runInNFrames;
+  }
+
+  /**
+   * This is called when the collectible count changes and in situations where the entire build is
+   * rerolled.
+   *
+   * Since getting a new player collectible map is expensive, we want to only run this function when
+   * necessary, and not on e.g. every frame. Unfortunately, this has the side effect of missing out
+   * on collectible changes from mods that add and remove a collectible on the same frame.
+   *
+   * @param player The player to update.
+   * @param numCollectiblesChanged Pass undefined for situations where the entire build was
+   *                               rerolled.
+   */
+  private updateCollectibleMapAndFire(
+    player: EntityPlayer,
+    numCollectiblesChanged: int | undefined,
+  ) {
+    const oldCollectibleMap = defaultMapGetPlayer(
+      v.run.playersCollectibleMap,
+      player,
+    );
+    const newCollectibleMap =
+      this.moddedElementSets.getPlayerCollectibleMap(player);
+    mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
+
+    const collectibleTypesSet = new Set<CollectibleType>([
+      ...oldCollectibleMap.keys(),
+      ...newCollectibleMap.keys(),
+    ]);
+
+    let numFired = 0;
+    for (const collectibleType of collectibleTypesSet) {
+      const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
+      const newNum = newCollectibleMap.get(collectibleType) ?? 0;
+      const difference = newNum - oldNum;
+      const increased = difference > 0;
+      const absoluteDifference = Math.abs(difference);
+
+      repeat(absoluteDifference, () => {
+        if (increased) {
+          this.postPlayerCollectibleAdded.fire(player, collectibleType);
+        } else {
+          this.postPlayerCollectibleRemoved.fire(player, collectibleType);
+        }
+        numFired++;
+      });
+
+      if (numFired === numCollectiblesChanged) {
+        return;
+      }
+    }
+  }
+
   /**
    * Checking for collectible count will work to detect when a player swaps their active item for
    * another active item. This is because the collectible count will decrement by 1 when the item is