isaacscript-common 25.3.0 → 25.4.0

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);
     }
   };

package/src/classes/callbacks/PostPickupStateChanged.ts

@@ -4,12 +4,14 @@ import { shouldFirePickup } from "../../shouldFire";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+  },
+};
+
 export class PostPickupStateChanged extends CustomCallback<ModCallbackCustom.POST_PICKUP_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 PostPickupStateChanged extends CustomCallback<ModCallbackCustom.POS
   // ModCallback.POST_PICKUP_UPDATE (35)
   private postPickupUpdate = (pickup: EntityPickup) => {
     const ptrHash = GetPtrHash(pickup);
-    const previousState = this.v.run.stateMap.getAndSetDefault(
+    const previousState = v.run.stateMap.getAndSetDefault(
       ptrHash,
       pickup.State,
     );
     const currentState = pickup.State;
-    this.v.run.stateMap.set(ptrHash, currentState);
+    v.run.stateMap.set(ptrHash, currentState);
 
     if (previousState !== currentState) {
       this.fire(pickup, previousState, currentState);

package/src/classes/callbacks/PostPlayerChangeHealth.ts

@@ -8,14 +8,16 @@ import { PlayerIndex } from "../../types/PlayerIndex";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    playersHealthMap: new DefaultMap<PlayerIndex, Map<HealthType, int>>(
+      () => new Map(),
+    ),
+  },
+};
+
 export class PostPlayerChangeHealth extends CustomCallback<ModCallbackCustom.POST_PLAYER_CHANGE_HEALTH> {
-  public override v = {
-    run: {
-      playersHealthMap: new DefaultMap<PlayerIndex, Map<HealthType, int>>(
-        () => new Map(),
-      ),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -37,7 +39,7 @@ export class PostPlayerChangeHealth extends CustomCallback<ModCallbackCustom.POS
     // the player switches between the two.
     const playerIndex = getPlayerIndex(player, true);
     const playerHealthMap =
-      this.v.run.playersHealthMap.getAndSetDefault(playerIndex);
+      v.run.playersHealthMap.getAndSetDefault(playerIndex);
 
     for (const healthType of HEALTH_TYPE_VALUES) {
       const storedHealthValue = playerHealthMap.get(healthType);

package/src/classes/callbacks/PostPlayerChangeStat.ts

@@ -13,15 +13,17 @@ import { PossibleStatType } from "../../types/PossibleStatType";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    playersStatMap: new DefaultMap<
+      PlayerIndex,
+      Map<StatType, PossibleStatType>
+    >(() => new Map()),
+  },
+};
+
 export class PostPlayerChangeStat extends CustomCallback<ModCallbackCustom.POST_PLAYER_CHANGE_STAT> {
-  public override v = {
-    run: {
-      playersStatMap: new DefaultMap<
-        PlayerIndex,
-        Map<StatType, PossibleStatType>
-      >(() => new Map()),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -42,8 +44,7 @@ export class PostPlayerChangeStat extends CustomCallback<ModCallbackCustom.POST_
     // we don't differentiate between The Forgotten and The Soul, the callback will fire every time
     // the player switches between the two.
     const playerIndex = getPlayerIndex(player, true);
-    const playerStatMap =
-      this.v.run.playersStatMap.getAndSetDefault(playerIndex);
+    const playerStatMap = v.run.playersStatMap.getAndSetDefault(playerIndex);
 
     for (const statType of STAT_TYPE_VALUES) {
       const storedStatValue = playerStatMap.get(statType);

package/src/classes/callbacks/PostPlayerChangeType.ts

@@ -9,16 +9,18 @@ import { PlayerIndex } from "../../types/PlayerIndex";
 import { DefaultMap } from "../DefaultMap";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    playersCharacterMap: new DefaultMap<
+      PlayerIndex,
+      PlayerType,
+      [character: PlayerType]
+    >((character: PlayerType) => character), // eslint-disable-line isaacscript/strict-enums
+  },
+};
+
 export class PostPlayerChangeType extends CustomCallback<ModCallbackCustom.POST_PLAYER_CHANGE_TYPE> {
-  public override v = {
-    run: {
-      playersCharacterMap: new DefaultMap<
-        PlayerIndex,
-        PlayerType,
-        [character: PlayerType]
-      >((character: PlayerType) => character), // eslint-disable-line isaacscript/strict-enums
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -37,12 +39,12 @@ export class PostPlayerChangeType extends CustomCallback<ModCallbackCustom.POST_
   private postPEffectReordered = (player: EntityPlayer) => {
     const character = player.GetPlayerType();
     const storedCharacter = defaultMapGetPlayer(
-      this.v.run.playersCharacterMap,
+      v.run.playersCharacterMap,
       player,
       character,
     );
     if (character !== storedCharacter) {
-      mapSetPlayer(this.v.run.playersCharacterMap, player, character);
+      mapSetPlayer(v.run.playersCharacterMap, player, character);
       this.fire(player, storedCharacter, character);
     }
   };

package/src/classes/callbacks/PostPlayerFatalDamage.ts

@@ -23,13 +23,15 @@ import { shouldFirePlayer } from "../../shouldFire";
 import { PlayerIndex } from "../../types/PlayerIndex";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    /** Needed to detect if Glass Cannon will kill the player or not. */
+    playersLastDamageGameFrame: new Map<PlayerIndex, int>(),
+  },
+};
+
 export class PostPlayerFatalDamage extends CustomCallback<ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE> {
-  public override v = {
-    run: {
-      /** Needed to detect if Glass Cannon will kill the player or not. */
-      playersLastDamageGameFrame: new Map<PlayerIndex, int>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -100,10 +102,10 @@ export class PostPlayerFatalDamage extends CustomCallback<ModCallbackCustom.POST
 
     const gameFrameCount = game.GetFrameCount();
     const lastDamageGameFrame = mapGetPlayer(
-      this.v.run.playersLastDamageGameFrame,
+      v.run.playersLastDamageGameFrame,
       player,
     );
-    mapSetPlayer(this.v.run.playersLastDamageGameFrame, player, gameFrameCount);
+    mapSetPlayer(v.run.playersLastDamageGameFrame, player, gameFrameCount);
 
     // If the player has a revival item such as Dead Cat, this will not be fatal damage.
     if (willPlayerRevive(player)) {

package/src/classes/callbacks/PostPlayerInitLate.ts

@@ -7,12 +7,14 @@ import { shouldFirePlayer } from "../../shouldFire";
 import { PlayerIndex } from "../../types/PlayerIndex";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  run: {
+    playersFiredSet: new Set<PlayerIndex>(),
+  },
+};
+
 export class PostPlayerInitLate extends CustomCallback<ModCallbackCustom.POST_PLAYER_INIT_LATE> {
-  public override v = {
-    run: {
-      playersFiredSet: new Set<PlayerIndex>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -29,8 +31,8 @@ export class PostPlayerInitLate extends CustomCallback<ModCallbackCustom.POST_PL
 
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private postPEffectUpdateReordered = (player: EntityPlayer) => {
-    if (!setHasPlayer(this.v.run.playersFiredSet, player)) {
-      setAddPlayer(this.v.run.playersFiredSet, player);
+    if (!setHasPlayer(v.run.playersFiredSet, player)) {
+      setAddPlayer(v.run.playersFiredSet, player);
       this.fire(player);
     }
   };

package/src/classes/callbacks/PostProjectileInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireProjectile } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostProjectileInitLate extends CustomCallback<ModCallbackCustom.POST_PROJECTILE_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostProjectileInitLate extends CustomCallback<ModCallbackCustom.POS
   // ModCallback.POST_PROJECTILE_UPDATE (44)
   private postProjectileUpdate = (projectile: EntityProjectile): void => {
     const ptrHash = GetPtrHash(projectile);
-    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(projectile);
     }
   };

package/src/classes/callbacks/PostPurchase.ts

@@ -14,14 +14,16 @@ import {
 
 type T = ModCallbackCustom.POST_PURCHASE;
 
+const v = {
+  room: {
+    playersHoldingItemOnLastFrameMap: new DefaultMap<PlayerIndex, boolean>(
+      false,
+    ),
+  },
+};
+
 export class PostPurchase extends CustomCallback<T> {
-  public override v = {
-    room: {
-      playersHoldingItemOnLastFrameMap: new DefaultMap<PlayerIndex, boolean>(
-        false,
-      ),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -53,11 +55,11 @@ export class PostPurchase extends CustomCallback<T> {
   private postPEffectUpdateReordered = (player: EntityPlayer) => {
     const isHoldingItem = player.IsHoldingItem();
     const wasHoldingItemOnLastFrame = defaultMapGetPlayer(
-      this.v.room.playersHoldingItemOnLastFrameMap,
+      v.room.playersHoldingItemOnLastFrameMap,
       player,
     );
     mapSetPlayer(
-      this.v.room.playersHoldingItemOnLastFrameMap,
+      v.room.playersHoldingItemOnLastFrameMap,
       player,
       isHoldingItem,
     );

package/src/classes/callbacks/PostRoomClearChanged.ts

@@ -9,12 +9,14 @@ import {
 
 type T = ModCallbackCustom.POST_ROOM_CLEAR_CHANGED;
 
+const v = {
+  room: {
+    cleared: false,
+  },
+};
+
 export class PostRoomClearChanged extends CustomCallback<T> {
-  public override v = {
-    room: {
-      cleared: false,
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -44,8 +46,8 @@ export class PostRoomClearChanged extends CustomCallback<T> {
     const room = game.GetRoom();
     const roomClear = room.IsClear();
 
-    if (roomClear !== this.v.room.cleared) {
-      this.v.room.cleared = roomClear;
+    if (roomClear !== v.room.cleared) {
+      v.room.cleared = roomClear;
       this.fire(roomClear);
     }
   };
@@ -55,6 +57,6 @@ export class PostRoomClearChanged extends CustomCallback<T> {
     const room = game.GetRoom();
     const roomClear = room.IsClear();
 
-    this.v.room.cleared = roomClear;
+    v.room.cleared = roomClear;
   };
 }

package/src/classes/callbacks/PostSacrifice.ts

@@ -5,12 +5,14 @@ import { hasFlag } from "../../functions/flag";
 import { shouldFirePlayer } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  level: {
+    numSacrifices: 0,
+  },
+};
+
 export class PostSacrifice extends CustomCallback<ModCallbackCustom.POST_SACRIFICE> {
-  public override v = {
-    level: {
-      numSacrifices: 0,
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -35,8 +37,8 @@ export class PostSacrifice extends CustomCallback<ModCallbackCustom.POST_SACRIFI
     const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
 
     if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
-      this.v.level.numSacrifices++;
-      this.fire(player, this.v.level.numSacrifices);
+      v.level.numSacrifices++;
+      this.fire(player, v.level.numSacrifices);
     }
 
     return undefined;

package/src/classes/callbacks/PostTearInitLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireTear } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostTearInitLate extends CustomCallback<ModCallbackCustom.POST_TEAR_INIT_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -24,8 +26,8 @@ export class PostTearInitLate extends CustomCallback<ModCallbackCustom.POST_TEAR
   // ModCallback.POST_TEAR_UPDATE (40)
   private postTearUpdate = (tear: EntityTear): void => {
     const ptrHash = GetPtrHash(tear);
-    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(tear);
     }
   };

package/src/classes/callbacks/PostTearInitVeryLate.ts

@@ -3,12 +3,14 @@ import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { shouldFireTear } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
 export class PostTearInitVeryLate extends CustomCallback<ModCallbackCustom.POST_TEAR_INIT_VERY_LATE> {
-  public override v = {
-    room: {
-      firedSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -29,8 +31,8 @@ export class PostTearInitVeryLate extends CustomCallback<ModCallbackCustom.POST_
     }
 
     const index = GetPtrHash(tear);
-    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(tear);
     }
   };

package/src/classes/callbacks/PostTransformation.ts

@@ -12,16 +12,18 @@ import {
 
 type T = ModCallbackCustom.POST_TRANSFORMATION;
 
+const v = {
+  run: {
+    // We cannot use a nested `DefaultMap` here.
+    playersTransformationsMap: new DefaultMap<
+      PlayerIndex,
+      Map<PlayerForm, boolean>
+    >(() => new Map()),
+  },
+};
+
 export class PostTransformation extends CustomCallback<T> {
-  public override v = {
-    run: {
-      // We cannot use a nested `DefaultMap` here.
-      playersTransformationsMap: new DefaultMap<
-        PlayerIndex,
-        Map<PlayerForm, boolean>
-      >(() => new Map()),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -49,7 +51,7 @@ export class PostTransformation extends CustomCallback<T> {
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private postPEffectUpdateReordered = (player: EntityPlayer) => {
     const playerTransformationsMap = defaultMapGetPlayer(
-      this.v.run.playersTransformationsMap,
+      v.run.playersTransformationsMap,
       player,
     );
 

package/src/classes/callbacks/PostTrinketBreak.ts

@@ -16,15 +16,17 @@ const TRINKETS_THAT_CAN_BREAK = [
   TrinketType.WALNUT,
 ] as const;
 
+const v = {
+  run: {
+    // We cannot use a nested `DefaultMap` here.
+    playersTrinketMap: new DefaultMap<PlayerIndex, Map<TrinketType, int>>(
+      () => new Map(),
+    ),
+  },
+};
+
 export class PostTrinketBreak extends CustomCallback<ModCallbackCustom.POST_TRINKET_BREAK> {
-  public override v = {
-    run: {
-      // We cannot use a nested `DefaultMap` here.
-      playersTrinketMap: new DefaultMap<PlayerIndex, Map<TrinketType, int>>(
-        () => new Map(),
-      ),
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -48,10 +50,7 @@ export class PostTrinketBreak extends CustomCallback<ModCallbackCustom.POST_TRIN
     _source: EntityRef,
     _countdownFrames: int,
   ): boolean | undefined => {
-    const trinketMap = defaultMapGetPlayer(
-      this.v.run.playersTrinketMap,
-      player,
-    );
+    const trinketMap = defaultMapGetPlayer(v.run.playersTrinketMap, player);
 
     for (const trinketType of TRINKETS_THAT_CAN_BREAK) {
       const numTrinketsHeld = player.GetTrinketMultiplier(trinketType);
@@ -86,10 +85,7 @@ export class PostTrinketBreak extends CustomCallback<ModCallbackCustom.POST_TRIN
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private postPEffectUpdateReordered = (player: EntityPlayer) => {
     // On every frame, keep track of how many trinkets we have.
-    const trinketMap = defaultMapGetPlayer(
-      this.v.run.playersTrinketMap,
-      player,
-    );
+    const trinketMap = defaultMapGetPlayer(v.run.playersTrinketMap, player);
 
     for (const trinketType of TRINKETS_THAT_CAN_BREAK) {
       const numTrinkets = player.GetTrinketMultiplier(trinketType);

package/src/classes/callbacks/PreNewLevel.ts

@@ -10,12 +10,14 @@ const TRAVELING_TO_NEXT_FLOOR_ANIMATIONS = new ReadonlySet<string>([
   "LightTravel",
 ]);
 
+const v = {
+  run: {
+    firedOnStage: null as int | null,
+  },
+};
+
 export class PreNewLevel extends CustomCallback<ModCallbackCustom.PRE_NEW_LEVEL> {
-  public override v = {
-    run: {
-      firedOnStage: null as int | null,
-    },
-  };
+  public override v = v;
 
   constructor() {
     super();
@@ -29,7 +31,7 @@ export class PreNewLevel extends CustomCallback<ModCallbackCustom.PRE_NEW_LEVEL>
   // ModCallback.POST_PLAYER_RENDER (32)
   private postPlayerRender = (player: EntityPlayer) => {
     const effectiveStage = getEffectiveStage();
-    if (effectiveStage === this.v.run.firedOnStage) {
+    if (effectiveStage === v.run.firedOnStage) {
       return;
     }
 
@@ -45,7 +47,7 @@ export class PreNewLevel extends CustomCallback<ModCallbackCustom.PRE_NEW_LEVEL>
     const frame = sprite.GetFrame();
     const finalFrame = getLastFrameOfAnimation(sprite);
     if (frame === finalFrame) {
-      this.v.run.firedOnStage = effectiveStage;
+      v.run.firedOnStage = effectiveStage;
       this.fire(player);
     }
   };