isaacscript-common 25.2.0 → 25.4.0

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

@@ -7,33 +7,35 @@ import { Exported } from "../../../decorators";
 import { getMoveActions, getShootActions } from "../../../functions/input";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    /**
+     * Glowing Hour Glass support is disabled by default since it can cause bugs with extra-gameplay
+     * features. (For example, whether the player should be able to move or not should often not be
+     * reset by the Glowing Hour Glass.)
+     */
+    __ignoreGlowingHourGlass: true,
+
+    /** Indexed by the requesting feature key. */
+    disableInputs: new Map<string, ReadonlySet<ButtonAction>>(),
+
+    /** Indexed by the requesting feature key. */
+    enableAllInputsWithBlacklistMap: new Map<
+      string,
+      ReadonlySet<ButtonAction>
+    >(),
+
+    /** Indexed by the requesting feature key. */
+    disableAllInputsWithWhitelistMap: new Map<
+      string,
+      ReadonlySet<ButtonAction>
+    >(),
+  },
+};
+
 export class DisableInputs extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      /**
-       * Glowing Hour Glass support is disabled by default since it can cause bugs with
-       * extra-gameplay features. (For example, whether the player should be able to move or not
-       * should often not be reset by the Glowing Hour Glass.)
-       */
-      __ignoreGlowingHourGlass: true,
-
-      /** Indexed by the requesting feature key. */
-      disableInputs: new Map<string, ReadonlySet<ButtonAction>>(),
-
-      /** Indexed by the requesting feature key. */
-      enableAllInputsWithBlacklistMap: new Map<
-        string,
-        ReadonlySet<ButtonAction>
-      >(),
-
-      /** Indexed by the requesting feature key. */
-      disableAllInputsWithWhitelistMap: new Map<
-        string,
-        ReadonlySet<ButtonAction>
-      >(),
-    },
-  };
+  public override v = v;
 
   /** @internal */
   constructor() {
@@ -87,19 +89,19 @@ export class DisableInputs extends Feature {
   private getReturnValue(buttonAction: ButtonAction, booleanCallback: boolean) {
     const disableValue = booleanCallback ? false : 0;
 
-    for (const blacklist of this.v.run.disableInputs.values()) {
+    for (const blacklist of v.run.disableInputs.values()) {
       if (blacklist.has(buttonAction)) {
         return disableValue;
       }
     }
 
-    for (const whitelist of this.v.run.disableAllInputsWithWhitelistMap.values()) {
+    for (const whitelist of v.run.disableAllInputsWithWhitelistMap.values()) {
       if (!whitelist.has(buttonAction)) {
         return disableValue;
       }
     }
 
-    for (const blacklist of this.v.run.enableAllInputsWithBlacklistMap.values()) {
+    for (const blacklist of v.run.enableAllInputsWithBlacklistMap.values()) {
       if (blacklist.has(buttonAction)) {
         return disableValue;
       }
@@ -119,8 +121,8 @@ export class DisableInputs extends Feature {
    */
   @Exported
   public enableAllInputs(key: string): void {
-    this.v.run.disableAllInputsWithWhitelistMap.delete(key);
-    this.v.run.enableAllInputsWithBlacklistMap.delete(key);
+    v.run.disableAllInputsWithWhitelistMap.delete(key);
+    v.run.enableAllInputsWithBlacklistMap.delete(key);
   }
 
   /**
@@ -140,7 +142,7 @@ export class DisableInputs extends Feature {
   @Exported
   public disableInputs(key: string, ...buttonActions: ButtonAction[]): void {
     const buttonActionsSet = new Set(buttonActions);
-    this.v.run.disableInputs.set(key, buttonActionsSet);
+    v.run.disableInputs.set(key, buttonActionsSet);
   }
 
   /**
@@ -156,8 +158,8 @@ export class DisableInputs extends Feature {
    */
   @Exported
   public disableAllInputs(key: string): void {
-    this.v.run.disableAllInputsWithWhitelistMap.set(key, new Set());
-    this.v.run.enableAllInputsWithBlacklistMap.delete(key);
+    v.run.disableAllInputsWithWhitelistMap.set(key, new Set());
+    v.run.enableAllInputsWithBlacklistMap.delete(key);
   }
 
   /**
@@ -177,8 +179,8 @@ export class DisableInputs extends Feature {
     key: string,
     blacklist: Set<ButtonAction> | ReadonlySet<ButtonAction>,
   ): void {
-    this.v.run.disableAllInputsWithWhitelistMap.delete(key);
-    this.v.run.enableAllInputsWithBlacklistMap.set(key, blacklist);
+    v.run.disableAllInputsWithWhitelistMap.delete(key);
+    v.run.enableAllInputsWithBlacklistMap.set(key, blacklist);
   }
 
   /**
@@ -198,8 +200,8 @@ export class DisableInputs extends Feature {
     key: string,
     whitelist: Set<ButtonAction> | ReadonlySet<ButtonAction>,
   ): void {
-    this.v.run.disableAllInputsWithWhitelistMap.set(key, whitelist);
-    this.v.run.enableAllInputsWithBlacklistMap.delete(key);
+    v.run.disableAllInputsWithWhitelistMap.set(key, whitelist);
+    v.run.enableAllInputsWithBlacklistMap.delete(key);
   }
 
   /**

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

@@ -78,7 +78,7 @@ export class ExtraConsoleCommands extends Feature {
 
   // ModCallback.POST_UPDATE (1)
   private postUpdate = () => {
-    if (this.v.persistent.spamBloodRights) {
+    if (v.persistent.spamBloodRights) {
       const player = Isaac.GetPlayer();
       player.UseActiveItem(CollectibleType.BLOOD_RIGHTS);
     }
@@ -87,31 +87,31 @@ export class ExtraConsoleCommands extends Feature {
   // ModCallback.EVALUATE_CACHE (8)
   // CacheFlag.DAMAGE (1 << 0)
   private evaluateCacheDamage = (player: EntityPlayer) => {
-    if (this.v.persistent.damage) {
-      player.Damage = this.v.persistent.damageAmount;
+    if (v.persistent.damage) {
+      player.Damage = v.persistent.damageAmount;
     }
   };
 
   // ModCallback.EVALUATE_CACHE (8)
   // CacheFlag.FIRE_DELAY (1 << 1)
   private evaluateCacheFireDelay = (player: EntityPlayer) => {
-    if (this.v.persistent.tears) {
-      player.FireDelay = this.v.persistent.tearsAmount;
+    if (v.persistent.tears) {
+      player.FireDelay = v.persistent.tearsAmount;
     }
   };
 
   // ModCallback.EVALUATE_CACHE (8)
   // CacheFlag.SPEED (1 << 4)
   private evaluateCacheSpeed = (player: EntityPlayer) => {
-    if (this.v.persistent.speed) {
-      player.MoveSpeed = this.v.persistent.speedAmount;
+    if (v.persistent.speed) {
+      player.MoveSpeed = v.persistent.speedAmount;
     }
   };
 
   // ModCallback.EVALUATE_CACHE (8)
   // CacheFlag.FLYING (1 << 7)
   private evaluateCacheFlying = (player: EntityPlayer) => {
-    if (this.v.persistent.flight) {
+    if (v.persistent.flight) {
       player.CanFly = true;
     }
   };
@@ -120,49 +120,49 @@ export class ExtraConsoleCommands extends Feature {
   private postCurseEval = (
     curses: BitFlags<LevelCurse>,
   ): BitFlags<LevelCurse> | undefined => {
-    if (this.v.persistent.disableCurses) {
+    if (v.persistent.disableCurses) {
       return bitFlags(LevelCurse.NONE);
     }
 
     let newCurses = curses;
 
     // 1
-    if (this.v.persistent.darkness) {
+    if (v.persistent.darkness) {
       newCurses = addFlag(newCurses, LevelCurse.DARKNESS);
     }
 
     // 2
-    if (this.v.persistent.labyrinth) {
+    if (v.persistent.labyrinth) {
       newCurses = addFlag(newCurses, LevelCurse.LABYRINTH);
     }
 
     // 3
-    if (this.v.persistent.lost) {
+    if (v.persistent.lost) {
       newCurses = addFlag(newCurses, LevelCurse.LOST);
     }
 
     // 4
-    if (this.v.persistent.unknown) {
+    if (v.persistent.unknown) {
       newCurses = addFlag(newCurses, LevelCurse.UNKNOWN);
     }
 
     // 5
-    if (this.v.persistent.cursed) {
+    if (v.persistent.cursed) {
       newCurses = addFlag(newCurses, LevelCurse.CURSED);
     }
 
     // 6
-    if (this.v.persistent.maze) {
+    if (v.persistent.maze) {
       newCurses = addFlag(newCurses, LevelCurse.MAZE);
     }
 
     // 7
-    if (this.v.persistent.blind) {
+    if (v.persistent.blind) {
       newCurses = addFlag(newCurses, LevelCurse.BLIND);
     }
 
     // 8
-    if (this.v.persistent.giant) {
+    if (v.persistent.giant) {
       newCurses = addFlag(newCurses, LevelCurse.GIANT);
     }
 
@@ -185,7 +185,7 @@ export class ExtraConsoleCommands extends Feature {
 
   // ModCallback.POST_FIRE_TEAR (61)
   private postFireTear = (tear: EntityTear) => {
-    if (this.v.persistent.chaosCardTears) {
+    if (v.persistent.chaosCardTears) {
       tear.ChangeVariant(TearVariant.CHAOS_CARD);
     }
   };
@@ -198,7 +198,7 @@ export class ExtraConsoleCommands extends Feature {
     _damageSource: EntityRef,
     _damageCountdownFrames: int,
   ) => {
-    if (this.v.persistent.spamBloodRights) {
+    if (v.persistent.spamBloodRights) {
       return false;
     }
 

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

@@ -6,15 +6,17 @@ import {
 import { Exported } from "../../../decorators";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    familiarBlacklist: [] as Array<
+      [variant: FamiliarVariant, subType: int | undefined]
+    >,
+  },
+};
+
 export class NoSirenSteal extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      familiarBlacklist: [] as Array<
-        [variant: FamiliarVariant, subType: int | undefined]
-      >,
-    },
-  };
+  public override v = v;
 
   /** @internal */
   constructor() {
@@ -56,7 +58,7 @@ export class NoSirenSteal extends Feature {
     incomingFamiliarVariant: FamiliarVariant,
     incomingFamiliarSubType: int | undefined,
   ): boolean {
-    for (const familiarTuple of this.v.run.familiarBlacklist) {
+    for (const familiarTuple of v.run.familiarBlacklist) {
       const [familiarVariant, familiarSubType] = familiarTuple;
 
       if (
@@ -98,6 +100,6 @@ export class NoSirenSteal extends Feature {
       return;
     }
 
-    this.v.run.familiarBlacklist.push([familiarVariant, familiarSubType]);
+    v.run.familiarBlacklist.push([familiarVariant, familiarSubType]);
   }
 }

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

@@ -29,15 +29,17 @@ interface InitialDescription {
   fallingAcceleration: float;
 }
 
+const v = {
+  run: {
+    isPseudoPaused: false,
+    shouldUnpause: false,
+    initialDescriptions: new Map<PtrHash, InitialDescription>(),
+  },
+};
+
 export class Pause extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      isPseudoPaused: false,
-      shouldUnpause: false,
-      initialDescriptions: new Map<PtrHash, InitialDescription>(),
-    },
-  };
+  public override v = v;
 
   private disableInputs: DisableInputs;
 
@@ -62,7 +64,7 @@ export class Pause extends Feature {
 
   // ModCallback.POST_UPDATE (1)
   private postUpdate = () => {
-    if (!this.v.run.isPseudoPaused) {
+    if (!v.run.isPseudoPaused) {
       return;
     }
 
@@ -77,7 +79,7 @@ export class Pause extends Feature {
 
     for (const tearOrProjectile of tearsAndProjectiles) {
       const ptrHash = GetPtrHash(tearOrProjectile);
-      const initialDescription = this.v.run.initialDescriptions.get(ptrHash);
+      const initialDescription = v.run.initialDescriptions.get(ptrHash);
       if (initialDescription === undefined) {
         continue;
       }
@@ -107,10 +109,10 @@ export class Pause extends Feature {
       return;
     }
 
-    if (!this.v.run.shouldUnpause) {
+    if (!v.run.shouldUnpause) {
       return;
     }
-    this.v.run.shouldUnpause = false;
+    v.run.shouldUnpause = false;
 
     // Returning a value of 1 for a single sub-frame will be enough for the game to register an
     // unpause but not enough for a tear to actually be fired.
@@ -119,7 +121,7 @@ export class Pause extends Feature {
 
   @Exported
   public isPaused(): boolean {
-    return this.v.run.isPseudoPaused;
+    return v.run.isPseudoPaused;
   }
 
   /**
@@ -135,18 +137,18 @@ export class Pause extends Feature {
    */
   @Exported
   public pause(): void {
-    if (this.v.run.isPseudoPaused) {
+    if (v.run.isPseudoPaused) {
       logError(
         "Failed to pseudo-pause the game, since it was already pseudo-paused.",
       );
       return;
     }
-    this.v.run.isPseudoPaused = true;
+    v.run.isPseudoPaused = true;
 
     // Tears/projectiles in the room will move slightly on every frame, even when the Pause
     // collectible is active. Thus, we manually reset the initial positions and heights on every
     // frame.
-    this.v.run.initialDescriptions.clear();
+    v.run.initialDescriptions.clear();
     const tearsAndProjectiles = [...getTears(), ...getProjectiles()];
     for (const tearOrProjectile of tearsAndProjectiles) {
       const ptrHash = GetPtrHash(tearOrProjectile);
@@ -160,7 +162,7 @@ export class Pause extends Feature {
           ? tearOrProjectile.FallingAcceleration
           : tearOrProjectile.FallingAccel,
       };
-      this.v.run.initialDescriptions.set(ptrHash, initialDescription);
+      v.run.initialDescriptions.set(ptrHash, initialDescription);
     }
 
     const firstPlayer = Isaac.GetPlayer();
@@ -197,14 +199,14 @@ export class Pause extends Feature {
    */
   @Exported
   public unpause(): void {
-    if (!this.v.run.isPseudoPaused) {
+    if (!v.run.isPseudoPaused) {
       logError(
         "Failed to pseudo-unpause the game, since it was not already pseudo-paused.",
       );
       return;
     }
-    this.v.run.isPseudoPaused = false;
-    this.v.run.shouldUnpause = true;
+    v.run.isPseudoPaused = false;
+    v.run.shouldUnpause = true;
 
     const tstlClassName = getTSTLClassName(this);
     if (tstlClassName === undefined) {

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

@@ -23,28 +23,30 @@ interface PersistentEntityDescription {
 
 type PersistentEntityTuple = [index: int, entityPtr: EntityPtr];
 
+const v = {
+  run: {
+    /** Iterates upward as new persistent entities are created. */
+    persistentEntityIndexCounter: 0,
+  },
+
+  level: {
+    /**
+     * Indexed by persistent entity index.
+     *
+     * When the entity is spawned in the currently room, its corresponding entry in this map will be
+     * temporarily deleted (until the entity itself is despawned).
+     */
+    persistentEntities: new Map<int, PersistentEntityDescription>(),
+  },
+
+  room: {
+    spawnedPersistentEntities: new Map<PtrHash, PersistentEntityTuple>(),
+  },
+};
+
 export class PersistentEntities extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      /** Iterates upward as new persistent entities are created. */
-      persistentEntityIndexCounter: 0,
-    },
-
-    level: {
-      /**
-       * Indexed by persistent entity index.
-       *
-       * When the entity is spawned in the currently room, its corresponding entry in this map will
-       * be temporarily deleted (until the entity itself is despawned).
-       */
-      persistentEntities: new Map<int, PersistentEntityDescription>(),
-    },
-
-    room: {
-      spawnedPersistentEntities: new Map<PtrHash, PersistentEntityTuple>(),
-    },
-  };
+  public override v = v;
 
   private roomHistory: RoomHistory;
 
@@ -69,7 +71,7 @@ export class PersistentEntities extends Feature {
   // ModCallback.POST_ENTITY_REMOVE (67)
   private postEntityRemove = (entity: Entity) => {
     const ptrHash = GetPtrHash(entity);
-    const tuple = this.v.room.spawnedPersistentEntities.get(ptrHash);
+    const tuple = v.room.spawnedPersistentEntities.get(ptrHash);
     if (tuple === undefined) {
       return;
     }
@@ -105,19 +107,19 @@ export class PersistentEntities extends Feature {
       roomListIndex: previousRoomDescription.roomListIndex,
       position: entity.Position,
     };
-    this.v.level.persistentEntities.set(index, persistentEntityDescription);
+    v.level.persistentEntities.set(index, persistentEntityDescription);
   }
 
   // ModCallbackCustom.POST_NEW_ROOM_REORDERED
   private postNewRoomReordered = () => {
     const roomListIndex = getRoomListIndex();
-    const persistentEntities = [...this.v.level.persistentEntities.entries()];
+    const persistentEntities = [...v.level.persistentEntities.entries()];
     const persistentEntitiesInThisRoom = persistentEntities.filter(
       ([_index, description]) => roomListIndex === description.roomListIndex,
     );
 
     for (const [index, description] of persistentEntitiesInThisRoom) {
-      this.v.level.persistentEntities.delete(index);
+      v.level.persistentEntities.delete(index);
       this.spawnAndTrack(
         description.entityType,
         description.variant,
@@ -146,7 +148,7 @@ export class PersistentEntities extends Feature {
 
     // Keep track that we spawned it so that we can respawn it if the player re-enters the room.
     const tuple: [int, EntityPtr] = [index, EntityPtr(entity)];
-    this.v.room.spawnedPersistentEntities.set(ptrHash, tuple);
+    v.room.spawnedPersistentEntities.set(ptrHash, tuple);
 
     return entity;
   }
@@ -168,15 +170,15 @@ export class PersistentEntities extends Feature {
     persistentEntityIndex: int,
     removeEntity = true,
   ): void {
-    this.v.level.persistentEntities.delete(persistentEntityIndex);
+    v.level.persistentEntities.delete(persistentEntityIndex);
 
-    for (const [ptrHash, tuple] of this.v.room.spawnedPersistentEntities) {
+    for (const [ptrHash, tuple] of v.room.spawnedPersistentEntities) {
       const [index, entityPtr] = tuple;
       if (index !== persistentEntityIndex) {
         continue;
       }
 
-      this.v.room.spawnedPersistentEntities.delete(ptrHash);
+      v.room.spawnedPersistentEntities.delete(ptrHash);
 
       if (removeEntity && entityPtr.Ref !== undefined) {
         entityPtr.Ref.Remove();
@@ -209,16 +211,16 @@ export class PersistentEntities extends Feature {
     subType: int,
     position: Vector,
   ): [Entity, int] {
-    this.v.run.persistentEntityIndexCounter++;
+    v.run.persistentEntityIndexCounter++;
 
     const entity = this.spawnAndTrack(
       entityType,
       variant,
       subType,
       position,
-      this.v.run.persistentEntityIndexCounter,
+      v.run.persistentEntityIndexCounter,
     );
 
-    return [entity, this.v.run.persistentEntityIndexCounter];
+    return [entity, v.run.persistentEntityIndexCounter];
   }
 }

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

@@ -21,28 +21,30 @@ interface PickupDescription {
   initSeed: Seed;
 }
 
+const v = {
+  run: {
+    /** Is incremented before assignment. Thus, the first pickup will have an index of 1. */
+    pickupCounter: 0 as PickupIndex,
+
+    pickupDataTreasureRooms: new Map<PickupIndex, PickupDescription>(),
+    pickupDataBossRooms: new Map<PickupIndex, PickupDescription>(),
+  },
+
+  level: {
+    /** Indexed by room list index. */
+    pickupData: new DefaultMap<int, Map<PickupIndex, PickupDescription>>(
+      () => new Map(),
+    ),
+  },
+
+  room: {
+    pickupIndexes: new Map<PtrHash, PickupIndex>(),
+  },
+};
+
 export class PickupIndexCreation extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      /** Is incremented before assignment. Thus, the first pickup will have an index of 1. */
-      pickupCounter: 0 as PickupIndex,
-
-      pickupDataTreasureRooms: new Map<PickupIndex, PickupDescription>(),
-      pickupDataBossRooms: new Map<PickupIndex, PickupDescription>(),
-    },
-
-    level: {
-      /** Indexed by room list index. */
-      pickupData: new DefaultMap<int, Map<PickupIndex, PickupDescription>>(
-        () => new Map(),
-      ),
-    },
-
-    room: {
-      pickupIndexes: new Map<PtrHash, PickupIndex>(),
-    },
-  };
+  public override v = v;
 
   private roomHistory: RoomHistory;
   private saveDataManager: SaveDataManager;
@@ -81,7 +83,7 @@ export class PickupIndexCreation extends Feature {
     // callback but should not incur a new pickup counter. (For example, the collectible rotation
     // with Tainted Isaac.) For these situations, we will already be tracking an index for this
     // pointer hash.
-    if (this.v.room.pickupIndexes.has(ptrHash)) {
+    if (v.room.pickupIndexes.has(ptrHash)) {
       return;
     }
 
@@ -97,13 +99,13 @@ export class PickupIndexCreation extends Feature {
       !isFirstVisit &&
       roomFrameCount <= 0
     ) {
-      this.v.room.pickupIndexes.set(ptrHash, pickupIndexFromLevelData);
+      v.room.pickupIndexes.set(ptrHash, pickupIndexFromLevelData);
       return;
     }
 
     // This is a brand new pickup that we have not previously seen on this run.
-    this.v.run.pickupCounter++;
-    this.v.room.pickupIndexes.set(ptrHash, this.v.run.pickupCounter);
+    v.run.pickupCounter++;
+    v.room.pickupIndexes.set(ptrHash, v.run.pickupCounter);
   }
 
   private getPickupIndexFromPreviousData(
@@ -111,7 +113,7 @@ export class PickupIndexCreation extends Feature {
   ): PickupIndex | undefined {
     const roomListIndex = getRoomListIndex();
     const pickupDescriptions =
-      this.v.level.pickupData.getAndSetDefault(roomListIndex);
+      v.level.pickupData.getAndSetDefault(roomListIndex);
 
     let pickupIndex = getStoredPickupIndex(pickup, pickupDescriptions);
     if (pickupIndex === undefined) {
@@ -129,7 +131,7 @@ export class PickupIndexCreation extends Feature {
 
   private checkDespawningFromPlayerLeavingRoom(entity: Entity) {
     const ptrHash = GetPtrHash(entity);
-    const pickupIndex = this.v.room.pickupIndexes.get(ptrHash);
+    const pickupIndex = v.room.pickupIndexes.get(ptrHash);
     if (pickupIndex === undefined) {
       return;
     }
@@ -157,7 +159,7 @@ export class PickupIndexCreation extends Feature {
     }
 
     const previousRoomListIndex = previousRoomDescription.roomListIndex;
-    const pickupDescriptions = this.v.level.pickupData.getAndSetDefault(
+    const pickupDescriptions = v.level.pickupData.getAndSetDefault(
       previousRoomListIndex,
     );
 
@@ -196,11 +198,11 @@ export class PickupIndexCreation extends Feature {
 
     switch (roomType) {
       case RoomType.TREASURE: {
-        return this.v.run.pickupDataTreasureRooms;
+        return v.run.pickupDataTreasureRooms;
       }
 
       case RoomType.BOSS: {
-        return this.v.run.pickupDataBossRooms;
+        return v.run.pickupDataBossRooms;
       }
 
       default: {
@@ -223,11 +225,11 @@ export class PickupIndexCreation extends Feature {
 
     switch (roomType) {
       case RoomType.TREASURE: {
-        return getStoredPickupIndex(pickup, this.v.run.pickupDataTreasureRooms);
+        return getStoredPickupIndex(pickup, v.run.pickupDataTreasureRooms);
       }
 
       case RoomType.BOSS: {
-        return getStoredPickupIndex(pickup, this.v.run.pickupDataBossRooms);
+        return getStoredPickupIndex(pickup, v.run.pickupDataBossRooms);
       }
 
       default: {
@@ -255,13 +257,13 @@ export class PickupIndexCreation extends Feature {
   @Exported
   public getPickupIndex(pickup: EntityPickup): PickupIndex {
     const ptrHash = GetPtrHash(pickup);
-    const pickupIndexInitial = this.v.room.pickupIndexes.get(ptrHash);
+    const pickupIndexInitial = v.room.pickupIndexes.get(ptrHash);
     if (pickupIndexInitial !== undefined) {
       return pickupIndexInitial;
     }
 
     this.setPickupIndex(pickup);
-    const pickupIndex = this.v.room.pickupIndexes.get(ptrHash);
+    const pickupIndex = v.room.pickupIndexes.get(ptrHash);
     if (pickupIndex !== undefined) {
       return pickupIndex;
     }