isaacscript-common 25.3.0 → 25.5.0

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

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

@@ -12,17 +12,19 @@ import { PlayerIndex } from "../../../types/PlayerIndex";
 import { DefaultMap } from "../../DefaultMap";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    playersInventory: new DefaultMap<
+      PlayerIndex,
+      CollectibleType[],
+      [player: EntityPlayer]
+    >(() => []),
+  },
+};
+
 export class PlayerInventory extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      playersInventory: new DefaultMap<
-        PlayerIndex,
-        CollectibleType[],
-        [player: EntityPlayer]
-      >(() => []),
-    },
-  };
+  public override v = v;
 
   /** @internal */
   constructor() {
@@ -46,7 +48,7 @@ export class PlayerInventory extends Feature {
     collectibleType: CollectibleType,
   ) => {
     const inventory = defaultMapGetPlayer(
-      this.v.run.playersInventory,
+      v.run.playersInventory,
       player,
       player,
     );
@@ -59,7 +61,7 @@ export class PlayerInventory extends Feature {
     collectibleType: CollectibleType,
   ) => {
     const inventory = defaultMapGetPlayer(
-      this.v.run.playersInventory,
+      v.run.playersInventory,
       player,
       player,
     );
@@ -94,7 +96,7 @@ export class PlayerInventory extends Feature {
     includeActiveCollectibles = true,
   ): CollectibleType[] {
     const inventory = defaultMapGetPlayer(
-      this.v.run.playersInventory,
+      v.run.playersInventory,
       player,
       player,
     );

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

@@ -17,13 +17,15 @@ const FLAGS_WHEN_PONY_IS_ACTIVE = [
   EntityFlag.NO_DAMAGE_BLINK, // 1 << 36
 ] as const;
 
+const v = {
+  run: {
+    playersIsPonyActive: new Set<PlayerIndex>(),
+  },
+};
+
 export class PonyDetection extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      playersIsPonyActive: new Set<PlayerIndex>(),
-    },
-  };
+  public override v = v;
 
   /** @internal */
   constructor() {
@@ -45,7 +47,7 @@ export class PonyDetection extends Feature {
       effects.HasCollectibleEffect(CollectibleType.PONY) ||
       effects.HasCollectibleEffect(CollectibleType.WHITE_PONY);
     const isPonyActiveOnPreviousFrame = setHasPlayer(
-      this.v.run.playersIsPonyActive,
+      v.run.playersIsPonyActive,
       player,
     );
     const hasPonyFlags = hasFlag(entityFlags, ...FLAGS_WHEN_PONY_IS_ACTIVE);
@@ -53,9 +55,9 @@ export class PonyDetection extends Feature {
     const isPonyActiveNow =
       hasPonyCollectibleEffect || (isPonyActiveOnPreviousFrame && hasPonyFlags);
     if (isPonyActiveNow) {
-      setAddPlayer(this.v.run.playersIsPonyActive, player);
+      setAddPlayer(v.run.playersIsPonyActive, player);
     } else {
-      setDeletePlayer(this.v.run.playersIsPonyActive, player);
+      setDeletePlayer(v.run.playersIsPonyActive, player);
     }
   };
 
@@ -67,7 +69,7 @@ export class PonyDetection extends Feature {
    */
   @Exported
   public isPlayerUsingPony(player: EntityPlayer): boolean {
-    return setHasPlayer(this.v.run.playersIsPonyActive, player);
+    return setHasPlayer(v.run.playersIsPonyActive, player);
   }
 
   /**

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

@@ -8,13 +8,15 @@ import { getPlayerIndex } from "../../../functions/playerIndex";
 import { PlayerIndex } from "../../../types/PlayerIndex";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  run: {
+    buttonActionTuples: [] as Array<[PlayerIndex, ButtonAction]>,
+  },
+};
+
 export class PressInput extends Feature {
   /** @internal */
-  public override v = {
-    run: {
-      buttonActionTuples: [] as Array<[PlayerIndex, ButtonAction]>,
-    },
-  };
+  public override v = v;
 
   /** @internal */
   constructor() {
@@ -48,16 +50,16 @@ export class PressInput extends Feature {
 
     const playerIndex = getPlayerIndex(player);
 
-    for (let i = this.v.run.buttonActionTuples.length - 1; i >= 0; i--) {
+    for (let i = v.run.buttonActionTuples.length - 1; i >= 0; i--) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const tuple = this.v.run.buttonActionTuples[i]!;
+      const tuple = v.run.buttonActionTuples[i]!;
       const [tuplePlayerIndex, tupleButtonAction] = tuple;
 
       if (
         tuplePlayerIndex === playerIndex &&
         tupleButtonAction === buttonAction
       ) {
-        this.v.run.buttonActionTuples.splice(i);
+        v.run.buttonActionTuples.splice(i);
         return true;
       }
     }
@@ -75,6 +77,6 @@ export class PressInput extends Feature {
   @Exported
   public pressInput(player: EntityPlayer, buttonAction: ButtonAction): void {
     const playerIndex = getPlayerIndex(player);
-    this.v.run.buttonActionTuples.push([playerIndex, buttonAction]);
+    v.run.buttonActionTuples.push([playerIndex, buttonAction]);
   }
 }

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

@@ -2,13 +2,15 @@ import { ModCallback } from "isaac-typescript-definitions";
 import { Exported } from "../../../decorators";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  room: {
+    preventingEntities: new Set<PtrHash>(),
+  },
+};
+
 export class PreventChildEntities extends Feature {
   /** @internal */
-  public override v = {
-    room: {
-      preventingEntities: new Set<PtrHash>(),
-    },
-  };
+  public override v = v;
 
   /** @internal */
   constructor() {
@@ -24,11 +26,11 @@ export class PreventChildEntities extends Feature {
   private postNPCInit = (npc: EntityNPC) => {
     const spawnerEntityMatch =
       npc.SpawnerEntity !== undefined &&
-      this.v.room.preventingEntities.has(GetPtrHash(npc.SpawnerEntity));
+      v.room.preventingEntities.has(GetPtrHash(npc.SpawnerEntity));
 
     const parentMatch =
       npc.Parent !== undefined &&
-      this.v.room.preventingEntities.has(GetPtrHash(npc.Parent));
+      v.room.preventingEntities.has(GetPtrHash(npc.Parent));
 
     if (spawnerEntityMatch || parentMatch) {
       npc.Remove();
@@ -49,6 +51,6 @@ export class PreventChildEntities extends Feature {
   @Exported
   public preventChildEntities(entity: Entity): void {
     const ptrHash = GetPtrHash(entity);
-    this.v.room.preventingEntities.add(ptrHash);
+    v.room.preventingEntities.add(ptrHash);
   }
 }

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

@@ -11,23 +11,25 @@ import { getEntityID } from "../../../functions/entities";
 import { isCollectible } from "../../../functions/pickupVariants";
 import { Feature } from "../../private/Feature";
 
+const v = {
+  room: {
+    /**
+     * Index is a string containing the grid index and the InitSeed of the collectible.
+     * (e.g. "12,1123579202")
+     *
+     * (We cannot simply use the InitSeed of the collectible because Diplopia can cause multiple
+     * collectibles in the room to have the same InitSeed. However, no two collectibles should ever
+     * be on the same grid index.)
+     *
+     * (We cannot use PtrHash as an index because that stays the same when the item is rolled.)
+     */
+    trackedCollectibles: new Map<string, CollectibleType>(),
+  },
+};
+
 export class PreventCollectibleRotation extends Feature {
   /** @internal */
-  public override v = {
-    room: {
-      /**
-       * Index is a string containing the grid index and the InitSeed of the collectible.
-       * (e.g. "12,1123579202")
-       *
-       * (We cannot simply use the InitSeed of the collectible because Diplopia can cause multiple
-       * collectibles in the room to have the same InitSeed. However, no two collectibles should
-       * ever be on the same grid index.)
-       *
-       * (We cannot use PtrHash as an index because that stays the same when the item is rolled.)
-       */
-      trackedCollectibles: new Map<string, CollectibleType>(),
-    },
-  };
+  public override v = v;
 
   /** @internal */
   constructor() {
@@ -55,7 +57,7 @@ export class PreventCollectibleRotation extends Feature {
   private useCardSoulOfIsaac = () => {
     // Soul of Isaac causes items to flip. Delete all tracked items (assuming that the player
     // deliberately wants to roll a quest item).
-    this.v.room.trackedCollectibles.clear();
+    v.room.trackedCollectibles.clear();
   };
 
   // ModCallback.POST_PICKUP_UPDATE (35)
@@ -73,7 +75,7 @@ export class PreventCollectibleRotation extends Feature {
     }
 
     const index = getMapIndex(collectible);
-    const trackedCollectibleType = this.v.room.trackedCollectibles.get(index);
+    const trackedCollectibleType = v.room.trackedCollectibles.get(index);
     if (
       trackedCollectibleType !== undefined &&
       collectible.SubType !== trackedCollectibleType
@@ -108,7 +110,7 @@ export class PreventCollectibleRotation extends Feature {
     }
 
     const index = getMapIndex(collectible);
-    this.v.room.trackedCollectibles.set(index, collectibleType);
+    v.room.trackedCollectibles.set(index, collectibleType);
 
     // The item might have already shifted on the first frame that it spawns, so change it back if
     // necessary.