isaacscript-common 25.2.0 → 25.4.0

package/src/classes/callbacks/PostCursedTeleport.ts

@@ -18,19 +18,21 @@ import { shouldFirePlayer } from "../../shouldFire";
 import { PlayerIndex } from "../../types/PlayerIndex";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    playersDamageFrameMap: new Map<
+      PlayerIndex,
+      [lastDamageFrame: int, callbackFiredOnThisFrame: boolean]
+    >(),
+  },
+
+  level: {
+    numSacrifices: 0,
+  },
+};
+
 export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CURSED_TELEPORT> {
-  public override v = {
-    run: {
-      playersDamageFrameMap: new Map<
-        PlayerIndex,
-        [lastDamageFrame: int, callbackFiredOnThisFrame: boolean]
-      >(),
-    },
-
-    level: {
-      numSacrifices: 0,
-    },
-  };
+  public override v = v;
 
   protected override shouldFire = shouldFirePlayer;
 
@@ -59,10 +61,7 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     _renderOffset: Vector,
   ): void => {
     // Retrieve information about this player.
-    const trackingArray = mapGetPlayer(
-      this.v.run.playersDamageFrameMap,
-      player,
-    );
+    const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
     if (trackingArray === undefined) {
       return;
     }
@@ -79,7 +78,7 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
 
     const gameFrameCount = game.GetFrameCount();
     const newTrackingArray = [gameFrameCount, true];
-    mapSetPlayer(this.v.run.playersDamageFrameMap, player, newTrackingArray);
+    mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
 
     this.fire(player);
   };
@@ -104,7 +103,7 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
 
     if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
-      this.v.level.numSacrifices++;
+      v.level.numSacrifices++;
     }
   }
 
@@ -115,10 +114,7 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     const gameFrameCount = game.GetFrameCount();
 
     // Don't do anything if we already activated the callback on this frame.
-    const trackingArray = mapGetPlayer(
-      this.v.run.playersDamageFrameMap,
-      player,
-    );
+    const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
     if (trackingArray !== undefined) {
       const [lastDamageFrame, callbackFiredOnThisFrame] = trackingArray;
       if (lastDamageFrame === gameFrameCount && callbackFiredOnThisFrame) {
@@ -132,7 +128,7 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     }
 
     const newTrackingArray = [gameFrameCount, false];
-    mapSetPlayer(this.v.run.playersDamageFrameMap, player, newTrackingArray);
+    mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
   }
 
   private isPotentialNaturalTeleportFromSacrificeRoom(
@@ -147,7 +143,7 @@ export class PostCursedTeleport extends CustomCallback<ModCallbackCustom.POST_CU
     return (
       roomType === RoomType.SACRIFICE &&
       isSpikeDamage &&
-      (this.v.level.numSacrifices === 6 || this.v.level.numSacrifices >= 12)
+      (v.level.numSacrifices === 6 || v.level.numSacrifices >= 12)
     );
   }
 }

package/src/classes/callbacks/PostDiceRoomActivated.ts

