isaacscript-common 6.11.2 → 6.12.0

package/src/features/pickupIndex.ts

@@ -0,0 +1,257 @@
+import {
+  EntityType,
+  ModCallback,
+  RoomType,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { getEntityID } from "../functions/entities";
+import { getPickups } from "../functions/entitiesSpecific";
+import { getRoomListIndex } from "../functions/roomData";
+import { onAscent } from "../functions/stage";
+import { vectorEquals } from "../functions/vector";
+import { PickupIndex } from "../types/PickupIndex";
+import { getLatestRoomDescription } from "./roomHistory";
+import { saveDataManager } from "./saveDataManager/exports";
+
+interface PickupDescription {
+  position: Vector;
+  initSeed: Seed;
+}
+
+const FEATURE_NAME = "pickupIndex";
+
+const v = {
+  run: {
+    pickupCounter: 0 as PickupIndex,
+    currentRoomListIndex: 0,
+
+    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 function pickupIndexInit(mod: ModUpgraded): void {
+  saveDataManager(FEATURE_NAME, v);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_INIT, postPickupInit); // 34
+  mod.AddCallback(
+    ModCallback.POST_ENTITY_REMOVE,
+    postEntityRemovePickup,
+    EntityType.PICKUP,
+  ); // 67
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
+    postNewRoomReordered,
+  );
+}
+
+// ModCallback.POST_PICKUP_INIT (34)
+function postPickupInit(pickup: EntityPickup) {
+  const ptrHash = GetPtrHash(pickup);
+
+  // In certain situations, pickups can be morphed, and this should not incur a new pickup counter.
+  // (For example, the collectible rotation with Tainted Isaac.)
+  if (v.room.pickupIndexes.has(ptrHash)) {
+    return;
+  }
+
+  // If we are re-entering a room that previously had a pickup, then we don't need to make a new
+  // index, because we will re-use the existing one.
+  const room = game.GetRoom();
+  const isFirstVisit = room.IsFirstVisit();
+  const roomFrameCount = room.GetFrameCount();
+  if (!isFirstVisit && roomFrameCount <= 0) {
+    return;
+  }
+
+  v.run.pickupCounter++;
+  v.room.pickupIndexes.set(ptrHash, v.run.pickupCounter);
+
+  // Additionally, keep track of which room we are storing the pointer hashes for.
+  v.run.currentRoomListIndex = getRoomListIndex();
+}
+
+// ModCallback.POST_ENTITY_REMOVE (67)
+// EntityType.PICKUP (5)
+function postEntityRemovePickup(entity: Entity) {
+  checkDespawningFromPlayerLeavingRoom(entity);
+}
+
+function checkDespawningFromPlayerLeavingRoom(entity: Entity) {
+  const ptrHash = GetPtrHash(entity);
+  const pickupIndex = v.room.pickupIndexes.get(ptrHash);
+  if (pickupIndex === undefined) {
+    return;
+  }
+
+  const roomListIndex = getRoomListIndex();
+  if (roomListIndex === v.run.currentRoomListIndex) {
+    // This is a pickup that is despawning in the current room. For example, it could be a heart
+    // pickup that the player picked up. Thus, we do not need to keep track of it's metadata.
+    return;
+  }
+
+  trackDespawningPickupMetadata(entity, pickupIndex);
+}
+
+/**
+ * This is a pickup that is despawning because the player is in the process of leaving the room.
+ * Keep track of the metadata for later. We need to use the previous room list index because even
+ * though the `POST_NEW_ROOM` callback was not fired yet, we have already traveled to the next room.
+ */
+function trackDespawningPickupMetadata(
+  entity: Entity,
+  pickupIndex: PickupIndex,
+) {
+  const previousRoomDescription = getLatestRoomDescription();
+  const previousRoomListIndex = previousRoomDescription.roomListIndex;
+  const pickupDescriptions = v.level.pickupData.getAndSetDefault(
+    previousRoomListIndex,
+  );
+
+  const pickupDescription: PickupDescription = {
+    position: entity.Position,
+    initSeed: entity.InitSeed,
+  };
+  pickupDescriptions.set(pickupIndex, pickupDescription);
+
+  // If the despawning pickup was in a Treasure Room or Boss Room, then it is possible that the
+  // pickup could re-appear during The Ascent. If this is the case, we store the metadata on a
+  // separate map to reference later.
+  if (onAscent()) {
+    return;
+  }
+
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+
+  switch (roomType) {
+    case RoomType.TREASURE: {
+      v.run.pickupDataTreasureRooms.set(pickupIndex, pickupDescription);
+      break;
+    }
+
+    case RoomType.BOSS: {
+      v.run.pickupDataBossRooms.set(pickupIndex, pickupDescription);
+      break;
+    }
+
+    default: {
+      break;
+    }
+  }
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+  const room = game.GetRoom();
+  const isFirstVisit = room.IsFirstVisit();
+
+  if (isFirstVisit) {
+    return;
+  }
+
+  const roomListIndex = getRoomListIndex();
+  const pickupDescriptions = v.level.pickupData.getAndSetDefault(roomListIndex);
+
+  for (const pickup of getPickups()) {
+    let pickupIndex = getStoredPickupIndex(pickup, pickupDescriptions);
+    if (pickupIndex === undefined) {
+      pickupIndex = getPostAscentPickupIndex(pickup);
+    }
+
+    if (pickupIndex === undefined) {
+      const entityID = getEntityID(pickup);
+      error(
+        `Failed to find a pickup index corresponding to existing pickup: ${entityID}`,
+      );
+    }
+
+    const ptrHash = GetPtrHash(pickup);
+    v.room.pickupIndexes.set(ptrHash, pickupIndex);
+  }
+}
+
+function getStoredPickupIndex(
+  pickup: Entity,
+  pickupDescriptions: Map<PickupIndex, PickupDescription>,
+): PickupIndex | undefined {
+  for (const [pickupIndex, pickupDescription] of pickupDescriptions.entries()) {
+    if (
+      vectorEquals(pickupDescription.position, pickup.Position) &&
+      pickupDescription.initSeed === pickup.InitSeed
+    ) {
+      return pickupIndex;
+    }
+  }
+
+  return undefined;
+}
+
+function getPostAscentPickupIndex(pickup: EntityPickup) {
+  // If we have not found the pickup index yet, we might be re-entering a post-Ascent Treasure Room
+  // or Boss Room.
+  if (!onAscent()) {
+    return undefined;
+  }
+
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+
+  switch (roomType) {
+    case RoomType.TREASURE: {
+      return getStoredPickupIndex(pickup, v.run.pickupDataTreasureRooms);
+    }
+
+    case RoomType.BOSS: {
+      return getStoredPickupIndex(pickup, v.run.pickupDataBossRooms);
+    }
+
+    default: {
+      return undefined;
+    }
+  }
+}
+
+/**
+ * Mods often have to track variables relating to a pickups. Finding an index for these kinds of
+ * data structures is difficult, since pickups are respawned every time a player re-enters a room,
+ * so the `PtrHash` will change.
+ *
+ * Use this function to get a unique index for a pickup to use in these data structures.
+ *
+ * Specifically, `PickupIndex` is a number that represents the spawn order of the pickup on the
+ * current run. For example, the first pickup spawned will have an index of 1, the second one will
+ * have an index of 2, and so on.
+ *
+ * Tracking pickups requires stateful tracking, so using pickup indexes requires an upgraded mod.
+ */
+export function getPickupIndex(pickup: EntityPickup): PickupIndex {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  const ptrHash = GetPtrHash(pickup);
+  const pickupIndex = v.room.pickupIndexes.get(ptrHash);
+  if (pickupIndex === undefined) {
+    const entityID = getEntityID(pickup);
+    error(
+      `Failed to get a pickup index for entity ${entityID} with hash: ${ptrHash}`,
+    );
+  }
+
+  return pickupIndex;
+}

package/src/features/playerInventory.ts

@@ -76,8 +76,8 @@ function useItemD4(
 
 // ModCallback.POST_GAME_STARTED (15)
 function postGameStarted() {
-  // We don't use the PostPlayerInit callback because some items are not given to the player at that
-  // point.
+  // We don't use the `POST_PLAYER_INIT` callback because some items are not given to the player at
+  // that point.
   for (const player of getAllPlayers()) {
     const playerIndex = getPlayerIndex(player);
     if (!v.run.playersInventory.has(playerIndex)) {

package/src/features/roomHistory.ts

@@ -0,0 +1,113 @@
+import { game } from "../cachedClasses";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { getLastElement } from "../functions/array";
+import {
+  getRoomGridIndex,
+  getRoomListIndex,
+  getRoomName,
+  getRoomStageID,
+  getRoomSubType,
+  getRoomVariant,
+} from "../functions/roomData";
+import { RoomDescription } from "../interfaces/RoomDescription";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "roomHistory";
+
+const v = {
+  run: {
+    roomHistory: [] as RoomDescription[],
+  },
+};
+
+/** @internal */
+export function roomHistoryInit(mod: ModUpgraded): void {
+  saveDataManager(FEATURE_NAME, v);
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_EARLY,
+    postNewRoomEarly,
+  );
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_EARLY
+function postNewRoomEarly() {
+  const level = game.GetLevel();
+  const stage = level.GetStage();
+  const stageType = level.GetStageType();
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const stageID = getRoomStageID();
+  const roomVariant = getRoomVariant();
+  const roomSubType = getRoomSubType();
+  const roomName = getRoomName();
+  const roomGridIndex = getRoomGridIndex();
+  const roomListIndex = getRoomListIndex();
+
+  const roomDescription: RoomDescription = {
+    stage,
+    stageType,
+    stageID,
+    roomType,
+    roomVariant,
+    roomSubType,
+    roomName,
+    roomGridIndex,
+    roomListIndex,
+  };
+  v.run.roomHistory.push(roomDescription);
+}
+
+/**
+ * Helper function to get information about all of the rooms that a player has visited thus far on
+ * this run.
+ */
+export function getRoomHistory(): readonly RoomDescription[] {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  return v.run.roomHistory;
+}
+
+/**
+ * Helper function to get information about the room that was previously visited.
+ *
+ * In the special case of only one room having been visited thus far (i.e. the starting room of the
+ * run), the starting room will be returned.
+ */
+export function getPreviousRoomDescription(): RoomDescription {
+  const previousRoomDescription =
+    v.run.roomHistory[v.run.roomHistory.length - 2];
+  if (previousRoomDescription !== undefined) {
+    return previousRoomDescription;
+  }
+
+  const startingRoomDescription = v.run.roomHistory[0];
+  if (startingRoomDescription !== undefined) {
+    return startingRoomDescription;
+  }
+
+  error(
+    "Failed to find a room description for any rooms thus far on this run.",
+  );
+}
+
+/**
+ * Helper function to get information about the most recent room that is stored in the room history
+ * array.
+ *
+ * This is useful in the `POST_ENTITY_REMOVE` callback, since if an entity is despawning due to a
+ * player having left the room, the current room will have changed already, but the `POST_NEW_ROOM`
+ * callback will not have fired yet, and there will not be an entry in the room history array for
+ * the current room.
+ */
+export function getLatestRoomDescription(): RoomDescription {
+  const latestRoomDescription = getLastElement(v.run.roomHistory);
+  if (latestRoomDescription === undefined) {
+    error(
+      "Failed to get the latest room description since the room history array was empty.",
+    );
+  }
+
+  return latestRoomDescription;
+}

package/src/features/saveDataManager/main.ts

@@ -65,8 +65,8 @@ function postPlayerInit() {
     restoreDefaultsAll();
   }
 
-  // On continued runs, the PostNewLevel callback will not fire, so we do not have to worry about
-  // saved data based on level getting overwritten.
+  // On continued runs, the `POST_NEW_LEVEL` callback will not fire, so we do not have to worry
+  // about saved data based on level getting overwritten.
 }
 
 // ModCallback.PRE_GAME_EXIT (17)

package/src/features/taintedLazarusPlayers.ts

@@ -58,11 +58,11 @@ function postPlayerInit(player: EntityPlayer) {
 /**
  * Indexes are the `PtrHash`, values are the `EntityPtr` of the *other* Lazarus.
  *
- * When starting a run, the PostPlayerInit callback will fire first for Dead Tainted Lazarus, then
- * for Tainted Lazarus. When continuing a run, the PostPlayerInit callback will fire first for the
- * character that is currently active. Thus, since the order of the characters is not certain, we
- * insert each of their pointers into a queue, and then only populate the map when we have one
- * Tainted Lazarus and one Dead Tainted Lazarus.
+ * When starting a run, the `POST_PLAYER_INIT` callback will fire first for Dead Tainted Lazarus,
+ * then for Tainted Lazarus. When continuing a run, the `POST_PLAYER_INIT` callback will fire first
+ * for the character that is currently active. Thus, since the order of the characters is not
+ * certain, we insert each of their pointers into a queue, and then only populate the map when we
+ * have one Tainted Lazarus and one Dead Tainted Lazarus.
  */
 function checkDequeue() {
   if (

package/src/functions/collectibles.ts

@@ -176,38 +176,51 @@ export function getCollectibleGfxFilename(
 }
 
 /**
- * Mods often have to track variables relating to a collectible. Finding an index for these kinds of
- * data structures is difficult, since collectibles are respawned every time a player re-enters a
- * room, so the `PtrHash` will change. Instead, we use a 4-tuple of the room list index, the grid
- * index of the collectible in the room, the collectible's SubType, and the collectible's InitSeed.
+ * Mods may have to keep track of data relating to a collectible. Finding an index for these kinds
+ * of data structures is difficult, since collectibles are respawned every time a player re-enters a
+ * room (like all other pickups), so the `PtrHash` will change.
+ *
+ * Use this function to get a unique index for a collectible to use in these data structures.
+ *
+ * If your mod is upgraded, then you should use the `getPickupIndex` function instead, as it is more
+ * general purpose and less prone to error (but relies on stateful tracking of pickups as the run
+ * progresses).
+ *
+ * Collectibles are a special case of pickups: they cannot be pushed around. (They actually can be
+ * pushed, but usually will stay on the same grid index.) Thus, it is possible to generate a
+ * somewhat reliable non-stateful index for collectibles. We use a 4-tuple of the room list index,
+ * the grid index of the collectible in the room, the collectible's `SubType`, and the collectible's
+ * `InitSeed`.
  *
  * Collectibles that are shifted by Tainted Isaac's mechanic will have unique collectible indexes
- * because the SubType is different. (The collectible entities share the same InitSeed.)
+ * because the `SubType` is different. (The collectible entities share the same `InitSeed` and
+ * `PtrHash`.)
  *
  * Collectibles that are rolled (with e.g. a D6) will have unique collectible indexes because the
- * SubType and InitSeed are different. If you want to track collectibles independently of any
+ * `SubType` and `InitSeed` are different. If you want to track collectibles independently of any
  * rerolls, then you can use the `PtrHash` as an index instead. (The `PtrHash` will not persist
  * between rooms, however.)
  *
  * Note that:
  * - The grid index is a necessary part of the collectible index because Diplopia and Crooked Penny
- *   can cause two or more collectibles with the same SubType and InitSeed to exist in the same
+ *   can cause two or more collectibles with the same `SubType` and `InitSeed` to exist in the same
  *   room.
  * - This index will fail in the case where the player uses Diplopia or a successful Crooked Penny
  *   seven or more times in the same room, since that will cause two or more collectibles with the
- *   same grid index, SubType, and InitSeed to exist.
- * - The SubType is a necessary part of the collectible index because Tainted Isaac will
- *   continuously cause collectibles to morph into new sub-types with the same InitSeed.
+ *   same grid index, `SubType`, and `InitSeed` to exist. (More than seven is required in non-1x1
+ *   rooms.)
+ * - The `SubType` is a necessary part of the collectible index because Tainted Isaac will
+ *   continuously cause collectibles to morph into new sub-types with the same `InitSeed`.
  * - Using a collectible's position as part of the index is problematic, since players can push a
  *   pedestal. (Even using the grid index does not solve this problem, since it is possible in
  *   certain cases for collectibles to be spawned at a position that is not aligned with the grid,
  *   and the pedestal pushed to an adjacent tile, but this case should be extremely rare.)
  * - Mega Chests spawn two collectibles on the exact same position. However, both of them will have
- *   different InitSeeds, so this is not a problem for this indexing scheme.
+ *   a different `InitSeed`, so this is not a problem for this indexing scheme.
  * - The indexing scheme used is different for collectibles that are inside of a Treasure Room or
  *   Boss Room, in order to handle the case of the player seeing the same collectible again in a
- *   post-Ascent Treasure Room or Boss Room. A 5-tuple of stage, stage type, grid index, SubType,
- *   and InitSeed is used in this case. (Using the room list index or the room grid index is not
+ *   post-Ascent Treasure Room or Boss Room. A 5-tuple of stage, stage type, grid index, `SubType`,
+ *   and `InitSeed` is used in this case. (Using the room list index or the room grid index is not
  *   suitable for this purpose, since both of these values can change in the post-Ascent rooms.)
  *   Even though Treasure Rooms and Boss Rooms are grouped together in this scheme, there probably
  *   will not be collectibles with the same grid index, SubType, and InitSeed.

package/src/functions/entities.ts

@@ -7,6 +7,7 @@ import { getIsaacAPIClassName } from "./isaacAPIClass";
 import { getRandom } from "./random";
 import { isRNG, newRNG } from "./rng";
 import { isPrimitive } from "./types";
+import { isVector, vectorToString } from "./vector";
 
 /**
  * Helper function to count the number of entities in room. Use this over the vanilla
@@ -130,10 +131,10 @@ export function getEntities(
 
 /**
  * Helper function to get all the fields on an entity. For example, this is useful for comparing it
- * to another entity later.
+ * to another entity later. (One option is to use the `logTableDifferences` function for this.)
  *
- * This function will only get fields that are equal to booleans, numbers, or strings, as comparing
- * other types is non-trivial.
+ * This function will only get fields that are equal to booleans, numbers, or strings, or Vectors,
+ * as comparing other types is non-trivial.
  */
 export function getEntityFields(
   entity: Entity,
@@ -187,6 +188,8 @@ function setPrimitiveEntityFields(
     const value = entity[indexKey];
     if (isPrimitive(value)) {
       entityFields.set(indexKey, value);
+    } else if (isVector(value)) {
+      entityFields.set(indexKey, vectorToString(value));
     }
   }
 }

package/src/functions/gridEntities.ts

@@ -95,8 +95,8 @@ export function getAllGridIndexes(): int[] {
  * Gets the entities that have a hitbox that overlaps with any part of the square that the grid
  * entity is on.
  *
- * Note that this function will not work properly in the PostNewRoom callback, since entities do not
- * have collision yet in that callback.
+ * Note that this function will not work properly in the `POST_NEW_ROOM` callback, since entities do
+ * not have collision yet in that callback.
  */
 export function getCollidingEntitiesWithGridEntity(
   gridEntity: GridEntity,

package/src/functions/isaacAPIClass.ts

@@ -1,4 +1,5 @@
 import { IsaacAPIClass } from "../types/private/IsaacAPIClass";
+import { trimPrefix } from "./string";
 import { isString, isUserdata } from "./types";
 
 /**
@@ -9,6 +10,10 @@ import { isString, isUserdata } from "./types";
  *
  * Returns undefined if the object is not of type `userdata` or if the "__type" metatable key does
  * not exist.
+ *
+ * In some cases, Isaac classes can be a read-only. If this is the case, the "__type" field will be
+ * prepended with "const ". This function will always strip this prefix, if it exists. For example,
+ * the class name returned for "const Vector" will be "Vector".
  */
 export function getIsaacAPIClassName(object: unknown): string | undefined {
   if (!isUserdata(object)) {
@@ -27,7 +32,40 @@ export function getIsaacAPIClassName(object: unknown): string | undefined {
     return undefined;
   }
 
-  return classType;
+  return trimPrefix(classType, "const ");
+}
+
+/** Helper function to detect if a variable is of type `EntityBomb`. */
+export function isBomb(variable: unknown): variable is EntityBomb {
+  return getIsaacAPIClassName(variable) === "EntityBomb";
+}
+
+/** Helper function to detect if a variable is of type `GridEntityDoor`. */
+export function isDoor(variable: unknown): variable is GridEntityDoor {
+  return getIsaacAPIClassName(variable) === "GridEntityDoor";
+}
+
+/** Helper function to detect if a variable is of type `EntityEffect`. */
+export function isEffect(variable: unknown): variable is EntityEffect {
+  return getIsaacAPIClassName(variable) === "EntityEffect";
+}
+
+/**
+ * Helper function to detect if a variable is of type `Entity`. This will return false for child
+ * classes such as `EntityPlayer` or `EntityTear`.
+ */
+export function isEntity(variable: unknown): variable is Entity {
+  return getIsaacAPIClassName(variable) === "Entity";
+}
+
+/** Helper function to detect if a variable is of type `EntityEffect`. */
+export function isFamiliar(variable: unknown): variable is EntityFamiliar {
+  return getIsaacAPIClassName(variable) === "EntityEffect";
+}
+
+/** Helper function to detect if a variable is of type `GridEntity`. */
+export function isGridEntity(variable: unknown): variable is GridEntity {
+  return getIsaacAPIClassName(variable) === "GridEntity";
 }
 
 /**
@@ -51,6 +89,73 @@ export function isIsaacAPIClassOfType(
   );
 }
 
+/** Helper function to detect if a variable is of type `EntityKnife`. */
+export function isKnife(variable: unknown): variable is EntityKnife {
+  return getIsaacAPIClassName(variable) === "EntityKnife";
+}
+
+/** Helper function to detect if a variable is of type `EntityLaser`. */
+export function isLaser(variable: unknown): variable is EntityLaser {
+  return getIsaacAPIClassName(variable) === "EntityLaser";
+}
+
+/** Helper function to detect if a variable is of type `EntityNPC`. */
+export function isNPC(variable: unknown): variable is EntityNPC {
+  return getIsaacAPIClassName(variable) === "EntityNPC";
+}
+
+/** Helper function to detect if a variable is of type `EntityPickup`. */
+export function isPickup(variable: unknown): variable is EntityPickup {
+  return getIsaacAPIClassName(variable) === "EntityPickup";
+}
+
+/** Helper function to detect if a variable is of type `GridEntityPit`. */
+export function isPit(variable: unknown): variable is GridEntityPit {
+  return getIsaacAPIClassName(variable) === "GridEntityPit";
+}
+
+/** Helper function to detect if a variable is of type `EntityPlayer`. */
+export function isPlayer(variable: unknown): variable is EntityPlayer {
+  return getIsaacAPIClassName(variable) === "EntityPlayer";
+}
+
+/** Helper function to detect if a variable is of type `GridEntityPoop`. */
+export function isPoop(variable: unknown): variable is GridEntityPoop {
+  return getIsaacAPIClassName(variable) === "GridEntityPoop";
+}
+
+/** Helper function to detect if a variable is of type `GridEntityPressurePlate`. */
+export function isPressurePlate(
+  variable: unknown,
+): variable is GridEntityPressurePlate {
+  return getIsaacAPIClassName(variable) === "GridEntityPressurePlate";
+}
+
+/** Helper function to detect if a variable is of type `EntityProjectile`. */
+export function isProjectile(variable: unknown): variable is EntityProjectile {
+  return getIsaacAPIClassName(variable) === "EntityProjectile";
+}
+
+/** Helper function to detect if a variable is of type `GridEntityRock`. */
+export function isRock(variable: unknown): variable is GridEntityRock {
+  return getIsaacAPIClassName(variable) === "GridEntityRock";
+}
+
+/** Helper function to detect if a variable is of type `GridEntitySpikes`. */
+export function isSpikes(variable: unknown): variable is GridEntitySpikes {
+  return getIsaacAPIClassName(variable) === "GridEntitySpikes";
+}
+
+/** Helper function to detect if a variable is of type `GridEntityTNT`. */
+export function isTNT(variable: unknown): variable is GridEntityTNT {
+  return getIsaacAPIClassName(variable) === "GridEntityTNT";
+}
+
+/** Helper function to detect if a variable is of type `EntityTear`. */
+export function isTear(variable: unknown): variable is EntityTear {
+  return getIsaacAPIClassName(variable) === "EntityTear";
+}
+
 /**
  * Helper function to check if an instantiated Isaac API class is equal to another one of the same
  * type. You must provide the list of keys to check for.

package/src/functions/pickupVariants.ts

@@ -18,12 +18,12 @@ export function isKey(pickup: EntityPickup): pickup is EntityPickupKey {
 }
 
 /** For `PickupVariant.BOMB` (40) */
-export function isBomb(pickup: EntityPickup): pickup is EntityPickupBomb {
+export function isBombPickup(pickup: EntityPickup): pickup is EntityPickupBomb {
   return pickup.Variant === PickupVariant.BOMB;
 }
 
 /** For `PickupVariant.POOP` (42) */
-export function isPoop(pickup: EntityPickup): pickup is EntityPickupPoop {
+export function isPoopPickup(pickup: EntityPickup): pickup is EntityPickupPoop {
   return pickup.Variant === PickupVariant.POOP;
 }