isaacscript-common 29.5.0 → 29.5.2

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

@@ -1,29 +1,41 @@
 import {
   CardType,
   CollectibleType,
+  DiceFloorSubType,
   ModCallback,
   PickupVariant,
 } from "isaac-typescript-definitions";
 import { game } from "../../../core/cachedClasses";
 import { Exported } from "../../../decorators";
+import { ISCFeature } from "../../../enums/ISCFeature";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
 import { setCollectibleSubType } from "../../../functions/collectibles";
 import { getEntityID } from "../../../functions/entities";
+import { getCollectibles } from "../../../functions/pickupsSpecific";
 import { isCollectible } from "../../../functions/pickupVariants";
+import { asCollectibleType } from "../../../functions/types";
+import { PickupIndex } from "../../../types/PickupIndex";
+import { ReadonlySet } from "../../../types/ReadonlySet";
 import { Feature } from "../../private/Feature";
+import { PickupIndexCreation } from "./PickupIndexCreation";
+
+const ROLL_COLLECTIBLE_TYPES = new ReadonlySet([
+  // The `PRE_USE_ITEM` D6 callback is fired for D6, D100, Dice Shard, 4-pip Dice Room, and 6-pip
+  // Dice Room.
+  CollectibleType.D6, // 105
+  CollectibleType.ETERNAL_D6, // 609
+  CollectibleType.SPINDOWN_DICE, // 723
+]);
+
+const ROLL_FLOOR_DICE_FLOOR_SUB_TYPES = new ReadonlySet([
+  DiceFloorSubType.FOUR_PIP,
+  DiceFloorSubType.SIX_PIP,
+]);
 
 const v = {
-  room: {
-    /**
-     * Index is a string containing the grid index and the InitSeed of the collectible.
-     * (e.g. "12,1123579202")
-     *
-     * (We cannot simply use the InitSeed of the collectible because Diplopia can cause multiple
-     * collectibles in the room to have the same InitSeed. However, no two collectibles should ever
-     * be on the same grid index.)
-     *
-     * (We cannot use PtrHash as an index because that stays the same when the item is rolled.)
-     */
-    trackedCollectibles: new Map<string, CollectibleType>(),
+  run: {
+    trackedCollectibles: new Map<PickupIndex, CollectibleType>(),
+    rollGameFrame: null as int | null,
   },
 };
 
@@ -31,59 +43,106 @@ export class PreventCollectibleRotation extends Feature {
   /** @internal */
   public override v = v;
 
+  private pickupIndexCreation: PickupIndexCreation;
+
   /** @internal */
-  constructor() {
+  constructor(pickupIndexCreation: PickupIndexCreation) {
     super();
 
+    this.featuresUsed = [ISCFeature.PICKUP_INDEX_CREATION];
+
     this.callbacksUsed = [
       // 5
       [
         ModCallback.POST_USE_CARD,
-        this.useCardSoulOfIsaac,
+        this.postUseCardSoulOfIsaac,
         [CardType.SOUL_ISAAC],
       ],
 
-      // 35
-      [
-        ModCallback.POST_PICKUP_UPDATE,
-        this.postPickupUpdateCollectible,
-        [PickupVariant.COLLECTIBLE],
-      ],
+      // 23, 105
+      [ModCallback.PRE_USE_ITEM, this.preUseItem],
+    ];
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom.POST_DICE_ROOM_ACTIVATED, this.postDiceRoomActivated],
+      [ModCallbackCustom.POST_PICKUP_CHANGED, this.postPickupChanged],
     ];
+
+    this.pickupIndexCreation = pickupIndexCreation;
   }
 
+  private preUseItem = (
+    collectibleType: CollectibleType,
+  ): boolean | undefined => {
+    if (ROLL_COLLECTIBLE_TYPES.has(collectibleType)) {
+      markRollFrame();
+    }
+
+    return undefined;
+  };
+
+  /**
+   * Soul of Isaac causes items to flip. We assume that the player deliberately wants to roll a
+   * quest item, so we delete all tracked items in the current room.
+   */
   // ModCallback.POST_USE_CARD (5)
   // Card.SOUL_ISAAC (81)
-  private useCardSoulOfIsaac = () => {
-    // Soul of Isaac causes items to flip. Delete all tracked items (assuming that the player
-    // deliberately wants to roll a quest item).
-    v.room.trackedCollectibles.clear();
+  private postUseCardSoulOfIsaac = () => {
+    const collectibles = getCollectibles();
+    for (const collectible of collectibles) {
+      const pickupIndex = this.pickupIndexCreation.getPickupIndex(collectible);
+      v.run.trackedCollectibles.delete(pickupIndex);
+    }
   };
 
-  // ModCallback.POST_PICKUP_UPDATE (35)
-  // PickupVariant.COLLECTIBLE (100)
-  private postPickupUpdateCollectible = (pickup: EntityPickup) => {
-    const collectible = pickup as EntityPickupCollectible;
-
-    this.checkCollectibleRotated(collectible);
+  // ModCallbackCustom.POST_DICE_ROOM_ACTIVATED
+  private postDiceRoomActivated = (
+    _player: EntityPlayer,
+    diceFloorSubType: DiceFloorSubType,
+  ) => {
+    if (ROLL_FLOOR_DICE_FLOOR_SUB_TYPES.has(diceFloorSubType)) {
+      v.run.trackedCollectibles.clear();
+    }
   };
 
-  private checkCollectibleRotated(collectible: EntityPickupCollectible) {
-    // Ignore empty pedestals (i.e. items that have already been taken by the player).
-    if (collectible.SubType === CollectibleType.NULL) {
+  // ModCallbackCustom.POST_PICKUP_CHANGED
+  private postPickupChanged = (
+    pickup: EntityPickup,
+    oldVariant: PickupVariant,
+    _oldSubType: int,
+    newVariant: PickupVariant,
+    newSubType: int,
+  ) => {
+    // We only care about collectibles rotating.
+    if (
+      oldVariant !== PickupVariant.COLLECTIBLE ||
+      newVariant !== PickupVariant.COLLECTIBLE
+    ) {
       return;
     }
 
-    const index = getMapIndex(collectible);
-    const trackedCollectibleType = v.room.trackedCollectibles.get(index);
-    if (
-      trackedCollectibleType !== undefined &&
-      collectible.SubType !== trackedCollectibleType
-    ) {
-      // This item has switched, so restore it back to the way it was.
-      setCollectibleSubType(collectible, trackedCollectibleType);
+    // Ignore empty pedestals (i.e. collectibles that have already been taken by the player).
+    if (asCollectibleType(newSubType) === CollectibleType.NULL) {
+      return;
     }
-  }
+
+    const pickupIndex = this.pickupIndexCreation.getPickupIndex(pickup);
+    const trackedCollectibleType = v.run.trackedCollectibles.get(pickupIndex);
+    if (trackedCollectibleType === undefined) {
+      return;
+    }
+
+    const gameFrameCount = game.GetFrameCount();
+    if (gameFrameCount === v.run.rollGameFrame) {
+      v.run.trackedCollectibles.delete(pickupIndex);
+      return;
+    }
+
+    if (trackedCollectibleType !== asCollectibleType(newSubType)) {
+      // This collectible has rotated, so restore it back to the way it was.
+      setCollectibleSubType(pickup, trackedCollectibleType);
+    }
+  };
 
   /**
    * Helper function to prevent a collectible from being affected by Tainted Isaac's rotation
@@ -109,17 +168,17 @@ export class PreventCollectibleRotation extends Feature {
       );
     }
 
-    const index = getMapIndex(collectible);
-    v.room.trackedCollectibles.set(index, collectibleType);
+    const pickupIndex = this.pickupIndexCreation.getPickupIndex(collectible);
+    v.run.trackedCollectibles.set(pickupIndex, collectibleType);
 
     // The item might have already shifted on the first frame that it spawns, so change it back if
     // necessary.
-    this.checkCollectibleRotated(collectible);
+    if (collectible.SubType !== collectibleType) {
+      setCollectibleSubType(collectible, collectibleType);
+    }
   }
 }
 
-function getMapIndex(collectible: EntityPickup) {
-  const room = game.GetRoom();
-  const gridIndex = room.GetGridIndex(collectible.Position);
-  return `${gridIndex},${collectible.InitSeed}`;
+function markRollFrame() {
+  v.run.rollGameFrame = game.GetFrameCount();
 }

package/src/enums/ModCallbackCustom.ts

@@ -244,25 +244,6 @@ export enum ModCallbackCustom {
    */
   POST_COLLECTIBLE_EMPTY,
 
-  /**
-   * Fires from the `POST_PICKUP_INIT` callback on the first time that a player has seen the
-   * respective collectible on the run. For more details on how this is calculated, see the
-   * documentation for the `getCollectibleIndex` helper function.
-   *
-   * This callback is useful because collectibles will despawn upon leaving the room and respawn
-   * upon re-entering the room. Additionally, when playing as Tainted Isaac, the `POST_PICKUP_INIT`
-   * callback will fire every time the item shifts.
-   *
-   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
-   * - You can provide an optional third argument that will make the callback only fire if it
-   *   matches the `CollectibleType` provided.
-   *
-   * ```ts
-   * function postCollectibleInitLate(collectible: EntityPickupCollectible): void {}
-   * ```
-   */
-  POST_COLLECTIBLE_INIT_FIRST,
-
   /**
    * Fires from the `POST_PLAYER_RENDER` callback on the first frame that the "TeleportUp" animation
    * begins playing after a player triggers a Cursed Eye teleport or a Cursed Skull teleport. (Both

package/src/features.ts

@@ -141,7 +141,6 @@ export function getFeatures(
   const moddedElementDetection = new ModdedElementDetection();
   const ponyDetection = new PonyDetection();
   const pressInput = new PressInput();
-  const preventCollectibleRotation = new PreventCollectibleRotation();
   const roomClearFrame = new RoomClearFrame();
   const roomHistory = new RoomHistory();
   const runNextRoom = new RunNextRoom();
@@ -149,15 +148,18 @@ export function getFeatures(
   const stageHistory = new StageHistory();
 
   const runInNFrames = new RunInNFrames(roomHistory);
+  const pickupIndexCreation = new PickupIndexCreation(
+    roomHistory,
+    saveDataManager,
+  );
+  const preventCollectibleRotation = new PreventCollectibleRotation(
+    pickupIndexCreation,
+  );
 
   const customGridEntities = new CustomGridEntities(runInNFrames);
   const moddedElementSets = new ModdedElementSets(moddedElementDetection);
   const itemPoolDetection = new ItemPoolDetection(moddedElementSets);
   const pause = new Pause(disableInputs);
-  const pickupIndexCreation = new PickupIndexCreation(
-    roomHistory,
-    saveDataManager,
-  );
   const preventGridEntityRespawn = new PreventGridEntityRespawn(runInNFrames);
   const spawnCollectible = new SpawnCollectible(preventCollectibleRotation);
 

package/src/functions/collectibles.ts

@@ -11,7 +11,6 @@ import {
   PickupPrice,
   PickupVariant,
   RenderMode,
-  RoomType,
 } from "isaac-typescript-definitions";
 import { game, itemConfig } from "../core/cachedClasses";
 import { BLIND_ITEM_PNG_PATH, DEFAULT_ITEM_POOL_TYPE } from "../core/constants";
@@ -28,11 +27,9 @@ import {
   DEFAULT_COLLECTIBLE_NAME,
 } from "../maps/collectibleTypeToNameMap";
 import { SINGLE_USE_ACTIVE_COLLECTIBLE_TYPES_SET } from "../sets/singleUseActiveCollectibleTypesSet";
-import { CollectibleIndex } from "../types/CollectibleIndex";
 import { getEntityID } from "./entities";
 import { hasFlag } from "./flag";
 import { isCollectible } from "./pickupVariants";
-import { getRoomListIndex } from "./roomData";
 import { clearSprite, spriteEquals } from "./sprites";
 import { isNumber } from "./types";
 import { iRange } from "./utils";
@@ -251,82 +248,6 @@ export function getCollectibleGfxFilename(
   return itemConfigItem.GfxFileName;
 }
 
-/**
- * Mods may have to keep track of data relating to a collectible. Finding an index for these kinds
- * of data structures is difficult, since collectibles are respawned every time a player re-enters a
- * room (like all other pickups), so the `PtrHash` will change.
- *
- * Use this function to get a unique index for a collectible to use in these data structures.
- *
- * If your mod is upgraded, then you should use the `getPickupIndex` function instead, as it is more
- * general purpose and less prone to error (but relies on stateful tracking of pickups as the run
- * progresses).
- *
- * Collectibles are a special case of pickups: they cannot be pushed around. (They actually can be
- * pushed, but usually will stay on the same grid index.) Thus, it is possible to generate a
- * somewhat reliable non-stateful index for collectibles. We use a 4-tuple of the room list index,
- * the grid index of the collectible in the room, the collectible's `SubType`, and the collectible's
- * `InitSeed`.
- *
- * Collectibles that are shifted by Tainted Isaac's mechanic will have unique collectible indexes
- * because the `SubType` is different. (The collectible entities share the same `InitSeed` and
- * `PtrHash`.)
- *
- * Collectibles that are rolled (with e.g. a D6) will have unique collectible indexes because the
- * `SubType` and `InitSeed` are different. If you want to track collectibles independently of any
- * rerolls, then you can use the `PtrHash` as an index instead. (The `PtrHash` will not persist
- * between rooms, however.)
- *
- * Note that:
- * - The grid index is a necessary part of the collectible index because Diplopia and Crooked Penny
- *   can cause two or more collectibles with the same `SubType` and `InitSeed` to exist in the same
- *   room.
- * - This index will fail in the case where the player uses Diplopia or a successful Crooked Penny
- *   seven or more times in the same room, since that will cause two or more collectibles with the
- *   same grid index, `SubType`, and `InitSeed` to exist. (More than seven is required in non-1x1
- *   rooms.)
- * - The `SubType` is a necessary part of the collectible index because Tainted Isaac will
- *   continuously cause collectibles to morph into new sub-types with the same `InitSeed`.
- * - Using a collectible's position as part of the index is problematic, since players can push a
- *   pedestal. (Even using the grid index does not solve this problem, since it is possible in
- *   certain cases for collectibles to be spawned at a position that is not aligned with the grid,
- *   and the pedestal pushed to an adjacent tile, but this case should be extremely rare.)
- * - Mega Chests spawn two collectibles on the exact same position. However, both of them will have
- *   a different `InitSeed`, so this is not a problem for this indexing scheme.
- * - The indexing scheme used is different for collectibles that are inside of a Treasure Room or
- *   Boss Room, in order to handle the case of the player seeing the same collectible again in a
- *   post-Ascent Treasure Room or Boss Room. A 5-tuple of stage, stage type, grid index, `SubType`,
- *   and `InitSeed` is used in this case. (Using the room list index or the room grid index is not
- *   suitable for this purpose, since both of these values can change in the post-Ascent rooms.)
- *   Even though Treasure Rooms and Boss Rooms are grouped together in this scheme, there probably
- *   will not be collectibles with the same grid index, SubType, and InitSeed.
- */
-export function getCollectibleIndex(
-  collectible: EntityPickup,
-): CollectibleIndex {
-  if (!isCollectible(collectible)) {
-    const entityID = getEntityID(collectible);
-    error(
-      `The "getCollectibleIndex" function was given a non-collectible: ${entityID}`,
-    );
-  }
-
-  const level = game.GetLevel();
-  const stage = level.GetStage();
-  const stageType = level.GetStageType();
-  const room = game.GetRoom();
-  const roomType = room.GetType();
-  const gridIndex = room.GetGridIndex(collectible.Position);
-  const roomListIndex = getRoomListIndex();
-
-  // Handle the special case of being in a Treasure Room or Boss Room.
-  if (roomType === RoomType.TREASURE || roomType === RoomType.BOSS) {
-    return `${stage},${stageType},${gridIndex},${collectible.SubType},${collectible.InitSeed}` as CollectibleIndex;
-  }
-
-  return `${roomListIndex},${gridIndex},${collectible.SubType},${collectible.InitSeed}` as CollectibleIndex;
-}
-
 /**
  * Helper function to get the initial amount of charges that a collectible has. Returns 0 if the
  * provided collectible type was not valid.

package/src/functions/playerIndex.ts

@@ -79,9 +79,9 @@ export function getPlayerFromIndex(
  * (1). This works even if the player does not have any Sad Onions.
  *
  * Note that by default, this returns the same index for both The Forgotten and The Soul. (Even
- * though they are technically different characters, they share the same inventory and InitSeed.) If
- * this is not desired, pass true for the `differentiateForgottenAndSoul` argument, and the RNG of
- * Spoon Bender (3) will be used for The Soul.
+ * though they are technically different characters, they share the same inventory and `InitSeed`.)
+ * If this is not desired, pass true for the `differentiateForgottenAndSoul` argument, and the RNG
+ * of Spoon Bender (3) will be used for The Soul.
  *
  * Also note that this index does not work in the `POST_PLAYER_INIT` function for players 2 through
  * 4. With that said, in almost all cases, you should be lazy-initializing your data structures in

package/src/functions/utils.ts

@@ -176,6 +176,8 @@ export function repeat(n: int, func: (i: int) => void): void {
  * useful as a means to prevent unused variables.)
  *
  * This function does not actually do anything. (It is an "empty" function.)
+ *
+ * @allowEmptyVariadic
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function todo(...args: unknown[]): void {}

package/src/index.ts

@@ -151,7 +151,6 @@ export * from "./types/AnyClass";
 export * from "./types/AnyEntity";
 export * from "./types/AnyFunction";
 export * from "./types/AnyGridEntity";
-export * from "./types/CollectibleIndex";
 export * from "./types/ConversionHeartSubType";
 export * from "./types/Decrement";
 export * from "./types/EntityID";

package/src/interfaces/private/AddCallbackParametersCustom.ts

@@ -145,11 +145,6 @@ export interface AddCallbackParametersCustom {
     collectibleType?: CollectibleType,
   ];
 
-  [ModCallbackCustom.POST_COLLECTIBLE_INIT_FIRST]: [
-    callback: (collectible: EntityPickupCollectible) => void,
-    collectibleType?: CollectibleType,
-  ];
-
   [ModCallbackCustom.POST_CURSED_TELEPORT]: [
     callback: (player: EntityPlayer) => void,
     playerVariant?: PlayerVariant,

package/src/shouldFire.ts

@@ -84,19 +84,6 @@ export function shouldFireBoolean(
   return optionalArg === undefined || optionalArg === fireArg;
 }
 
-export function shouldFireCollectible(
-  fireArgs: [collectible: EntityPickupCollectible],
-  optionalArgs: [collectibleType?: CollectibleType],
-): boolean {
-  const [collectible] = fireArgs;
-  const [callbackCollectibleType] = optionalArgs;
-
-  return (
-    callbackCollectibleType === undefined ||
-    callbackCollectibleType === collectible.SubType
-  );
-}
-
 export function shouldFireCollectibleType(
   fireArgs: [player: EntityPlayer, collectibleType: CollectibleType],
   optionalArgs: [collectibleType?: CollectibleType],

package/dist/src/classes/callbacks/PostCollectibleInitFirst.d.ts

@@ -1,15 +0,0 @@
-import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
-import { shouldFireCollectible } from "../../shouldFire";
-import { CollectibleIndex } from "../../types/CollectibleIndex";
-import { CustomCallback } from "../private/CustomCallback";
-export declare class PostCollectibleInitFirst extends CustomCallback<ModCallbackCustom.POST_COLLECTIBLE_INIT_FIRST> {
-    v: {
-        run: {
-            seenCollectibles: Set<CollectibleIndex>;
-        };
-    };
-    constructor();
-    protected shouldFire: typeof shouldFireCollectible;
-    private postPickupInitCollectible;
-}
-//# sourceMappingURL=PostCollectibleInitFirst.d.ts.map

package/dist/src/classes/callbacks/PostCollectibleInitFirst.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostCollectibleInitFirst.d.ts","sourceRoot":"","sources":["../../../../src/classes/callbacks/PostCollectibleInitFirst.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAQ3D,qBAAa,wBAAyB,SAAQ,cAAc,CAAC,iBAAiB,CAAC,2BAA2B,CAAC;IACzF,CAAC;;;;MAAK;;IAetB,UAAmB,UAAU,+BAAyB;IAItD,OAAO,CAAC,yBAAyB,CAS/B;CACH"}

package/dist/src/classes/callbacks/PostCollectibleInitFirst.lua

@@ -1,36 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local Set = ____lualib.Set
-local __TS__New = ____lualib.__TS__New
-local __TS__Class = ____lualib.__TS__Class
-local __TS__ClassExtends = ____lualib.__TS__ClassExtends
-local ____exports = {}
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
-local PickupVariant = ____isaac_2Dtypescript_2Ddefinitions.PickupVariant
-local ____collectibles = require("src.functions.collectibles")
-local getCollectibleIndex = ____collectibles.getCollectibleIndex
-local ____shouldFire = require("src.shouldFire")
-local shouldFireCollectible = ____shouldFire.shouldFireCollectible
-local ____CustomCallback = require("src.classes.private.CustomCallback")
-local CustomCallback = ____CustomCallback.CustomCallback
-local v = {run = {seenCollectibles = __TS__New(Set)}}
-____exports.PostCollectibleInitFirst = __TS__Class()
-local PostCollectibleInitFirst = ____exports.PostCollectibleInitFirst
-PostCollectibleInitFirst.name = "PostCollectibleInitFirst"
-__TS__ClassExtends(PostCollectibleInitFirst, CustomCallback)
-function PostCollectibleInitFirst.prototype.____constructor(self)
-    CustomCallback.prototype.____constructor(self)
-    self.v = v
-    self.shouldFire = shouldFireCollectible
-    self.postPickupInitCollectible = function(____, pickup)
-        local collectible = pickup
-        local collectibleIndex = getCollectibleIndex(nil, collectible)
-        if v.run.seenCollectibles:has(collectibleIndex) then
-            return
-        end
-        v.run.seenCollectibles:add(collectibleIndex)
-        self:fire(collectible)
-    end
-    self.callbacksUsed = {{ModCallback.POST_PICKUP_INIT, self.postPickupInitCollectible, {PickupVariant.COLLECTIBLE}}}
-end
-return ____exports

package/dist/src/types/CollectibleIndex.d.ts

@@ -1,18 +0,0 @@
-/**
- * `CollectibleIndex` is a specific type of string that represents a unique identifier for a
- * collectible. Mods can signify that data structures handle collectibles by using this type.
- *
- * For more information, see the documentation for the `getCollectibleIndex` function.
- *
- * For example:
- *
- * ```ts
- * const collectiblesNameMap = new Map<CollectibleIndex, string>();
- * ```
- *
- * This type is branded for extra type safety.
- */
-export type CollectibleIndex = string & {
-    readonly __collectibleIndexBrand: symbol;
-};
-//# sourceMappingURL=CollectibleIndex.d.ts.map

package/dist/src/types/CollectibleIndex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CollectibleIndex.d.ts","sourceRoot":"","sources":["../../../src/types/CollectibleIndex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IACtC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;CAC1C,CAAC"}

package/dist/src/types/CollectibleIndex.lua

@@ -1,2 +0,0 @@
-local ____exports = {}
-return ____exports

package/src/classes/callbacks/PostCollectibleInitFirst.ts

@@ -1,44 +0,0 @@
-import { ModCallback, PickupVariant } from "isaac-typescript-definitions";
-import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
-import { getCollectibleIndex } from "../../functions/collectibles";
-import { shouldFireCollectible } from "../../shouldFire";
-import { CollectibleIndex } from "../../types/CollectibleIndex";
-import { CustomCallback } from "../private/CustomCallback";
-
-const v = {
-  run: {
-    seenCollectibles: new Set<CollectibleIndex>(),
-  },
-};
-
-export class PostCollectibleInitFirst extends CustomCallback<ModCallbackCustom.POST_COLLECTIBLE_INIT_FIRST> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 34
-      [
-        ModCallback.POST_PICKUP_INIT,
-        this.postPickupInitCollectible,
-        [PickupVariant.COLLECTIBLE],
-      ],
-    ];
-  }
-
-  protected override shouldFire = shouldFireCollectible;
-
-  // ModCallback.POST_PICKUP_INIT (34)
-  // PickupVariant.COLLECTIBLE (100)
-  private postPickupInitCollectible = (pickup: EntityPickup): void => {
-    const collectible = pickup as EntityPickupCollectible;
-    const collectibleIndex = getCollectibleIndex(collectible);
-    if (v.run.seenCollectibles.has(collectibleIndex)) {
-      return;
-    }
-
-    v.run.seenCollectibles.add(collectibleIndex);
-    this.fire(collectible);
-  };
-}

package/src/types/CollectibleIndex.ts

@@ -1,17 +0,0 @@
-/**
- * `CollectibleIndex` is a specific type of string that represents a unique identifier for a
- * collectible. Mods can signify that data structures handle collectibles by using this type.
- *
- * For more information, see the documentation for the `getCollectibleIndex` function.
- *
- * For example:
- *
- * ```ts
- * const collectiblesNameMap = new Map<CollectibleIndex, string>();
- * ```
- *
- * This type is branded for extra type safety.
- */
-export type CollectibleIndex = string & {
-  readonly __collectibleIndexBrand: symbol;
-};