@@ -14,12 +14,14 @@ import {
 
 type T = ModCallbackCustom.POST_DICE_ROOM_ACTIVATED;
 
+const v = {
+  room: {
+    diceRoomActivated: false,
+  },
+};
+
 export class PostDiceRoomActivated extends CustomCallback<T> {
-  public override v = {
-    room: {
-      diceRoomActivated: false,
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -50,7 +52,7 @@ export class PostDiceRoomActivated extends CustomCallback<T> {
   // ModCallback.POST_EFFECT_UPDATE (55)
   // EffectVariant.DICE_FLOOR (76)
   private postEffectUpdateDiceFloor = (effect: EntityEffect): void => {
-    if (this.v.room.diceRoomActivated) {
+    if (v.room.diceRoomActivated) {
       return;
     }
 
@@ -62,7 +64,7 @@ export class PostDiceRoomActivated extends CustomCallback<T> {
 
     const closestPlayer = getClosestPlayer(effect.Position);
     if (isCloseEnoughToTriggerDiceFloor(closestPlayer, effect)) {
-      this.v.room.diceRoomActivated = true;
+      v.room.diceRoomActivated = true;
       this.fire(closestPlayer, effect.SubType as DiceFloorSubType);
     }
   };

package/src/classes/callbacks/PostEffectInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireEffect } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostEffectInitLate extends CustomCallback<ModCallbackCustom.POST_EFFECT_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostEffectInitLate extends CustomCallback<ModCallbackCustom.POST_EF
   // ModCallback.POST_EFFECT_UPDATE (55)
   private postEffectUpdate = (effect: EntityEffect): void => {
     const index = GetPtrHash(effect);
-    if (!this.v.room.firedSet.has(index)) {
-      this.v.room.firedSet.add(index);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
       this.fire(effect);
     }
   };

package/src/classes/callbacks/PostEffectStateChanged.ts

@@ -4,12 +4,14 @@ import { shouldFireEffect } from "../../shouldFire";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+  },
+};
+
 export class PostEffectStateChanged extends CustomCallback<ModCallbackCustom.POST_EFFECT_STATE_CHANGED> {
-  public override v = {
-    run: {
-      stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -25,12 +27,12 @@ export class PostEffectStateChanged extends CustomCallback<ModCallbackCustom.POS
   // ModCallback.POST_EFFECT_UPDATE (55)
   private postEffectUpdate = (effect: EntityEffect): void => {
     const ptrHash = GetPtrHash(effect);
-    const previousState = this.v.run.stateMap.getAndSetDefault(
+    const previousState = v.run.stateMap.getAndSetDefault(
       ptrHash,
       effect.State,
     );
     const currentState = effect.State;
-    this.v.run.stateMap.set(ptrHash, currentState);
+    v.run.stateMap.set(ptrHash, currentState);
 
     if (previousState !== currentState) {
       this.fire(effect, previousState, currentState);

package/src/classes/callbacks/PostFamiliarInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireFamiliar } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostFamiliarInitLate extends CustomCallback<ModCallbackCustom.POST_FAMILIAR_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostFamiliarInitLate extends CustomCallback<ModCallbackCustom.POST_
   // ModCallback.POST_FAMILIAR_UPDATE (6)
   private postFamiliarUpdate = (familiar: EntityFamiliar): void => {
     const index = GetPtrHash(familiar);
-    if (!this.v.room.firedSet.has(index)) {
-      this.v.room.firedSet.add(index);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
       this.fire(familiar);
     }
   };

package/src/classes/callbacks/PostFamiliarStateChanged.ts

@@ -4,12 +4,14 @@ import { shouldFireFamiliar } from "../../shouldFire";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+  },
+};
+
 export class PostFamiliarStateChanged extends CustomCallback<ModCallbackCustom.POST_FAMILIAR_STATE_CHANGED> {
-  public override v = {
-    run: {
-      stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -25,12 +27,12 @@ export class PostFamiliarStateChanged extends CustomCallback<ModCallbackCustom.P
   // ModCallback.POST_FAMILIAR_UPDATE (6)
   private postFamiliarUpdate = (familiar: EntityFamiliar): void => {
     const ptrHash = GetPtrHash(familiar);
-    const previousState = this.v.run.stateMap.getAndSetDefault(
+    const previousState = v.run.stateMap.getAndSetDefault(
       ptrHash,
       familiar.State,
     );
     const currentState = familiar.State;
-    this.v.run.stateMap.set(ptrHash, currentState);
+    v.run.stateMap.set(ptrHash, currentState);
 
     if (previousState !== currentState) {
       this.fire(familiar, previousState, currentState);

package/src/classes/callbacks/PostGameStartedReordered.ts

@@ -1,5 +1,6 @@
 import { ISCFeature } from "../../enums/ISCFeature";
 import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireBoolean } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostGameStartedReordered extends CustomCallback<ModCallbackCustom.POST_GAME_STARTED_REORDERED> {
@@ -8,4 +9,6 @@ export class PostGameStartedReordered extends CustomCallback<ModCallbackCustom.P
 
     this.featuresUsed = [ISCFeature.GAME_REORDERED_CALLBACKS];
   }
+
+  protected override shouldFire = shouldFireBoolean;
 }

package/src/classes/callbacks/PostGameStartedReorderedLast.ts

@@ -1,5 +1,6 @@
 import { ISCFeature } from "../../enums/ISCFeature";
 import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireBoolean } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostGameStartedReorderedLast extends CustomCallback<ModCallbackCustom.POST_GAME_STARTED_REORDERED> {
@@ -8,4 +9,6 @@ export class PostGameStartedReorderedLast extends CustomCallback<ModCallbackCust
 
     this.featuresUsed = [ISCFeature.GAME_REORDERED_CALLBACKS];
   }
+
+  protected override shouldFire = shouldFireBoolean;
 }

package/src/classes/callbacks/PostGreedModeWave.ts

@@ -4,12 +4,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { isGreedMode } from "../../functions/run";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    currentGreedWave: 0,
+  },
+};
+
 export class PostGreedModeWave extends CustomCallback<ModCallbackCustom.POST_GREED_MODE_WAVE> {
-  public override v = {
-    run: {
-      currentGreedWave: 0,
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -28,8 +30,8 @@ export class PostGreedModeWave extends CustomCallback<ModCallbackCustom.POST_GRE
 
     const level = game.GetLevel();
     const newWave = level.GreedModeWave;
-    const oldWave = this.v.run.currentGreedWave;
-    this.v.run.currentGreedWave = newWave;
+    const oldWave = v.run.currentGreedWave;
+    v.run.currentGreedWave = newWave;
 
     if (newWave > oldWave) {
       this.fire(oldWave, newWave);

package/src/classes/callbacks/PostHolyMantleRemoved.ts

@@ -9,12 +9,14 @@ import { PlayerIndex } from "../../types/PlayerIndex";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    playersHolyMantleMap: new DefaultMap<PlayerIndex, int>(0),
+  },
+};
+
 export class PostHolyMantleRemoved extends CustomCallback<ModCallbackCustom.POST_HOLY_MANTLE_REMOVED> {
-  public override v = {
-    run: {
-      playersHolyMantleMap: new DefaultMap<PlayerIndex, int>(0),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -36,10 +38,10 @@ export class PostHolyMantleRemoved extends CustomCallback<ModCallbackCustom.POST
       CollectibleType.HOLY_MANTLE,
     );
     const oldNumHolyMantles = defaultMapGetPlayer(
-      this.v.run.playersHolyMantleMap,
+      v.run.playersHolyMantleMap,
       player,
     );
-    mapSetPlayer(this.v.run.playersHolyMantleMap, player, newNumHolyMantles);
+    mapSetPlayer(v.run.playersHolyMantleMap, player, newNumHolyMantles);
 
     if (newNumHolyMantles < oldNumHolyMantles) {
       this.fire(player, oldNumHolyMantles, newNumHolyMantles);

package/src/classes/callbacks/PostItemDischarge.ts

@@ -30,23 +30,24 @@ type T = ModCallbackCustom.POST_ITEM_DISCHARGE;
 type ActiveSlotToCollectibleTypeMap = Map<ActiveSlot, CollectibleType>;
 type ActiveSlotToChargeMap = Map<ActiveSlot, int>;
 
+const v = {
+  run: {
+    playersActiveItemMap: new DefaultMap<
+      PlayerIndex,
+      ActiveSlotToCollectibleTypeMap
+    >(() => new Map()),
+    playersActiveChargeMap: new DefaultMap<PlayerIndex, ActiveSlotToChargeMap>(
+      () => new Map(),
+    ),
+  },
+
+  room: {
+    playersBulbLastCollisionFrame: new Map<PlayerIndex, int>(),
+  },
+};
+
 export class PostItemDischarge extends CustomCallback<T> {
-  public override v = {
-    run: {
-      playersActiveItemMap: new DefaultMap<
-        PlayerIndex,
-        ActiveSlotToCollectibleTypeMap
-      >(() => new Map()),
-      playersActiveChargeMap: new DefaultMap<
-        PlayerIndex,
-        ActiveSlotToChargeMap
-      >(() => new Map()),
-    },
-
-    room: {
-      playersBulbLastCollisionFrame: new Map<PlayerIndex, int>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -122,23 +123,16 @@ export class PostItemDischarge extends CustomCallback<T> {
     }
 
     const gameFrameCount = game.GetFrameCount();
-    mapSetPlayer(
-      this.v.room.playersBulbLastCollisionFrame,
-      player,
-      gameFrameCount,
-    );
+    mapSetPlayer(v.room.playersBulbLastCollisionFrame, player, gameFrameCount);
   }
 
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private postPEffectUpdateReordered = (player: EntityPlayer) => {
     const activeItemMap = defaultMapGetPlayer(
-      this.v.run.playersActiveItemMap,
-      player,
-    );
-    const chargeMap = defaultMapGetPlayer(
-      this.v.run.playersActiveChargeMap,
+      v.run.playersActiveItemMap,
       player,
     );
+    const chargeMap = defaultMapGetPlayer(v.run.playersActiveChargeMap, player);
 
     for (const activeSlot of ACTIVE_SLOT_VALUES) {
       const currentActiveItem = player.GetActiveItem();
@@ -179,7 +173,7 @@ export class PostItemDischarge extends CustomCallback<T> {
   private playerRecentlyCollidedWithBulb(player: EntityPlayer) {
     const gameFrameCount = game.GetFrameCount();
     const bulbLastCollisionFrame = mapGetPlayer(
-      this.v.room.playersBulbLastCollisionFrame,
+      v.room.playersBulbLastCollisionFrame,
       player,
     );
     const collidedOnThisFrame = gameFrameCount === bulbLastCollisionFrame;

package/src/classes/callbacks/PostKeyboardChanged.ts

@@ -10,12 +10,14 @@ import {
 
 type T = ModCallbackCustom.POST_KEYBOARD_CHANGED;
 
+const v = {
+  run: {
+    pressedKeys: new Set<Keyboard>(),
+  },
+};
+
 export class PostKeyboardChanged extends CustomCallback<T> {
-  public override v = {
-    run: {
-      pressedKeys: new Set<Keyboard>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -40,20 +42,20 @@ export class PostKeyboardChanged extends CustomCallback<T> {
   };
 
   private postRender = () => {
-    for (const keyboard of this.v.run.pressedKeys) {
+    for (const keyboard of v.run.pressedKeys) {
       if (!isKeyboardPressed(keyboard)) {
-        this.v.run.pressedKeys.delete(keyboard);
+        v.run.pressedKeys.delete(keyboard);
         this.fire(keyboard, false);
       }
     }
 
     for (const keyboard of KEYBOARD_VALUES) {
-      if (this.v.run.pressedKeys.has(keyboard)) {
+      if (v.run.pressedKeys.has(keyboard)) {
         continue;
       }
 
       if (isKeyboardPressed(keyboard)) {
-        this.v.run.pressedKeys.add(keyboard);
+        v.run.pressedKeys.add(keyboard);
         this.fire(keyboard, true);
       }
     }

package/src/classes/callbacks/PostKnifeInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireKnife } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostKnifeInitLate extends CustomCallback<ModCallbackCustom.POST_KNIFE_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostKnifeInitLate extends CustomCallback<ModCallbackCustom.POST_KNI
   // ModCallback.POST_KNIFE_UPDATE (51)
   private postKnifeUpdate = (knife: EntityKnife): void => {
     const ptrHash = GetPtrHash(knife);
-    if (!this.v.room.firedSet.has(ptrHash)) {
-      this.v.room.firedSet.add(ptrHash);
+    if (!v.room.firedSet.has(ptrHash)) {
+      v.room.firedSet.add(ptrHash);
       this.fire(knife);
     }
   };

package/src/classes/callbacks/PostLaserInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireLaser } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostLaserInitLate extends CustomCallback<ModCallbackCustom.POST_LASER_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostLaserInitLate extends CustomCallback<ModCallbackCustom.POST_LAS
   // ModCallback.POST_LASER_UPDATE (48)
   private postLaserUpdate = (laser: EntityLaser) => {
     const index = GetPtrHash(laser);
-    if (!this.v.room.firedSet.has(index)) {
-      this.v.room.firedSet.add(index);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
       this.fire(laser);
     }
   };

package/src/classes/callbacks/PostNPCInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireNPC } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostNPCInitLate extends CustomCallback<ModCallbackCustom.POST_NPC_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostNPCInitLate extends CustomCallback<ModCallbackCustom.POST_NPC_I
   // ModCallback.POST_NPC_UPDATE (0)
   private postNPCUpdate = (npc: EntityNPC) => {
     const index = GetPtrHash(npc);
-    if (!this.v.room.firedSet.has(index)) {
-      this.v.room.firedSet.add(index);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
       this.fire(npc);
     }
   };

package/src/classes/callbacks/PostNPCStateChanged.ts

@@ -4,14 +4,16 @@ import { shouldFireNPC } from "../../shouldFire";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    stateMap: new DefaultMap<PtrHash, NpcState, [NpcState]>(
+      (state) => state, // eslint-disable-line isaacscript/strict-enums
+    ),
+  },
+};
+
 export class PostNPCStateChanged extends CustomCallback<ModCallbackCustom.POST_NPC_STATE_CHANGED> {
-  public override v = {
-    run: {
-      stateMap: new DefaultMap<PtrHash, NpcState, [NpcState]>(
-        (state) => state, // eslint-disable-line isaacscript/strict-enums
-      ),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -27,12 +29,9 @@ export class PostNPCStateChanged extends CustomCallback<ModCallbackCustom.POST_N
   // ModCallback.POST_NPC_UPDATE (0)
   private postNPCUpdate = (npc: EntityNPC) => {
     const ptrHash = GetPtrHash(npc);
-    const previousState = this.v.run.stateMap.getAndSetDefault(
-      ptrHash,
-      npc.State,
-    );
+    const previousState = v.run.stateMap.getAndSetDefault(ptrHash, npc.State);
     const currentState = npc.State;
-    this.v.run.stateMap.set(ptrHash, currentState);
+    v.run.stateMap.set(ptrHash, currentState);
 
     if (previousState !== currentState) {
       this.fire(npc, previousState, currentState);

package/src/classes/callbacks/PostPickupCollect.ts

@@ -4,12 +4,14 @@ import { getClosestPlayer } from "../../functions/players";
 import { shouldFirePickup } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostPickupCollect extends CustomCallback<ModCallbackCustom.POST_PICKUP_COLLECT> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -31,8 +33,8 @@ export class PostPickupCollect extends CustomCallback<ModCallbackCustom.POST_PIC
     }
 
     const index = GetPtrHash(pickup);
-    if (!this.v.room.firedSet.has(index)) {
-      this.v.room.firedSet.add(index);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
 
       const player = getClosestPlayer(pickup.Position);
       this.fire(pickup, player);

package/src/classes/callbacks/PostPickupInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFirePickup } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostPickupInitLate extends CustomCallback<ModCallbackCustom.POST_PICKUP_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostPickupInitLate extends CustomCallback<ModCallbackCustom.POST_PI
   // ModCallback.POST_PICKUP_UPDATE (35)
   private postPickupUpdate = (pickup: EntityPickup) => {
     const index = GetPtrHash(pickup);
-    if (!this.v.room.firedSet.has(index)) {
-      this.v.room.firedSet.add(index);
+    if (!v.room.firedSet.has(index)) {
+      v.room.firedSet.add(index);
       this.fire(pickup);
     }
   };