isaacscript-common 14.1.2 → 14.2.0

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

@@ -8,7 +8,6 @@ import {
 } from "isaac-typescript-definitions";
 import { game } from "../../../core/cachedClasses";
 import { ISCFeature } from "../../../enums/ISCFeature";
-import { ModCallbackCustom2 } from "../../../enums/ModCallbackCustom2";
 import {
   removeGridEntity,
   spawnGridEntityWithVariant,
@@ -45,19 +44,47 @@ export class CustomGridEntities extends Feature {
     this.featuresUsed = [ISCFeature.RUN_IN_N_FRAMES];
 
     this.callbacksUsed = [
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
       [
         ModCallback.PRE_USE_ITEM,
         [this.preUseItemWeNeedToGoDeeper, CollectibleType.WE_NEED_TO_GO_DEEPER],
       ], // 23
     ];
 
-    this.customCallbacksUsed = [
-      [ModCallbackCustom2.POST_NEW_ROOM_REORDERED, [this.postNewRoomReordered]],
-    ];
-
     this.runInNFrames = runInNFrames;
   }
 
+  // ModCallback.POST_NEW_ROOM (19)
+  private postNewRoom = (): void => {
+    // When we re-enter a room, the graphics for any custom entities will be reverted back to that
+    // of a normal decoration. Thus, we must re-apply the anm2.
+    const roomListIndex = getRoomListIndex();
+    const roomCustomGridEntities =
+      this.v.level.customGridEntities.get(roomListIndex);
+    if (roomCustomGridEntities === undefined) {
+      return;
+    }
+
+    const room = game.GetRoom();
+    for (const [gridIndex, data] of roomCustomGridEntities.entries()) {
+      const decoration = room.GetGridEntity(gridIndex);
+      if (decoration === undefined) {
+        roomCustomGridEntities.delete(gridIndex);
+        continue;
+      }
+
+      if (data.anm2Path !== undefined) {
+        const sprite = decoration.GetSprite();
+        sprite.Load(data.anm2Path, true);
+        const animationToPlay =
+          data.defaultAnimation === undefined
+            ? sprite.GetDefaultAnimation()
+            : data.defaultAnimation;
+        sprite.Play(animationToPlay, true);
+      }
+    }
+  };
+
   // ModCallback.PRE_USE_ITEM (23)
   // CollectibleType.WE_NEED_TO_GO_DEEPER (84)
   private preUseItemWeNeedToGoDeeper = (
@@ -109,37 +136,6 @@ export class CustomGridEntities extends Feature {
     return true;
   };
 
-  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
-  private postNewRoomReordered = (): void => {
-    // When we re-enter a room, the graphics for any custom entities will be reverted back to that
-    // of a normal decoration. Thus, we must re-apply the anm2.
-    const roomListIndex = getRoomListIndex();
-    const roomCustomGridEntities =
-      this.v.level.customGridEntities.get(roomListIndex);
-    if (roomCustomGridEntities === undefined) {
-      return;
-    }
-
-    const room = game.GetRoom();
-    for (const [gridIndex, data] of roomCustomGridEntities.entries()) {
-      const decoration = room.GetGridEntity(gridIndex);
-      if (decoration === undefined) {
-        roomCustomGridEntities.delete(gridIndex);
-        continue;
-      }
-
-      if (data.anm2Path !== undefined) {
-        const sprite = decoration.GetSprite();
-        sprite.Load(data.anm2Path, true);
-        const animationToPlay =
-          data.defaultAnimation === undefined
-            ? sprite.GetDefaultAnimation()
-            : data.defaultAnimation;
-        sprite.Play(animationToPlay, true);
-      }
-    }
-  };
-
   /**
    * Helper function to spawn a custom grid entity. Custom grid entities are persistent in that they
    * will reappear if the player leaves and re-enters the room. (It will be manually respawned in

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

@@ -1,7 +1,3 @@
-// This provides the logic for the following callbacks:
-// - `PRE_CUSTOM_REVIVE`
-// - `POST_CUSTOM_REVIVE`
-
 import {
   CollectibleType,
   FamiliarVariant,
@@ -60,14 +56,11 @@ export class CustomRevive extends Feature {
 
     this.callbacksUsed = [
       [ModCallback.POST_RENDER, [this.postRender]], // 2
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
     ];
 
     this.customCallbacksUsed = [
-      [ModCallbackCustom2.POST_NEW_ROOM_REORDERED, [this.postNewRoomReordered]],
-      [
-        ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED,
-        [this.postPEffectUpdateReordered],
-      ],
       [
         ModCallbackCustom2.POST_PLAYER_FATAL_DAMAGE,
         [this.postPlayerFatalDamage],
@@ -90,18 +83,8 @@ export class CustomRevive extends Feature {
     sfxManager.Stop(SoundEffect.ONE_UP);
   };
 
-  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
-  private postNewRoomReordered = (): void => {
-    if (this.v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
-      return;
-    }
-
-    this.v.run.state = CustomReviveState.WAITING_FOR_ITEM_ANIMATION;
-    this.logStateChanged();
-  };
-
-  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-  private postPEffectUpdateReordered = (player: EntityPlayer): void => {
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffectUpdate = (player: EntityPlayer): void => {
     this.checkWaitingForItemAnimation(player);
   };
 
@@ -149,6 +132,16 @@ export class CustomRevive extends Feature {
     this.logStateChanged();
   }
 
+  // ModCallback.POST_NEW_ROOM (19)
+  private postNewRoom = (): void => {
+    if (this.v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
+      return;
+    }
+
+    this.v.run.state = CustomReviveState.WAITING_FOR_ITEM_ANIMATION;
+    this.logStateChanged();
+  };
+
   // ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE
   private postPlayerFatalDamage = (
     player: EntityPlayer,

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

@@ -1,7 +1,3 @@
-// This provides the logic for the following callbacks:
-// - `POST_ESAU_JR`
-// - `POST_FIRST_ESAU_JR`
-
 import {
   CollectibleType,
   ControllerIndex,

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

@@ -1,9 +1,3 @@
-// This provides the logic for the following callbacks:
-// - `POST_GAME_STARTED_REORDERED`
-// - `POST_GAME_STARTED_REORDERED_LAST`
-// - `POST_NEW_LEVEL_REORDERED`
-// - `POST_NEW_ROOM_REORDERED`
-
 // By default, callbacks fire in the following order:
 // - `POST_NEW_ROOM` --> `POST_NEW_LEVEL` --> `POST_GAME_STARTED`
 
@@ -139,17 +133,21 @@ export class GameReorderedCallbacks extends Feature {
     this.currentStageType = stageType;
   }
 
-  @Exported()
+  // --------------
+  // Public methods
+  // --------------
+
+  @Exported
   public forceNewLevelCallback(): void {
     this.forceNewLevel = true;
   }
 
-  @Exported()
+  @Exported
   public forceNewRoomCallback(): void {
     this.forceNewRoom = true;
   }
 
-  @Exported()
+  @Exported
   public reorderedCallbacksSetStage(
     stage: LevelStage,
     stageType: StageType,

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

@@ -1,7 +1,3 @@
-// This provides the logic for the following callbacks:
-// - `POST_GRID_ENTITY_COLLISION`
-// - `POST_GRID_ENTITY_CUSTOM_COLLISION`
-
 import { GridCollisionClass, ModCallback } from "isaac-typescript-definitions";
 import {
   getCollidingEntitiesWithGridEntity,

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

@@ -0,0 +1,42 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getGridEntities } from "../../../functions/gridEntities";
+import { PostGridEntityCustomRender } from "../../callbacks/PostGridEntityCustomRender";
+import { PostGridEntityRender } from "../../callbacks/PostGridEntityRender";
+import { Feature } from "../../private/Feature";
+import { CustomGridEntities } from "./CustomGridEntities";
+
+export class GridEntityRenderDetection extends Feature {
+  private postGridEntityRender: PostGridEntityRender;
+  private postGridEntityCustomRender: PostGridEntityCustomRender;
+  private customGridEntities: CustomGridEntities;
+
+  constructor(
+    postGridEntityRender: PostGridEntityRender,
+    postGridEntityCustomRender: PostGridEntityCustomRender,
+    customGridEntities: CustomGridEntities,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_RENDER, [this.postRender]], // 2
+    ];
+
+    this.postGridEntityRender = postGridEntityRender;
+    this.postGridEntityCustomRender = postGridEntityCustomRender;
+    this.customGridEntities = customGridEntities;
+  }
+
+  // ModCallback.POST_RENDER (2)
+  private 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/{GridEntityDetection.ts → GridEntityUpdateDetection.ts}

@@ -1,18 +1,5 @@
-// This provides the logic for the following callbacks:
-// - `POST_GRID_ENTITY_INIT`
-// - `POST_GRID_ENTITY_CUSTOM_INIT`
-// - `POST_GRID_ENTITY_UPDATE`
-// - `POST_GRID_ENTITY_CUSTOM_UPDATE`
-// - `POST_GRID_ENTITY_REMOVE`
-// - `POST_GRID_ENTITY_CUSTOM_REMOVE`
-// - `POST_GRID_ENTITY_STATE_CHANGED`
-// - `POST_GRID_ENTITY_CUSTOM_STATE_CHANGED`
-// - `POST_GRID_ENTITY_BROKEN`
-// - `POST_GRID_ENTITY_CUSTOM_BROKEN`
-
 import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
 import { ISCFeature } from "../../../enums/ISCFeature";
-import { ModCallbackCustom2 } from "../../../enums/ModCallbackCustom2";
 import {
   getGridEntitiesMap,
   isGridEntityBroken,
@@ -36,7 +23,7 @@ type GridEntityTuple = [
   state: int,
 ];
 
-export class GridEntityDetection extends Feature {
+export class GridEntityUpdateDetection extends Feature {
   public override v = {
     room: {
       /** Indexed by grid index. */
@@ -75,10 +62,7 @@ export class GridEntityDetection extends Feature {
 
     this.callbacksUsed = [
       [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
-    ];
-
-    this.customCallbacksUsed = [
-      [ModCallbackCustom2.POST_NEW_ROOM_REORDERED, [this.postNewRoomReordered]],
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
     ];
 
     this.postGridEntityInit = postGridEntityInit;
@@ -220,8 +204,8 @@ export class GridEntityDetection extends Feature {
     this.v.room.initializedGridEntities.set(gridIndex, newTuple);
   }
 
-  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
-  private postNewRoomReordered = (): void => {
+  // ModCallback.POST_NEW_ROOM (19)
+  private postNewRoom = (): void => {
     const gridEntitiesMap = getGridEntitiesMap();
 
     for (const [gridIndex, gridEntity] of gridEntitiesMap.entries()) {

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

@@ -0,0 +1,91 @@
+import {
+  CollectibleType,
+  ItemType,
+  ModCallback,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { defaultMapGetPlayer } from "../../../functions/playerDataStructures";
+import { asNumber } from "../../../functions/types";
+import {
+  newPickingUpItem,
+  PickingUpItem,
+  resetPickingUpItem,
+} from "../../../types/PickingUpItem";
+import { PlayerIndex } from "../../../types/PlayerIndex";
+import { PostItemPickup } from "../../callbacks/PostItemPickup";
+import { PreItemPickup } from "../../callbacks/PreItemPickup";
+import { DefaultMap } from "../../DefaultMap";
+import { Feature } from "../../private/Feature";
+
+export class ItemPickupDetection extends Feature {
+  public override v = {
+    run: {
+      playersPickingUpItemMap: new DefaultMap<PlayerIndex, PickingUpItem>(() =>
+        newPickingUpItem(),
+      ),
+    },
+  };
+
+  private postItemPickup: PostItemPickup;
+  private preItemPickup: PreItemPickup;
+
+  constructor(postItemPickup: PostItemPickup, preItemPickup: PreItemPickup) {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
+    ];
+
+    this.postItemPickup = postItemPickup;
+    this.preItemPickup = preItemPickup;
+  }
+
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffectUpdate = (player: EntityPlayer) => {
+    const pickingUpItem = defaultMapGetPlayer(
+      this.v.run.playersPickingUpItemMap,
+      player,
+    );
+
+    if (player.IsItemQueueEmpty()) {
+      this.queueEmpty(player, pickingUpItem);
+      // If a player enters a room with a trinket next to the entrance, the player will pick up the
+      // trinket, but it will not become queued (it will be deposited into their inventory
+      // immediately). Since we don't know what type of item the player is holding, don't account
+      // for this bug.
+    } else {
+      this.queueNotEmpty(player, pickingUpItem);
+    }
+  };
+
+  private queueEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
+    if (
+      pickingUpItem.itemType === ItemType.NULL ||
+      asNumber(pickingUpItem.subType) === 0
+    ) {
+      return;
+    }
+
+    this.postItemPickup.fire(player, pickingUpItem);
+    resetPickingUpItem(pickingUpItem);
+  }
+
+  private queueNotEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
+    const queuedItem = player.QueuedItem.Item;
+    if (queuedItem === undefined || queuedItem.Type === ItemType.NULL) {
+      // This should never happen, since the `EntityPlayer.IsItemQueueEmpty` method returned true.
+      return;
+    }
+
+    if (
+      queuedItem.Type !== pickingUpItem.itemType ||
+      queuedItem.ID !== pickingUpItem.subType
+    ) {
+      // Record which item we are picking up.
+      pickingUpItem.itemType = queuedItem.Type;
+      pickingUpItem.subType = queuedItem.ID as CollectibleType | TrinketType;
+
+      this.preItemPickup.fire(player, pickingUpItem);
+    }
+  }
+}

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

@@ -0,0 +1,245 @@
+import {
+  ActiveSlot,
+  CollectibleType,
+  DamageFlag,
+  EntityType,
+  ModCallback,
+  PlayerType,
+} from "isaac-typescript-definitions";
+import { arrayEquals } from "../../../functions/array";
+import { getEnumValues } from "../../../functions/enums";
+import { hasFlag } from "../../../functions/flag";
+import {
+  defaultMapGetPlayer,
+  mapSetPlayer,
+} from "../../../functions/playerDataStructures";
+import {
+  getPlayerCollectibleMap,
+  getPlayerFromPtr,
+} from "../../../functions/players";
+import { repeat } from "../../../functions/utils";
+import { PlayerIndex } from "../../../types/PlayerIndex";
+import { PostPlayerCollectibleAdded } from "../../callbacks/PostPlayerCollectibleAdded";
+import { PostPlayerCollectibleRemoved } from "../../callbacks/PostPlayerCollectibleRemoved";
+import { DefaultMap } from "../../DefaultMap";
+import { Feature } from "../../private/Feature";
+import { RunInNFrames } from "../other/RunInNFrames";
+
+export class PlayerCollectibleDetection extends Feature {
+  public override v = {
+    run: {
+      playersCollectibleCount: new DefaultMap<PlayerIndex, int>(0),
+      playersCollectibleMap: new DefaultMap<
+        PlayerIndex,
+        Map<CollectibleType, int>
+      >(() => new Map()),
+      playersActiveItemMap: new DefaultMap<
+        PlayerIndex,
+        Map<ActiveSlot, CollectibleType>
+      >(() => new Map()),
+    },
+  };
+
+  private postPlayerCollectibleAdded: PostPlayerCollectibleAdded;
+  private postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved;
+  private runInNFrames: RunInNFrames;
+
+  constructor(
+    postPlayerCollectibleAdded: PostPlayerCollectibleAdded,
+    postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved,
+    runInNFrames: RunInNFrames,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_USE_ITEM, [this.useItemD4, CollectibleType.D4]], // 3
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
+      [
+        ModCallback.ENTITY_TAKE_DMG,
+        [this.entityTakeDmgPlayer, EntityType.PLAYER],
+      ], // 11
+    ];
+
+    this.postPlayerCollectibleAdded = postPlayerCollectibleAdded;
+    this.postPlayerCollectibleRemoved = postPlayerCollectibleRemoved;
+    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(
+      this.v.run.playersCollectibleMap,
+      player,
+    );
+    const newCollectibleMap = getPlayerCollectibleMap(player);
+    mapSetPlayer(this.v.run.playersCollectibleMap, player, newCollectibleMap);
+
+    const collectibleTypesSet = new Set<CollectibleType>([
+      ...oldCollectibleMap.keys(),
+      ...newCollectibleMap.keys(),
+    ]);
+
+    let numFired = 0;
+    for (const collectibleType of collectibleTypesSet.values()) {
+      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 useItemD4 = (
+    _collectibleType: CollectibleType,
+    _rng: RNG,
+    player: EntityPlayer,
+  ): boolean | undefined => {
+    // This function is also triggered for:
+    // - D100
+    // - D Infinity copying D4 or D100
+    // - 1-pip dice room
+    // - 6-pip dice room
+    // - Reverse Wheel of Fortune copying 1-pip or 6-pip dice room
+    // - First getting Missing No.
+    // - Arriving on a new floor with Missing No.
+
+    // This function is not triggered for:
+    // - Tainted Eden getting hit (this is explicitly handled elsewhere)
+    // - Genesis (which is automatically handled by the collectibles being removed in the normal
+    //   `POST_PLAYER_COLLECTIBLE_REMOVED` callback)
+    this.updateCollectibleMapAndFire(player, undefined);
+
+    return undefined;
+  };
+
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffectUpdate = (player: EntityPlayer) => {
+    const oldCollectibleCount = defaultMapGetPlayer(
+      this.v.run.playersCollectibleCount,
+      player,
+    );
+    const newCollectibleCount = player.GetCollectibleCount();
+    mapSetPlayer(
+      this.v.run.playersCollectibleCount,
+      player,
+      newCollectibleCount,
+    );
+
+    const difference = newCollectibleCount - oldCollectibleCount;
+
+    if (difference > 0) {
+      this.updateCollectibleMapAndFire(player, difference);
+    } else if (difference < 0) {
+      this.updateCollectibleMapAndFire(player, difference * -1);
+    } else if (difference === 0) {
+      this.checkActiveItemsChanged(player);
+    }
+  };
+
+  /**
+   * 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
+   * swapped onto the pedestal and the hold animation begins, and increment by 1 when the item is
+   * dequeued and the hold animation ends.
+   *
+   * However, we also want to explicitly check for the case where a mod swaps in a custom active
+   * collectible on the same frame, since doing so is cheap.
+   */
+  private checkActiveItemsChanged(player: EntityPlayer) {
+    const activeItemMap = defaultMapGetPlayer(
+      this.v.run.playersActiveItemMap,
+      player,
+    );
+
+    const oldCollectibleTypes: CollectibleType[] = [];
+    const newCollectibleTypes: CollectibleType[] = [];
+
+    for (const activeSlot of getEnumValues(ActiveSlot)) {
+      const oldCollectibleType =
+        activeItemMap.get(activeSlot) ?? CollectibleType.NULL;
+      const newCollectibleType = player.GetActiveItem(activeSlot);
+      activeItemMap.set(activeSlot, newCollectibleType);
+
+      oldCollectibleTypes.push(oldCollectibleType);
+      newCollectibleTypes.push(newCollectibleType);
+    }
+
+    // For example, it is possible for the player to switch Schoolbag items, which will cause the
+    // collectibles in the array to be the same, but in a different order. Thus, we sort both arrays
+    // before comparing them.
+    oldCollectibleTypes.sort();
+    newCollectibleTypes.sort();
+
+    if (!arrayEquals(oldCollectibleTypes, newCollectibleTypes)) {
+      // One or more active items have changed (with the player's total collectible count remaining
+      // the same).
+      this.updateCollectibleMapAndFire(player, undefined);
+    }
+  }
+
+  // ModCallback.ENTITY_TAKE_DMG (11)
+  // EntityType.PLAYER (1)
+  // We need to handle the case of Tainted Eden taking damage.
+  private entityTakeDmgPlayer = (
+    entity: Entity,
+    _amount: float,
+    damageFlags: BitFlags<DamageFlag>,
+    _source: EntityRef,
+    _countdownFrames: int,
+  ): boolean | undefined => {
+    // Tainted Eden's mechanic does not apply if she e.g. uses Dull Razor.
+    if (hasFlag(damageFlags, DamageFlag.FAKE)) {
+      return undefined;
+    }
+
+    const player = entity.ToPlayer();
+    if (player === undefined) {
+      return undefined;
+    }
+
+    const character = player.GetPlayerType();
+    if (character !== PlayerType.EDEN_B) {
+      return undefined;
+    }
+
+    // The items will only be rerolled after the damage is successfully applied.
+    const entityPtr = EntityPtr(player);
+    this.runInNFrames.runNextGameFrame(() => {
+      const futurePlayer = getPlayerFromPtr(entityPtr);
+      if (futurePlayer !== undefined) {
+        this.updateCollectibleMapAndFire(player, undefined);
+      }
+    });
+
+    return undefined;
+  };
+}