isaacscript-common 6.6.1-dev.0 → 6.6.1-dev.4

package/src/functions/nextStage.ts

@@ -0,0 +1,419 @@
+import {
+  GameStateFlag,
+  GridRoom,
+  LevelStage,
+  StageType,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { hasVisitedStage } from "../features/stageHistory";
+import { areFeaturesInitialized } from "../featuresInitialized";
+import { getRoomGridIndex } from "./roomData";
+import {
+  calculateStageType,
+  calculateStageTypeRepentance,
+  onRepentanceStage,
+} from "./stage";
+
+/**
+ * Helper function to get the stage that a trapdoor or heaven door would take the player to, based
+ * on the current stage, room, and game state flags.
+ *
+ * Note that in non-upgraded mods, this function will not account for the player having visited
+ * Repentance floors in The Ascent. (Handling this requires stateful tracking as the player
+ * progresses through the run.)
+ */
+export function getNextStage(): LevelStage {
+  const level = game.GetLevel();
+  const backwardsPath = game.GetStateFlag(GameStateFlag.BACKWARDS_PATH);
+  const mausoleumHeartKilled = game.GetStateFlag(
+    GameStateFlag.MAUSOLEUM_HEART_KILLED,
+  );
+  const stage = level.GetStage();
+  const repentanceStage = onRepentanceStage();
+  const roomGridIndex = getRoomGridIndex();
+
+  // First, handle the special case of being on the backwards path.
+  if (backwardsPath) {
+    return getNextStageBackwardsPath(stage, repentanceStage);
+  }
+
+  // Second, handle the special case of being in a specific off-grid room.
+  switch (roomGridIndex) {
+    // -8
+    case GridRoom.BLUE_WOMB: {
+      return LevelStage.BLUE_WOMB;
+    }
+
+    // -9
+    case GridRoom.THE_VOID: {
+      return LevelStage.THE_VOID;
+    }
+
+    // -10
+    case GridRoom.SECRET_EXIT: {
+      if (repentanceStage) {
+        // e.g. From Downpour 2 to Mines 1, etc.
+        return (stage as int) + 1;
+      }
+
+      if (stage === LevelStage.DEPTHS_2) {
+        // From Depths 2 to Mausoleum 2 through the strange door.
+        return LevelStage.DEPTHS_2;
+      }
+
+      // e.g. From Basement 1 to Downpour 1, from Basement 2 to Downpour 2, etc.
+      return stage;
+    }
+  }
+
+  // 2
+  if (repentanceStage && stage === LevelStage.BASEMENT_2) {
+    // From Downpour 2 to Caves 2.
+    return LevelStage.CAVES_2;
+  }
+
+  // 4
+  if (repentanceStage && stage === LevelStage.CAVES_2) {
+    // From Mines 2 to Depths 2.
+    return LevelStage.DEPTHS_2;
+  }
+
+  // 6
+  if (repentanceStage && stage === LevelStage.DEPTHS_2) {
+    if (mausoleumHeartKilled) {
+      // From Mausoleum 2 to Corpse 1.
+      return LevelStage.WOMB_1;
+    }
+
+    // From Mausoleum 2 to Womb 2.
+    return LevelStage.WOMB_2;
+  }
+
+  // 8
+  if (stage === LevelStage.WOMB_2) {
+    // From Womb 2 to Sheol or Cathedral.
+    return LevelStage.SHEOL_CATHEDRAL;
+  }
+
+  // 11
+  if (stage === LevelStage.DARK_ROOM_CHEST) {
+    // - The Chest goes to The Chest.
+    // - The Dark Room goes to the Dark Room.
+    return LevelStage.DARK_ROOM_CHEST;
+  }
+
+  // 12
+  if (stage === LevelStage.THE_VOID) {
+    // The Void goes to The Void.
+    return LevelStage.THE_VOID;
+  }
+
+  // By default, go to the next floor.
+  return (stage as int) + 1;
+}
+
+function getNextStageBackwardsPath(
+  stage: LevelStage,
+  repentanceStage: boolean,
+): LevelStage {
+  // If we have no stage history to work with, then default to the previous stage.
+  if (!areFeaturesInitialized()) {
+    return (stage as int) - 1;
+  }
+
+  const visitedDownpour1 = hasVisitedStage(
+    LevelStage.BASEMENT_1,
+    StageType.REPENTANCE,
+  );
+  const visitedDross1 = hasVisitedStage(
+    LevelStage.BASEMENT_1,
+    StageType.REPENTANCE_B,
+  );
+  const visitedDownpour2 = hasVisitedStage(
+    LevelStage.BASEMENT_2,
+    StageType.REPENTANCE,
+  );
+  const visitedDross2 = hasVisitedStage(
+    LevelStage.BASEMENT_2,
+    StageType.REPENTANCE_B,
+  );
+  const visitedMines1 = hasVisitedStage(
+    LevelStage.CAVES_1,
+    StageType.REPENTANCE,
+  );
+  const visitedAshpit1 = hasVisitedStage(
+    LevelStage.CAVES_1,
+    StageType.REPENTANCE_B,
+  );
+  const visitedMines2 = hasVisitedStage(
+    LevelStage.DEPTHS_2,
+    StageType.REPENTANCE,
+  );
+  const visitedAshpit2 = hasVisitedStage(
+    LevelStage.DEPTHS_2,
+    StageType.REPENTANCE_B,
+  );
+
+  if (stage === LevelStage.BASEMENT_1) {
+    if (repentanceStage) {
+      // From Downpour 1 to Basement 1.
+      return LevelStage.BASEMENT_1;
+    }
+
+    // From Basement 1 to Home.
+    return LevelStage.HOME;
+  }
+
+  if (stage === LevelStage.BASEMENT_2) {
+    if (repentanceStage) {
+      if (visitedDownpour1 || visitedDross1) {
+        // From Downpour 2 to Downpour 1.
+        return LevelStage.BASEMENT_1;
+      }
+
+      // From Downpour 2 to Basement 2.
+      return LevelStage.BASEMENT_2;
+    }
+
+    // From Basement 2 to Basement 1.
+    return LevelStage.BASEMENT_1;
+  }
+
+  if (stage === LevelStage.CAVES_1) {
+    if (repentanceStage) {
+      if (visitedDownpour2 || visitedDross2) {
+        // From Mines 1 to Downpour 1.
+        return LevelStage.BASEMENT_2;
+      }
+
+      // From Mines 1 to Caves 1.
+      return LevelStage.CAVES_1;
+    }
+
+    // From Caves 1 to Basement 2.
+    return LevelStage.BASEMENT_2;
+  }
+
+  if (stage === LevelStage.CAVES_2) {
+    if (repentanceStage) {
+      if (visitedMines1 || visitedAshpit1) {
+        // From Mines 2 to Mines 1.
+        return LevelStage.CAVES_1;
+      }
+
+      // From Mines 2 to Caves 2.
+      return LevelStage.CAVES_2;
+    }
+
+    // From Caves 2 to Caves 1.
+    return LevelStage.CAVES_1;
+  }
+
+  if (stage === LevelStage.DEPTHS_1) {
+    if (repentanceStage) {
+      if (visitedMines2 || visitedAshpit2) {
+        // From Mausoleum 1 to Mines 2.
+        return LevelStage.CAVES_2;
+      }
+
+      // From Mausoleum 1 to Depths 1.
+      return LevelStage.DEPTHS_1;
+    }
+
+    // From Depths 1 to Caves 2.
+    return LevelStage.CAVES_2;
+  }
+
+  if (stage === LevelStage.DEPTHS_2) {
+    if (repentanceStage) {
+      // From Mausoleum 2 to Depths 2.
+      return LevelStage.DEPTHS_2;
+    }
+
+    // From Depths 2 to Depths 1.
+    return LevelStage.DEPTHS_1;
+  }
+
+  return (stage as int) - 1;
+}
+
+/**
+ * Helper function to get the stage type that a trapdoor or heaven door would take the player to,
+ * based on the current stage, room, and game state flags.
+ *
+ * @param upwards Whether or not the player should go up to Cathedral in the case of being on Womb
+ *                2. Default is false.
+ */
+export function getNextStageType(upwards = false): StageType {
+  const backwardsPath = game.GetStateFlag(GameStateFlag.BACKWARDS_PATH);
+  const mausoleumHeartKilled = game.GetStateFlag(
+    GameStateFlag.MAUSOLEUM_HEART_KILLED,
+  );
+  const level = game.GetLevel();
+  const stage = level.GetStage();
+  const stageType = level.GetStageType();
+  const repentanceStage = onRepentanceStage();
+  const roomGridIndex = getRoomGridIndex();
+  const nextStage = getNextStage();
+
+  // First, handle the special case of being on the backwards path.
+  if (backwardsPath) {
+    return getStageTypeBackwardsPath(stage, nextStage, repentanceStage);
+  }
+
+  // Second, handle the special case of being in a specific off-grid room.
+  if (roomGridIndex === (GridRoom.SECRET_EXIT as int)) {
+    return calculateStageTypeRepentance(nextStage);
+  }
+
+  if (
+    repentanceStage &&
+    (stage === LevelStage.BASEMENT_1 || // 1
+      stage === LevelStage.CAVES_1 || // 3
+      stage === LevelStage.DEPTHS_1 || // 5
+      stage === LevelStage.WOMB_1) // 7
+  ) {
+    return calculateStageTypeRepentance(nextStage);
+  }
+
+  if (
+    repentanceStage &&
+    stage === LevelStage.DEPTHS_2 &&
+    mausoleumHeartKilled
+  ) {
+    return calculateStageTypeRepentance(nextStage);
+  }
+
+  // 9
+  if (nextStage === LevelStage.BLUE_WOMB) {
+    // Blue Womb does not have any alternate floors.
+    return StageType.ORIGINAL;
+  }
+
+  // 10
+  if (nextStage === LevelStage.SHEOL_CATHEDRAL) {
+    if (upwards) {
+      // Go to Cathedral (10.1).
+      return StageType.WRATH_OF_THE_LAMB;
+    }
+
+    // Go to Sheol (10.0).
+    return StageType.ORIGINAL;
+  }
+
+  // 11
+  if (nextStage === LevelStage.DARK_ROOM_CHEST) {
+    if (stageType === StageType.ORIGINAL) {
+      // Sheol (10.0) goes to the Dark Room (11.0).
+      return StageType.ORIGINAL;
+    }
+
+    // Cathedral (10.1) goes to The Chest (11.1).
+    return StageType.WRATH_OF_THE_LAMB;
+  }
+
+  // 12
+  if (nextStage === LevelStage.THE_VOID) {
+    // The Void does not have any alternate floors.
+    return StageType.ORIGINAL;
+  }
+
+  // 13
+  if (nextStage === LevelStage.HOME) {
+    // Home does not have any alternate floors.
+    return StageType.ORIGINAL;
+  }
+
+  return calculateStageType(nextStage);
+}
+
+function getStageTypeBackwardsPath(
+  stage: LevelStage,
+  nextStage: LevelStage,
+  repentanceStage: boolean,
+): StageType {
+  const visitedDownpour1 = hasVisitedStage(
+    LevelStage.BASEMENT_1,
+    StageType.REPENTANCE,
+  );
+  const visitedDross1 = hasVisitedStage(
+    LevelStage.BASEMENT_1,
+    StageType.REPENTANCE_B,
+  );
+  const visitedDownpour2 = hasVisitedStage(
+    LevelStage.BASEMENT_2,
+    StageType.REPENTANCE,
+  );
+  const visitedDross2 = hasVisitedStage(
+    LevelStage.BASEMENT_2,
+    StageType.REPENTANCE_B,
+  );
+  const visitedMines1 = hasVisitedStage(
+    LevelStage.CAVES_1,
+    StageType.REPENTANCE,
+  );
+  const visitedAshpit1 = hasVisitedStage(
+    LevelStage.CAVES_1,
+    StageType.REPENTANCE_B,
+  );
+  const visitedMines2 = hasVisitedStage(
+    LevelStage.DEPTHS_2,
+    StageType.REPENTANCE,
+  );
+  const visitedAshpit2 = hasVisitedStage(
+    LevelStage.DEPTHS_2,
+    StageType.REPENTANCE_B,
+  );
+
+  if (stage === LevelStage.BASEMENT_2 && repentanceStage) {
+    if (visitedDownpour1) {
+      return StageType.REPENTANCE;
+    }
+
+    if (visitedDross1) {
+      return StageType.REPENTANCE_B;
+    }
+  }
+
+  if (stage === LevelStage.CAVES_1 && repentanceStage) {
+    if (visitedDownpour2) {
+      return StageType.REPENTANCE;
+    }
+
+    if (visitedDross2) {
+      return StageType.REPENTANCE_B;
+    }
+  }
+
+  if (stage === LevelStage.CAVES_2 && !repentanceStage) {
+    if (visitedDownpour2) {
+      return StageType.REPENTANCE;
+    }
+
+    if (visitedDross2) {
+      return StageType.REPENTANCE_B;
+    }
+  }
+
+  if (stage === LevelStage.CAVES_2 && repentanceStage) {
+    if (visitedMines1) {
+      return StageType.REPENTANCE;
+    }
+
+    if (visitedAshpit1) {
+      return StageType.REPENTANCE_B;
+    }
+  }
+
+  if (stage === LevelStage.DEPTHS_2 && !repentanceStage) {
+    if (visitedAshpit2) {
+      return StageType.REPENTANCE_B;
+    }
+
+    if (visitedMines2) {
+      return StageType.REPENTANCE;
+    }
+  }
+
+  return calculateStageType(nextStage);
+}

package/src/functions/npc.ts

@@ -0,0 +1,148 @@
+import {
+  BegottenVariant,
+  BigHornVariant,
+  ChargerSubType,
+  ChargerVariant,
+  DarkEsauVariant,
+  DeathVariant,
+  EntityType,
+  MamaGurdyVariant,
+  MotherSubType,
+  MotherVariant,
+  NpcState,
+  PeepVariant,
+  ProjectilesMode,
+  RaglingVariant,
+  VisVariant,
+} from "isaac-typescript-definitions";
+import { EGGY_STATE_FRAME_OF_FINAL_SPIDER } from "../constants";
+import { getFilteredNewEntities } from "./entity";
+import { getNPCs, getProjectiles } from "./entitySpecific";
+
+/**
+ * Used to filter out certain NPCs when determining of an NPC is "alive" and/or should keep the
+ * doors open.
+ */
+const NON_ALIVE_NPCS_TYPE_VARIANT: ReadonlySet<string> = new Set([
+  `${EntityType.VIS}.${VisVariant.CHUBBER_PROJECTILE}`, // 39.22
+  `${EntityType.DEATH}.${DeathVariant.DEATH_SCYTHE}`, // 66.10
+  `${EntityType.PEEP}.${PeepVariant.PEEP_EYE}`, // 68.10
+  `${EntityType.PEEP}.${PeepVariant.BLOAT_EYE}`, // 68.11
+  `${EntityType.BEGOTTEN}.${BegottenVariant.BEGOTTEN_CHAIN}`, // 251.10
+  `${EntityType.MAMA_GURDY}.${MamaGurdyVariant.LEFT_HAND}`, // 266.1
+  `${EntityType.MAMA_GURDY}.${MamaGurdyVariant.RIGHT_HAND}`, // 266.2
+  `${EntityType.BIG_HORN}.${BigHornVariant.SMALL_HOLE}`, // 411.1
+  `${EntityType.BIG_HORN}.${BigHornVariant.BIG_HOLE}`, // 411.2
+  `${EntityType.DARK_ESAU}.${DarkEsauVariant.DARK_ESAU}`, // 866.0
+  `${EntityType.DARK_ESAU}.${DarkEsauVariant.PIT}`, // 866.1
+]);
+
+/**
+ * Used to filter out certain NPCs when determining of an NPC is "alive" and/or should keep the
+ * doors open.
+ */
+const NON_ALIVE_NPCS_TYPE_VARIANT_SUBTYPE: ReadonlySet<string> = new Set([
+  `${EntityType.CHARGER}.${ChargerVariant.CHARGER}.${ChargerSubType.MY_SHADOW}`, // 23.0.1
+  `${EntityType.MOTHER}.${MotherVariant.MOTHER_1}.${MotherSubType.PHASE_2}`, // 912
+]);
+
+/**
+ * Helper function to make an NPC fire a projectile. Returns the fired projectile. Use this function
+ * instead of the `EntityNPC.FireProjectiles` method, since that returns void.
+ *
+ * @param npc The NPC to fire the projectile from.
+ * @param position The staring position of the projectile.
+ * @param velocity The starting velocity of the projectile.
+ * @param projectilesMode The mode of the projectile. Optional. Default is
+ *                        `ProjectilesMode.ONE_PROJECTILE`.
+ * @param projectileParams The parameters of the projectile. Optional. Default is
+ *                         `ProjectileParams()`.
+ * @returns The fired projectile.
+ */
+export function fireProjectiles(
+  npc: EntityNPC,
+  position: Vector,
+  velocity: Vector,
+  projectilesMode: ProjectilesMode = ProjectilesMode.ONE_PROJECTILE,
+  projectileParams: ProjectileParams = ProjectileParams(),
+): EntityProjectile[] {
+  const oldProjectiles = getProjectiles(projectileParams.Variant);
+  npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
+  const newProjectiles = getProjectiles(projectileParams.Variant);
+
+  return getFilteredNewEntities(oldProjectiles, newProjectiles);
+}
+
+/**
+ * Helper function to get all of the non-dead NPCs in the room.
+ *
+ * This function will not include NPCs on an internal blacklist, such as Death's scythes or Big Horn
+ * holes.
+ */
+export function getAliveNPCs(
+  matchingEntityType?: EntityType,
+  matchingVariant?: int,
+  matchingSubType?: int,
+  ignoreFriendly = false,
+): EntityNPC[] {
+  const npcs = getNPCs(
+    matchingEntityType,
+    matchingVariant,
+    matchingSubType,
+    ignoreFriendly,
+  );
+  return npcs.filter((npc) => !npc.IsDead() && !isAliveExceptionNPC(npc));
+}
+
+/**
+ * Checks for specific NPCs that have "CanShutDoors" set to true naturally by the game, but should
+ * not actually keep the doors closed (like Death's scythes).
+ */
+export function isAliveExceptionNPC(npc: EntityNPC): boolean {
+  const entityTypeVariant = `${npc.Type}.${npc.Variant}`;
+  if (NON_ALIVE_NPCS_TYPE_VARIANT.has(entityTypeVariant)) {
+    return true;
+  }
+
+  const entityTypeVariantSubType = `${npc.Type}.${npc.Variant}.${npc.SubType}`;
+  if (NON_ALIVE_NPCS_TYPE_VARIANT_SUBTYPE.has(entityTypeVariantSubType)) {
+    return true;
+  }
+
+  if (isRaglingDeathPatch(npc)) {
+    return true;
+  }
+
+  if (isDyingEggyWithNoSpidersLeft(npc)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Helper function to detect the custom death state of an Eggy. Eggies are never actually marked
+ * dead by the game. Instead, when Eggies take fatal damage, they go into NpcState.STATE_SUICIDE and
+ * spawn 14 Swarm Spiders while their StateFrame ticks upwards.
+ */
+export function isDyingEggyWithNoSpidersLeft(npc: EntityNPC): boolean {
+  return (
+    npc.State === NpcState.SUICIDE &&
+    npc.StateFrame >= EGGY_STATE_FRAME_OF_FINAL_SPIDER
+  );
+}
+
+/**
+ * Helper function to detect the custom death state of a Rag Man Ragling. When Rag Man Raglings die,
+ * they turn into a patch on the ground and can be revived by Rag Man at a later time. This causes
+ * them to show up as an "alive" enemy, so they should usually be filtered out of lists of alive
+ * enemies.
+ */
+export function isRaglingDeathPatch(npc: EntityNPC): boolean {
+  return (
+    npc.Type === EntityType.RAGLING &&
+    npc.Variant === (RaglingVariant.RAG_MANS_RAGLING as int) &&
+    // They go to `STATE_SPECIAL` when they are patches on the ground.
+    npc.State === NpcState.SPECIAL
+  );
+}

package/src/functions/pickupVariants.ts

@@ -0,0 +1,60 @@
+/* eslint-disable sort-exports/sort-exports */
+
+import { PickupVariant } from "isaac-typescript-definitions";
+
+/** For `PickupVariant.HEART` (10) */
+export function isHeart(pickup: EntityPickup): pickup is EntityPickupHeart {
+  return pickup.Variant === PickupVariant.HEART;
+}
+
+/** For `PickupVariant.COIN` (20) */
+export function isCoin(pickup: EntityPickup): pickup is EntityPickupCoin {
+  return pickup.Variant === PickupVariant.COIN;
+}
+
+/** For `PickupVariant.KEY` (30) */
+export function isKey(pickup: EntityPickup): pickup is EntityPickupKey {
+  return pickup.Variant === PickupVariant.KEY;
+}
+
+/** For `PickupVariant.BOMB` (40) */
+export function isBomb(pickup: EntityPickup): pickup is EntityPickupBomb {
+  return pickup.Variant === PickupVariant.BOMB;
+}
+
+/** For `PickupVariant.POOP` (42) */
+export function isPoop(pickup: EntityPickup): pickup is EntityPickupPoop {
+  return pickup.Variant === PickupVariant.POOP;
+}
+
+/** For `PickupVariant.SACK` (69) */
+export function isSack(pickup: EntityPickup): pickup is EntityPickupSack {
+  return pickup.Variant === PickupVariant.SACK;
+}
+
+/** For `PickupVariant.PILL` (70) */
+export function isPill(pickup: EntityPickup): pickup is EntityPickupPill {
+  return pickup.Variant === PickupVariant.PILL;
+}
+
+/** For `PickupVariant.LIL_BATTERY` (90) */
+export function isBattery(pickup: EntityPickup): pickup is EntityPickupBattery {
+  return pickup.Variant === PickupVariant.LIL_BATTERY;
+}
+
+/** For `PickupVariant.COLLECTIBLE` (100) */
+export function isCollectible(
+  pickup: EntityPickup,
+): pickup is EntityPickupCollectible {
+  return pickup.Variant === PickupVariant.COLLECTIBLE;
+}
+
+/** For `PickupVariant.TAROT_CARD` (300) */
+export function isCardPickup(pickup: EntityPickup): pickup is EntityPickupCard {
+  return pickup.Variant === PickupVariant.TAROT_CARD;
+}
+
+/** For `PickupVariant.TRINKET` (350) */
+export function isTrinket(pickup: EntityPickup): pickup is EntityPickupTrinket {
+  return pickup.Variant === PickupVariant.TRINKET;
+}