isaacscript-common 25.2.0 → 25.4.0

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

@@ -36,14 +36,16 @@ enum CustomReviveState {
   WAITING_FOR_ITEM_ANIMATION,
 }
 
+const v = {
+  run: {
+    state: CustomReviveState.DISABLED,
+    revivalType: null as int | null,
+    dyingPlayerIndex: null as PlayerIndex | null,
+  },
+};
+
 export class CustomRevive extends Feature {
-  public override v = {
-    run: {
-      state: CustomReviveState.DISABLED,
-      revivalType: null as int | null,
-      dyingPlayerIndex: null as PlayerIndex | null,
-    },
-  };
+  public override v = v;
 
   private preCustomRevive: PreCustomRevive;
   private postCustomRevive: PostCustomRevive;
@@ -87,7 +89,7 @@ export class CustomRevive extends Feature {
 
   // ModCallback.POST_RENDER (2)
   private postRender = (): void => {
-    if (this.v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
+    if (v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
       return;
     }
 
@@ -99,7 +101,7 @@ export class CustomRevive extends Feature {
   // ModCallback.POST_FAMILIAR_INIT (7)
   // FamiliarVariant.ONE_UP (41)
   private postFamiliarInitOneUp = (familiar: EntityFamiliar): void => {
-    if (this.v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
+    if (v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
       return;
     }
 
@@ -108,11 +110,11 @@ export class CustomRevive extends Feature {
 
   // ModCallbackCustom.POST_NEW_ROOM_REORDERED
   private postNewRoomReordered = (): void => {
-    if (this.v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
+    if (v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
       return;
     }
 
-    this.v.run.state = CustomReviveState.WAITING_FOR_ITEM_ANIMATION;
+    v.run.state = CustomReviveState.WAITING_FOR_ITEM_ANIMATION;
     this.logStateChanged();
   };
 
@@ -122,16 +124,16 @@ export class CustomRevive extends Feature {
   };
 
   private checkWaitingForItemAnimation(player: EntityPlayer): void {
-    if (this.v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
+    if (v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
       return;
     }
 
-    if (this.v.run.dyingPlayerIndex === null) {
+    if (v.run.dyingPlayerIndex === null) {
       return;
     }
 
     const playerIndex = getPlayerIndex(player);
-    if (playerIndex !== this.v.run.dyingPlayerIndex) {
+    if (playerIndex !== v.run.dyingPlayerIndex) {
       return;
     }
 
@@ -152,16 +154,13 @@ export class CustomRevive extends Feature {
     // expected to play a new animation in the PostCustomRevive callback, which will overwrite the
     // 1-Up animation.
 
-    if (this.v.run.revivalType !== null) {
-      this.postCustomRevive.fire(
-        playerToCheckHoldingItem,
-        this.v.run.revivalType,
-      );
+    if (v.run.revivalType !== null) {
+      this.postCustomRevive.fire(playerToCheckHoldingItem, v.run.revivalType);
     }
 
-    this.v.run.state = CustomReviveState.DISABLED;
-    this.v.run.revivalType = null;
-    this.v.run.dyingPlayerIndex = null;
+    v.run.state = CustomReviveState.DISABLED;
+    v.run.revivalType = null;
+    v.run.dyingPlayerIndex = null;
     this.logStateChanged();
   }
 
@@ -188,9 +187,9 @@ export class CustomRevive extends Feature {
       return;
     }
 
-    this.v.run.state = CustomReviveState.WAITING_FOR_ROOM_TRANSITION;
-    this.v.run.revivalType = revivalType;
-    this.v.run.dyingPlayerIndex = getPlayerIndex(player);
+    v.run.state = CustomReviveState.WAITING_FOR_ROOM_TRANSITION;
+    v.run.revivalType = revivalType;
+    v.run.dyingPlayerIndex = getPlayerIndex(player);
     this.logStateChanged();
 
     player.AddCollectible(CollectibleType.ONE_UP, 0, false);
@@ -220,8 +219,8 @@ export class CustomRevive extends Feature {
   private logStateChanged(): void {
     if (DEBUG) {
       log(
-        `Custom revive state changed: ${CustomReviveState[this.v.run.state]} (${
-          this.v.run.state
+        `Custom revive state changed: ${CustomReviveState[v.run.state]} (${
+          v.run.state
         })`,
       );
     }

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

@@ -10,14 +10,16 @@ import { PostEsauJr } from "../../callbacks/PostEsauJr";
 import { PostFirstEsauJr } from "../../callbacks/PostFirstEsauJr";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    usedEsauJrFrame: null as int | null,
+    usedEsauJrControllerIndex: null as ControllerIndex | null,
+    usedEsauJrAtLeastOnce: false,
+  },
+};
+
 export class EsauJrDetection extends Feature {
-  public override v = {
-    run: {
-      usedEsauJrFrame: null as int | null,
-      usedEsauJrControllerIndex: null as ControllerIndex | null,
-      usedEsauJrAtLeastOnce: false,
-    },
-  };
+  public override v = v;
 
   private postEsauJr: PostEsauJr;
   private postFirstEsauJr: PostFirstEsauJr;
@@ -47,30 +49,30 @@ export class EsauJrDetection extends Feature {
 
     // Check to see if it is the frame after the player has used Esau Jr.
     if (
-      this.v.run.usedEsauJrFrame === null ||
-      gameFrameCount < this.v.run.usedEsauJrFrame + 1
+      v.run.usedEsauJrFrame === null ||
+      gameFrameCount < v.run.usedEsauJrFrame + 1
     ) {
       return;
     }
-    this.v.run.usedEsauJrFrame = null;
+    v.run.usedEsauJrFrame = null;
 
     // Find the player corresponding to the player who used Esau Jr. a frame ago (via matching the
     // ControllerIndex).
-    if (this.v.run.usedEsauJrControllerIndex === null) {
+    if (v.run.usedEsauJrControllerIndex === null) {
       return;
     }
     const players = getPlayersWithControllerIndex(
-      this.v.run.usedEsauJrControllerIndex,
+      v.run.usedEsauJrControllerIndex,
     );
-    this.v.run.usedEsauJrControllerIndex = null;
+    v.run.usedEsauJrControllerIndex = null;
 
     const player = players[0];
     if (player === undefined) {
       return;
     }
 
-    if (!this.v.run.usedEsauJrAtLeastOnce) {
-      this.v.run.usedEsauJrAtLeastOnce = true;
+    if (!v.run.usedEsauJrAtLeastOnce) {
+      v.run.usedEsauJrAtLeastOnce = true;
       this.postFirstEsauJr.fire(player);
     }
 
@@ -90,8 +92,8 @@ export class EsauJrDetection extends Feature {
     const gameFrameCount = game.GetFrameCount();
 
     // The player only changes to Esau Jr. on the frame after the item is used.
-    this.v.run.usedEsauJrFrame = gameFrameCount + 1;
-    this.v.run.usedEsauJrControllerIndex = player.ControllerIndex;
+    v.run.usedEsauJrFrame = gameFrameCount + 1;
+    v.run.usedEsauJrControllerIndex = player.ControllerIndex;
 
     return undefined;
   };

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

@@ -9,13 +9,15 @@ import { PostFirstFlip } from "../../callbacks/PostFirstFlip";
 import { PostFlip } from "../../callbacks/PostFlip";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
+    usedFlipAtLeastOnce: false,
+  },
+};
+
 export class FlipDetection extends Feature {
-  public override v = {
-    run: {
-      /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
-      usedFlipAtLeastOnce: false,
-    },
-  };
+  public override v = v;
 
   private postFlip: PostFlip;
   private postFirstFlip: PostFirstFlip;
@@ -53,8 +55,8 @@ export class FlipDetection extends Feature {
       return undefined;
     }
 
-    if (!this.v.run.usedFlipAtLeastOnce) {
-      this.v.run.usedFlipAtLeastOnce = true;
+    if (!v.run.usedFlipAtLeastOnce) {
+      v.run.usedFlipAtLeastOnce = true;
       this.postFirstFlip.fire(newLazarus, player);
     }
 

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

@@ -9,15 +9,17 @@ import { DefaultMap } from "../../DefaultMap";
 import { Feature } from "../../private/Feature";
 import { CustomGridEntities } from "./CustomGridEntities";
 
+const v = {
+  room: {
+    /** Indexed by grid entity pointer hash. */
+    collidingEntitiesMap: new DefaultMap<PtrHash, Set<PtrHash>>(
+      () => new Set(),
+    ),
+  },
+};
+
 export class GridEntityCollisionDetection extends Feature {
-  public override v = {
-    room: {
-      /** Indexed by grid entity pointer hash. */
-      collidingEntitiesMap: new DefaultMap<PtrHash, Set<PtrHash>>(
-        () => new Set(),
-      ),
-    },
-  };
+  public override v = v;
 
   private postGridEntityCollision: PostGridEntityCollision;
   private postGridEntityCustomCollision: PostGridEntityCustomCollision;
@@ -49,7 +51,7 @@ export class GridEntityCollisionDetection extends Feature {
     for (const gridEntity of gridEntitiesWithCollision) {
       const gridEntityPtrHash = GetPtrHash(gridEntity);
       const oldCollidingEntities =
-        this.v.room.collidingEntitiesMap.getAndSetDefault(gridEntityPtrHash);
+        v.room.collidingEntitiesMap.getAndSetDefault(gridEntityPtrHash);
 
       // Check for new colliding entities.
       const collidingEntities = getCollidingEntitiesWithGridEntity(gridEntity);

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

@@ -24,13 +24,15 @@ type GridEntityTuple = [
   state: int,
 ];
 
+const v = {
+  room: {
+    /** Indexed by grid index. */
+    initializedGridEntities: new Map<int, GridEntityTuple>(),
+  },
+};
+
 export class GridEntityUpdateDetection extends Feature {
-  public override v = {
-    room: {
-      /** Indexed by grid index. */
-      initializedGridEntities: new Map<int, GridEntityTuple>(),
-    },
-  };
+  public override v = v;
 
   private postGridEntityInit: PostGridEntityInit;
   private postGridEntityCustomInit: PostGridEntityCustomInit;
@@ -108,15 +110,14 @@ export class GridEntityUpdateDetection extends Feature {
   private checkGridEntitiesRemoved(
     gridEntitiesMap: Map<int, GridEntity>,
   ): void {
-    for (const [gridIndex, gridEntityTuple] of this.v.room
-      .initializedGridEntities) {
+    for (const [gridIndex, gridEntityTuple] of v.room.initializedGridEntities) {
       const [storedGridEntityType, storedGridEntityVariant] = gridEntityTuple;
       const gridEntity = gridEntitiesMap.get(gridIndex);
       if (
         gridEntity === undefined ||
         gridEntity.GetType() !== storedGridEntityType
       ) {
-        this.v.room.initializedGridEntities.delete(gridIndex);
+        v.room.initializedGridEntities.delete(gridIndex);
 
         const gridEntityTypeCustom =
           this.customGridEntities.getCustomGridEntityType(gridIndex);
@@ -137,7 +138,7 @@ export class GridEntityUpdateDetection extends Feature {
     gridIndex: int,
     gridEntity: GridEntity,
   ): void {
-    const gridEntityTuple = this.v.room.initializedGridEntities.get(gridIndex);
+    const gridEntityTuple = v.room.initializedGridEntities.get(gridIndex);
     if (gridEntityTuple === undefined) {
       // This grid entity did not exist a frame ago; we don't want to fire the state changed
       // callback on the first frame that it exists.
@@ -177,7 +178,7 @@ export class GridEntityUpdateDetection extends Feature {
 
   private checkNewGridEntity(gridIndex: int, gridEntity: GridEntity): void {
     const gridEntityType = gridEntity.GetType();
-    const gridEntityTuple = this.v.room.initializedGridEntities.get(gridIndex);
+    const gridEntityTuple = v.room.initializedGridEntities.get(gridIndex);
 
     if (
       gridEntityTuple === undefined ||
@@ -204,7 +205,7 @@ export class GridEntityUpdateDetection extends Feature {
       variant,
       gridEntity.State,
     ];
-    this.v.room.initializedGridEntities.set(gridIndex, newTuple);
+    v.room.initializedGridEntities.set(gridIndex, newTuple);
   }
 
   // ModCallbackCustom.POST_NEW_ROOM_REORDERED

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

@@ -17,14 +17,16 @@ import { PreItemPickup } from "../../callbacks/PreItemPickup";
 import { DefaultMap } from "../../DefaultMap";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    playersPickingUpItemMap: new DefaultMap<PlayerIndex, PickingUpItem>(() =>
+      newPickingUpItem(),
+    ),
+  },
+};
+
 export class ItemPickupDetection extends Feature {
-  public override v = {
-    run: {
-      playersPickingUpItemMap: new DefaultMap<PlayerIndex, PickingUpItem>(() =>
-        newPickingUpItem(),
-      ),
-    },
-  };
+  public override v = v;
 
   private postItemPickup: PostItemPickup;
   private preItemPickup: PreItemPickup;
@@ -46,7 +48,7 @@ export class ItemPickupDetection extends Feature {
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private postPEffectUpdateReordered = (player: EntityPlayer) => {
     const pickingUpItem = defaultMapGetPlayer(
-      this.v.run.playersPickingUpItemMap,
+      v.run.playersPickingUpItemMap,
       player,
     );
 

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

@@ -5,13 +5,15 @@ import { PostPickupChanged } from "../../callbacks/PostPickupChanged";
 import { Feature } from "../../private/Feature";
 import { PickupIndexCreation } from "../other/PickupIndexCreation";
 
+const v = {
+  room: {
+    pickupVariants: new Map<PickupIndex, PickupVariant>(),
+    pickupSubTypes: new Map<PickupIndex, int>(),
+  },
+};
+
 export class PickupChangeDetection extends Feature {
-  public override v = {
-    room: {
-      pickupVariants: new Map<PickupIndex, PickupVariant>(),
-      pickupSubTypes: new Map<PickupIndex, int>(),
-    },
-  };
+  public override v = v;
 
   private postPickupChanged: PostPickupChanged;
   private pickupIndexCreation: PickupIndexCreation;
@@ -37,11 +39,11 @@ export class PickupChangeDetection extends Feature {
   private postPickupUpdate = (pickup: EntityPickup) => {
     const pickupIndex = this.pickupIndexCreation.getPickupIndex(pickup);
 
-    const oldVariant = this.v.room.pickupVariants.get(pickupIndex);
-    this.v.room.pickupVariants.set(pickupIndex, pickup.Variant);
+    const oldVariant = v.room.pickupVariants.get(pickupIndex);
+    v.room.pickupVariants.set(pickupIndex, pickup.Variant);
 
-    const oldSubType = this.v.room.pickupSubTypes.get(pickupIndex);
-    this.v.room.pickupSubTypes.set(pickupIndex, pickup.SubType);
+    const oldSubType = v.room.pickupSubTypes.get(pickupIndex);
+    v.room.pickupSubTypes.set(pickupIndex, pickup.SubType);
 
     // If this is the first update frame for the pickup, it cannot have changed.
     if (oldVariant === undefined || oldSubType === undefined) {

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

@@ -26,20 +26,22 @@ import { Feature } from "../../private/Feature";
 import { ModdedElementSets } from "../other/ModdedElementSets";
 import { RunInNFrames } from "../other/RunInNFrames";
 
+const 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()),
+  },
+};
+
 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()),
-    },
-  };
+  public override v = v;
 
   private postPlayerCollectibleAdded: PostPlayerCollectibleAdded;
   private postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved;
@@ -96,12 +98,12 @@ export class PlayerCollectibleDetection extends Feature {
     numCollectiblesChanged: int | undefined,
   ) {
     const oldCollectibleMap = defaultMapGetPlayer(
-      this.v.run.playersCollectibleMap,
+      v.run.playersCollectibleMap,
       player,
     );
     const newCollectibleMap =
       this.moddedElementSets.getPlayerCollectibleMap(player);
-    mapSetPlayer(this.v.run.playersCollectibleMap, player, newCollectibleMap);
+    mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
 
     const collectibleTypesSet = new Set<CollectibleType>([
       ...oldCollectibleMap.keys(),
@@ -204,11 +206,7 @@ export class PlayerCollectibleDetection extends Feature {
     }
 
     const newCollectibleCount = player.GetCollectibleCount();
-    mapSetPlayer(
-      this.v.run.playersCollectibleCount,
-      player,
-      newCollectibleCount,
-    );
+    mapSetPlayer(v.run.playersCollectibleCount, player, newCollectibleCount);
 
     this.updateCollectibleMapAndFire(player, 1);
   };
@@ -216,15 +214,11 @@ export class PlayerCollectibleDetection extends Feature {
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private postPEffectUpdateReordered = (player: EntityPlayer) => {
     const oldCollectibleCount = defaultMapGetPlayer(
-      this.v.run.playersCollectibleCount,
+      v.run.playersCollectibleCount,
       player,
     );
     const newCollectibleCount = player.GetCollectibleCount();
-    mapSetPlayer(
-      this.v.run.playersCollectibleCount,
-      player,
-      newCollectibleCount,
-    );
+    mapSetPlayer(v.run.playersCollectibleCount, player, newCollectibleCount);
 
     const difference = newCollectibleCount - oldCollectibleCount;
 
@@ -248,7 +242,7 @@ export class PlayerCollectibleDetection extends Feature {
    */
   private checkActiveItemsChanged(player: EntityPlayer) {
     const activeItemMap = defaultMapGetPlayer(
-      this.v.run.playersActiveItemMap,
+      v.run.playersActiveItemMap,
       player,
     );
 

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

@@ -16,16 +16,18 @@ import { PostPlayerRenderReordered } from "../../callbacks/PostPlayerRenderReord
 import { PostPlayerUpdateReordered } from "../../callbacks/PostPlayerUpdateReordered";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    postGameStartedFiredOnThisRun: false,
+
+    postPEffectUpdateQueue: [] as PlayerIndex[],
+    postPlayerUpdateQueue: [] as PlayerIndex[],
+    postPlayerRenderQueue: [] as PlayerIndex[],
+  },
+};
+
 export class PlayerReorderedCallbacks extends Feature {
-  public override v = {
-    run: {
-      postGameStartedFiredOnThisRun: false,
-
-      postPEffectUpdateQueue: [] as PlayerIndex[],
-      postPlayerUpdateQueue: [] as PlayerIndex[],
-      postPlayerRenderQueue: [] as PlayerIndex[],
-    },
-  };
+  public override v = v;
 
   private postPEffectUpdateReordered: PostPEffectUpdateReordered;
   private postPlayerRenderReordered: PostPlayerRenderReordered;
@@ -63,23 +65,23 @@ export class PlayerReorderedCallbacks extends Feature {
 
   // ModCallback.POST_PEFFECT_UPDATE (4)
   private postPEffectUpdate = (player: EntityPlayer): void => {
-    if (this.v.run.postGameStartedFiredOnThisRun) {
+    if (v.run.postGameStartedFiredOnThisRun) {
       this.postPEffectUpdateReordered.fire(player);
     } else {
       // Defer callback execution until the `POST_GAME_STARTED` callback fires.
       const playerIndex = getPlayerIndex(player);
-      this.v.run.postPEffectUpdateQueue.push(playerIndex);
+      v.run.postPEffectUpdateQueue.push(playerIndex);
     }
   };
 
   // ModCallback.POST_PLAYER_UPDATE (31)
   private postPlayerUpdate = (player: EntityPlayer): void => {
-    if (this.v.run.postGameStartedFiredOnThisRun) {
+    if (v.run.postGameStartedFiredOnThisRun) {
       this.postPlayerUpdateReordered.fire(player);
     } else {
       // Defer callback execution until the `POST_GAME_STARTED` callback fires.
       const playerIndex = getPlayerIndex(player);
-      this.v.run.postPlayerUpdateQueue.push(playerIndex);
+      v.run.postPlayerUpdateQueue.push(playerIndex);
     }
   };
 
@@ -88,31 +90,22 @@ export class PlayerReorderedCallbacks extends Feature {
     player: EntityPlayer,
     _renderOffset: Vector,
   ): void => {
-    if (this.v.run.postGameStartedFiredOnThisRun) {
+    if (v.run.postGameStartedFiredOnThisRun) {
       this.postPlayerRenderReordered.fire(player);
     } else {
       // Defer callback execution until the `POST_GAME_STARTED` callback fires.
       const playerIndex = getPlayerIndex(player);
-      this.v.run.postPlayerRenderQueue.push(playerIndex);
+      v.run.postPlayerRenderQueue.push(playerIndex);
     }
   };
 
   // ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST
   private postGameStartedReorderedLast = (): void => {
-    this.v.run.postGameStartedFiredOnThisRun = true;
-
-    dequeue(
-      this.v.run.postPEffectUpdateQueue,
-      this.postPEffectUpdateReordered.fire,
-    );
-    dequeue(
-      this.v.run.postPlayerUpdateQueue,
-      this.postPlayerUpdateReordered.fire,
-    );
-    dequeue(
-      this.v.run.postPlayerRenderQueue,
-      this.postPlayerRenderReordered.fire,
-    );
+    v.run.postGameStartedFiredOnThisRun = true;
+
+    dequeue(v.run.postPEffectUpdateQueue, this.postPEffectUpdateReordered.fire);
+    dequeue(v.run.postPlayerUpdateQueue, this.postPlayerUpdateReordered.fire);
+    dequeue(v.run.postPlayerRenderQueue, this.postPlayerRenderReordered.fire);
   };
 }
 

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

@@ -24,12 +24,14 @@ import { PostSlotDestroyed } from "../../callbacks/PostSlotDestroyed";
 import { Feature } from "../../private/Feature";
 import { RoomHistory } from "../other/RoomHistory";
 
+const v = {
+  room: {
+    destroyedSlotSet: new Set<PtrHash>(),
+  },
+};
+
 export class SlotDestroyedDetection extends Feature {
-  public override v = {
-    room: {
-      destroyedSlotSet: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   private postSlotDestroyed: PostSlotDestroyed;
   private roomHistory: RoomHistory;
@@ -92,7 +94,7 @@ export class SlotDestroyedDetection extends Feature {
   private postSlotUpdate = (slot: EntitySlot) => {
     const ptrHash = GetPtrHash(slot);
 
-    const alreadyDestroyed = this.v.room.destroyedSlotSet.has(ptrHash);
+    const alreadyDestroyed = v.room.destroyedSlotSet.has(ptrHash);
     if (alreadyDestroyed) {
       return;
     }
@@ -109,7 +111,7 @@ export class SlotDestroyedDetection extends Feature {
   private checkDestroyedFromCollisionClass(slot: EntitySlot) {
     if (slot.GridCollisionClass === EntityGridCollisionClass.GROUND) {
       const ptrHash = GetPtrHash(slot);
-      this.v.room.destroyedSlotSet.add(ptrHash);
+      v.room.destroyedSlotSet.add(ptrHash);
       this.postSlotDestroyed.fire(slot, SlotDestructionType.NORMAL);
     }
   }

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

@@ -5,18 +5,20 @@ import { PostSlotRender } from "../../callbacks/PostSlotRender";
 import { DefaultMap } from "../../DefaultMap";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  room: {
+    slotAnimations: new DefaultMap<PtrHash, string, [slot: Entity]>(
+      (slot: Entity) => {
+        const sprite = slot.GetSprite();
+        return sprite.GetAnimation();
+      },
+    ),
+    brokenSlots: new Set<PtrHash>(),
+  },
+};
+
 export class SlotRenderDetection extends Feature {
-  public override v = {
-    room: {
-      slotAnimations: new DefaultMap<PtrHash, string, [slot: Entity]>(
-        (slot: Entity) => {
-          const sprite = slot.GetSprite();
-          return sprite.GetAnimation();
-        },
-      ),
-      brokenSlots: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   private postSlotRender: PostSlotRender;
   private postSlotAnimationChanged: PostSlotAnimationChanged;
@@ -48,11 +50,11 @@ export class SlotRenderDetection extends Feature {
     const sprite = slot.GetSprite();
     const currentAnimation = sprite.GetAnimation();
     const ptrHash = GetPtrHash(slot);
-    const previousAnimation = this.v.room.slotAnimations.getAndSetDefault(
+    const previousAnimation = v.room.slotAnimations.getAndSetDefault(
       ptrHash,
       slot,
     );
-    this.v.room.slotAnimations.set(ptrHash, currentAnimation);
+    v.room.slotAnimations.set(ptrHash, currentAnimation);
 
     if (currentAnimation !== previousAnimation) {
       this.postSlotAnimationChanged.fire(