isaacscript-common 14.2.0 → 15.0.0

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

@@ -0,0 +1,236 @@
+import {
+  CacheFlag,
+  CollectibleType,
+  DamageFlag,
+  EntityType,
+  LevelCurse,
+  ModCallback,
+  TearVariant,
+} from "isaac-typescript-definitions";
+import { Exported } from "../../../decorators";
+import { addFlag, bitFlags } from "../../../functions/flag";
+import { getMapPartialMatch } from "../../../functions/map";
+import {
+  isVanillaConsoleCommand,
+  printConsole,
+} from "../../../functions/utils";
+import { Feature } from "../../private/Feature";
+import * as commands from "./extraConsoleCommands/commands";
+import { v } from "./extraConsoleCommands/v";
+
+export class ExtraConsoleCommands extends Feature {
+  /** @internal */
+  public override v = v;
+
+  private commandFunctionMap = new Map<string, (params: string) => void>();
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+      [
+        ModCallback.EVALUATE_CACHE,
+        [this.evaluateCacheDamage, CacheFlag.DAMAGE], // 1 << 0
+      ], // 8
+      [
+        ModCallback.EVALUATE_CACHE,
+        [this.evaluateCacheFireDelay, CacheFlag.FIRE_DELAY], // 1 << 1
+      ], // 8
+      [
+        ModCallback.EVALUATE_CACHE,
+        [this.evaluateCacheSpeed, CacheFlag.SPEED], // 1 << 4
+      ], // 8
+      [
+        ModCallback.EVALUATE_CACHE,
+        [this.evaluateCacheFlying, CacheFlag.FLYING], // 1 << 7
+      ], // 8
+      [
+        ModCallback.ENTITY_TAKE_DMG,
+        [this.entityTakeDmgPlayer, EntityType.PLAYER],
+      ], // 11
+      [ModCallback.POST_CURSE_EVAL, [this.postCurseEval]], // 12
+      [ModCallback.EXECUTE_CMD, [this.executeCmd]], // 22
+      [ModCallback.POST_FIRE_TEAR, [this.postFireTear]], // 61
+    ];
+
+    for (const [funcName, func] of Object.entries(commands)) {
+      this.commandFunctionMap.set(funcName, func);
+    }
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = () => {
+    if (this.v.persistent.spamBloodRights) {
+      const player = Isaac.GetPlayer();
+      player.UseActiveItem(CollectibleType.BLOOD_RIGHTS);
+    }
+  };
+
+  // ModCallback.EVALUATE_CACHE (8)
+  // CacheFlag.DAMAGE (1 << 0)
+  private evaluateCacheDamage = (player: EntityPlayer) => {
+    if (this.v.persistent.damage) {
+      player.Damage = this.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;
+    }
+  };
+
+  // ModCallback.EVALUATE_CACHE (8)
+  // CacheFlag.SPEED (1 << 4)
+  private evaluateCacheSpeed = (player: EntityPlayer) => {
+    if (this.v.persistent.speed) {
+      player.MoveSpeed = this.v.persistent.speedAmount;
+    }
+  };
+
+  // ModCallback.EVALUATE_CACHE (8)
+  // CacheFlag.FLYING (1 << 7)
+  private evaluateCacheFlying = (player: EntityPlayer) => {
+    if (this.v.persistent.flight) {
+      player.CanFly = true;
+    }
+  };
+
+  // ModCallback.ENTITY_TAKE_DMG (11)
+  // EntityType.PLAYER (1)
+  private entityTakeDmgPlayer = (
+    _entity: Entity,
+    _damageAmount: float,
+    _damageFlags: BitFlags<DamageFlag>,
+    _damageSource: EntityRef,
+    _damageCountdownFrames: int,
+  ) => {
+    if (this.v.persistent.spamBloodRights) {
+      return false;
+    }
+
+    return undefined;
+  };
+
+  // ModCallback.POST_CURSE_EVAL (12)
+  private postCurseEval = (
+    curses: BitFlags<LevelCurse>,
+  ): BitFlags<LevelCurse> | undefined => {
+    if (this.v.persistent.disableCurses) {
+      return bitFlags(LevelCurse.NONE);
+    }
+
+    let newCurses = curses;
+
+    // 1
+    if (this.v.persistent.darkness) {
+      newCurses = addFlag(newCurses, LevelCurse.DARKNESS);
+    }
+
+    // 2
+    if (this.v.persistent.labyrinth) {
+      newCurses = addFlag(newCurses, LevelCurse.LABYRINTH);
+    }
+
+    // 3
+    if (this.v.persistent.lost) {
+      newCurses = addFlag(newCurses, LevelCurse.LOST);
+    }
+
+    // 4
+    if (this.v.persistent.unknown) {
+      newCurses = addFlag(newCurses, LevelCurse.UNKNOWN);
+    }
+
+    // 5
+    if (this.v.persistent.cursed) {
+      newCurses = addFlag(newCurses, LevelCurse.CURSED);
+    }
+
+    // 6
+    if (this.v.persistent.maze) {
+      newCurses = addFlag(newCurses, LevelCurse.MAZE);
+    }
+
+    // 7
+    if (this.v.persistent.blind) {
+      newCurses = addFlag(newCurses, LevelCurse.BLIND);
+    }
+
+    // 8
+    if (this.v.persistent.giant) {
+      newCurses = addFlag(newCurses, LevelCurse.GIANT);
+    }
+
+    return curses === newCurses ? undefined : newCurses;
+  };
+
+  // ModCallback.EXECUTE_CMD (22)
+  private executeCmd = (command: string, params: string) => {
+    const resultTuple = getMapPartialMatch(command, this.commandFunctionMap);
+    if (resultTuple === undefined) {
+      printConsole("That is an invalid console command.");
+      return;
+    }
+
+    const [commandName, commandFunction] = resultTuple;
+    printConsole(`Command: ${commandName}`);
+    commandFunction(params);
+  };
+
+  // ModCallback.POST_FIRE_TEAR (61)
+  private postFireTear = (tear: EntityTear) => {
+    if (this.v.persistent.chaosCardTears) {
+      tear.ChangeVariant(TearVariant.CHAOS_CARD);
+    }
+  };
+
+  /**
+   * Helper function to add a custom console command.
+   *
+   * The standard library comes with many existing console commands that are useful for debugging,
+   * but you can also add your own commands that are useful for your particular mod. It's easier to
+   * add commands to the existing command system than to add your own logic manually to the
+   * `EXECUTE_CMD` callback.
+   */
+  @Exported
+  public addConsoleCommand(
+    commandName: string,
+    commandFunction: (params: string) => void,
+  ): void {
+    if (isVanillaConsoleCommand(commandName)) {
+      error(
+        `Failed to add a new console command of "${commandName}" because that name already belongs to a vanilla command. You must pick a non-colliding name.`,
+      );
+    }
+
+    if (this.commandFunctionMap.has(commandName)) {
+      error(
+        `Failed to add a new console command of "${commandName}" because there is already an existing custom command by that name. If you want to overwrite a command from the standard library, you can use the "removeExtraConsoleCommand" function.`,
+      );
+    }
+
+    this.commandFunctionMap.set(commandName, commandFunction);
+  }
+
+  /**
+   * Helper function to remove a custom console command.
+   *
+   * The standard library comes with many existing console commands that are useful for debugging.
+   * If you want to disable one of them, use this function.
+   */
+  @Exported
+  public removeConsoleCommand(commandName: string): void {
+    if (!this.commandFunctionMap.has(commandName)) {
+      error(
+        `Failed to remove the console command of "${commandName}", since it does not already exist in the map.`,
+      );
+    }
+
+    this.commandFunctionMap.delete(commandName);
+  }
+}

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

@@ -0,0 +1,48 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../../core/cachedClasses";
+import { Exported } from "../../../decorators";
+import { Feature } from "../../private/Feature";
+
+const FADE_IN_SPEED = 1;
+
+export class FadeInRemover extends Feature {
+  private enabled = false;
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_GAME_STARTED, [this.postGameStarted]], // 15
+    ];
+  }
+
+  // ModCallback.POST_GAME_STARTED (15)
+  private postGameStarted = (_isContinued: boolean) => {
+    if (this.enabled) {
+      game.Fadein(FADE_IN_SPEED);
+    }
+  };
+
+  /**
+   * Removes the fade-in that occurs at the beginning of a run. If this behavior is desired, call
+   * this function once at the beginning of your mod.
+   *
+   * This is useful for debugging, when you are resetting the game often.
+   *
+   * You can restore the vanilla behavior with the `restoreFadeIn` function.
+   */
+  @Exported
+  public removeFadeIn(): void {
+    this.enabled = true;
+  }
+
+  /**
+   * Disables the fade-in remover. Only useful if you have previously called the `removeFadeIn`
+   * function.
+   */
+  @Exported
+  public restoreFadeIn(): void {
+    this.enabled = false;
+  }
+}

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

@@ -0,0 +1,83 @@
+import { ButtonAction, ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../../core/cachedClasses";
+import { Exported } from "../../../decorators";
+import {
+  isActionTriggeredOnAnyInput,
+  isModifierKeyPressed,
+} from "../../../functions/input";
+import { restart } from "../../../functions/run";
+import { Feature } from "../../private/Feature";
+
+/** A global variable set by custom consoles. */
+declare let AwaitingTextInput: boolean;
+
+export class FastReset extends Feature {
+  private enabled = false;
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_RENDER, [this.postRender]], // 2
+    ];
+  }
+
+  // ModCallback.POST_RENDER (2)
+  private postRender = () => {
+    if (!this.enabled) {
+      return;
+    }
+
+    checkResetInput();
+  };
+
+  /**
+   * Enables the fast-reset feature, which allows you to restart the game instantaneously. If this
+   * behavior is desired, call this function once at the beginning of your mod.
+   *
+   * This is useful for debugging, when you are resetting the game often.
+   *
+   * You can disable the fast-reset feature with the `disableFastReset` function.
+   */
+  @Exported
+  public enableFastReset(): void {
+    this.enabled = true;
+  }
+
+  /**
+   * Disables the fast-reset feature. Only useful if you have previously called the
+   * `enableFastReset` function.
+   */
+  @Exported
+  public disableFastReset(): void {
+    this.enabled = false;
+  }
+}
+
+/** Check for fast-reset inputs. */
+function checkResetInput() {
+  const isPaused = game.IsPaused();
+
+  // Disable the fast-reset feature if the console is open. (This will also disable the feature when
+  // the game is paused, but that's okay as well.)
+  if (isPaused) {
+    return;
+  }
+
+  // Disable the fast-reset feature if any custom consoles are open.
+  if (AwaitingTextInput) {
+    return;
+  }
+
+  // Don't fast-reset if any modifiers are pressed.
+  if (isModifierKeyPressed()) {
+    return;
+  }
+
+  // Check to see if the player has pressed the restart input. (We check all inputs instead of
+  // `player.ControllerIndex` because a controller player might be using the keyboard to reset.)
+  if (isActionTriggeredOnAnyInput(ButtonAction.RESTART)) {
+    restart();
+  }
+}

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

@@ -0,0 +1,58 @@
+import { NullItemID } from "isaac-typescript-definitions";
+import { Exported } from "../../../decorators";
+import { ISCFeature } from "../../../enums/ISCFeature";
+import { Feature } from "../../private/Feature";
+import { ModdedElementSets } from "./ModdedElementSets";
+
+const FLYING_NULL_ITEMS: readonly NullItemID[] = [
+  NullItemID.REVERSE_SUN, // 66
+  NullItemID.SPIRIT_SHACKLES_SOUL, // 10
+  NullItemID.LOST_CURSE, // 112
+];
+
+export class FlyingDetection extends Feature {
+  private moddedElementSets: ModdedElementSets;
+
+  /** @internal */
+  constructor(moddedElementSets: ModdedElementSets) {
+    super();
+
+    this.featuresUsed = [ISCFeature.MODDED_ELEMENT_SETS];
+
+    this.moddedElementSets = moddedElementSets;
+  }
+
+  /**
+   * Helper function to see if the player currently has flying from a temporary effect such as
+   * Hanged Man, Bat Wing, and so on.
+   */
+  @Exported
+  public hasFlyingTemporaryEffect(player: EntityPlayer): boolean {
+    const effects = player.GetEffects();
+
+    // - Hanged Man card gives a Transcendence temporary effect.
+    // - Pinking Shears gives a Transcendence temporary effect.
+    const flyingCollectibles =
+      this.moddedElementSets.getFlyingCollectibles(false);
+    for (const collectibleType of flyingCollectibles.values()) {
+      if (effects.HasCollectibleEffect(collectibleType)) {
+        return true;
+      }
+    }
+
+    const flyingTrinkets = this.moddedElementSets.getFlyingTrinkets();
+    for (const trinketType of flyingTrinkets.values()) {
+      if (effects.HasTrinketEffect(trinketType)) {
+        return true;
+      }
+    }
+
+    for (const nullItemID of FLYING_NULL_ITEMS) {
+      if (effects.HasNullEffect(nullItemID)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

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

@@ -0,0 +1,52 @@
+import {
+  ButtonAction,
+  InputHook,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { Exported } from "../../../decorators";
+import { Feature } from "../../private/Feature";
+
+export class ForgottenSwitch extends Feature {
+  /** @internal */
+  public override v = {
+    run: {
+      shouldSwitch: false,
+    },
+  };
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.INPUT_ACTION,
+        [this.isActionTriggered, InputHook.IS_ACTION_TRIGGERED],
+      ], // 13
+    ];
+  }
+
+  // ModCallback.INPUT_ACTION (13)
+  // InputHook.IS_ACTION_TRIGGERED (1)
+  private isActionTriggered = (
+    _entity: Entity | undefined,
+    _inputHook: InputHook,
+    buttonAction: ButtonAction,
+  ) => {
+    if (buttonAction === ButtonAction.DROP && this.v.run.shouldSwitch) {
+      this.v.run.shouldSwitch = false;
+      return true;
+    }
+
+    return undefined;
+  };
+
+  /**
+   * When used on The Forgotten, switches to The Soul. When used on The Soul, switches to The
+   * Forgotten. This takes 1 game frame to take effect.
+   */
+  @Exported
+  public forgottenSwitch(): void {
+    this.v.run.shouldSwitch = true;
+  }
+}

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

@@ -0,0 +1,228 @@
+import {
+  CollectibleType,
+  ItemConfigTag,
+  ItemPoolType,
+  PlayerType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { game } from "../../../core/cachedClasses";
+import { Exported } from "../../../decorators";
+import { ISCFeature } from "../../../enums/ISCFeature";
+import { collectibleHasTag } from "../../../functions/collectibleTag";
+import {
+  mapGetPlayer,
+  mapSetPlayer,
+} from "../../../functions/playerDataStructures";
+import { getAllPlayers } from "../../../functions/playerIndex";
+import {
+  anyPlayerHasCollectible,
+  getPlayersOfType,
+} from "../../../functions/players";
+import { repeat } from "../../../functions/utils";
+import { PlayerIndex } from "../../../types/PlayerIndex";
+import { Feature } from "../../private/Feature";
+import { ModdedElementSets } from "./ModdedElementSets";
+
+const COLLECTIBLE_TYPE_THAT_IS_NOT_IN_ANY_POOLS = CollectibleType.KEY_PIECE_1;
+
+const COLLECTIBLES_THAT_AFFECT_ITEM_POOLS: readonly CollectibleType[] = [
+  CollectibleType.CHAOS, // 402
+  CollectibleType.SACRED_ORB, // 691
+  CollectibleType.TMTRAINER, // 721
+];
+
+const TRINKETS_THAT_AFFECT_ITEM_POOLS: readonly TrinketType[] = [
+  TrinketType.NO,
+];
+
+export class ItemPoolDetection extends Feature {
+  private moddedElementSets: ModdedElementSets;
+
+  /** @internal */
+  constructor(moddedElementSets: ModdedElementSets) {
+    super();
+
+    this.featuresUsed = [ISCFeature.MODDED_ELEMENT_SETS];
+
+    this.moddedElementSets = moddedElementSets;
+  }
+
+  /**
+   * Helper function to get the remaining collectibles in a given item pool. This function is
+   * expensive, so only use it in situations where the lag is acceptable.
+   */
+  @Exported
+  public getCollectiblesInItemPool(
+    itemPoolType: ItemPoolType,
+  ): CollectibleType[] {
+    const collectibleArray = this.moddedElementSets.getCollectibleArray();
+    return collectibleArray.filter((collectibleType) =>
+      this.isCollectibleInItemPool(collectibleType, itemPoolType),
+    );
+  }
+
+  /**
+   * Helper function to see if the given collectible is still present in the given item pool.
+   *
+   * If the collectible is non-offensive, any Tainted Losts will be temporarily changed to Isaac and
+   * then changed back. (This is because Tainted Lost is not able to retrieve non-offensive
+   * collectibles from item pools).
+   *
+   * Under the hood, this function works by using the `ItemPool.AddRoomBlacklist` method to
+   * blacklist every collectible except for the one provided.
+   */
+  @Exported
+  public isCollectibleInItemPool(
+    collectibleType: CollectibleType,
+    itemPoolType: ItemPoolType,
+  ): boolean {
+    // We use a specific collectible which is known to not be in any pools as a default value. Thus,
+    // we must explicitly handle this case.
+    if (collectibleType === COLLECTIBLE_TYPE_THAT_IS_NOT_IN_ANY_POOLS) {
+      return false;
+    }
+
+    // On Tainted Lost, it is impossible to retrieve non-offensive collectibles from pools, so we
+    // temporarily change the character to Isaac.
+    const taintedLosts = getPlayersOfType(PlayerType.LOST_B);
+    const isOffensive = collectibleHasTag(
+      collectibleType,
+      ItemConfigTag.OFFENSIVE,
+    );
+    let changedPlayerTypes = false;
+    if (!isOffensive) {
+      changedPlayerTypes = true;
+      for (const player of taintedLosts) {
+        player.ChangePlayerType(PlayerType.ISAAC);
+      }
+    }
+
+    const [removedItemsMap, removedTrinketsMap] =
+      removeItemsAndTrinketsThatAffectItemPools();
+
+    // Blacklist every collectible in the game except for the provided collectible.
+    const itemPool = game.GetItemPool();
+    itemPool.ResetRoomBlacklist();
+    for (const collectibleTypeInSet of this.moddedElementSets.getCollectibleArray()) {
+      if (collectibleTypeInSet !== collectibleType) {
+        itemPool.AddRoomBlacklist(collectibleTypeInSet);
+      }
+    }
+
+    // Get a collectible from the pool and see if it is the intended collectible. (We can use any
+    // arbitrary value as the seed since it should not influence the result.)
+    const seed = 1 as Seed;
+    const retrievedCollectibleType = itemPool.GetCollectible(
+      itemPoolType,
+      false,
+      seed,
+      COLLECTIBLE_TYPE_THAT_IS_NOT_IN_ANY_POOLS,
+    );
+    const collectibleUnlocked = retrievedCollectibleType === collectibleType;
+
+    // Reset the blacklist
+    itemPool.ResetRoomBlacklist();
+
+    restoreItemsAndTrinketsThatAffectItemPools(
+      removedItemsMap,
+      removedTrinketsMap,
+    );
+
+    // Change any players back to Tainted Lost, if necessary.
+    if (changedPlayerTypes) {
+      for (const player of taintedLosts) {
+        player.ChangePlayerType(PlayerType.LOST_B);
+      }
+    }
+
+    return collectibleUnlocked;
+  }
+
+  /**
+   * Helper function to see if the given collectible is unlocked on the current save file. This
+   * requires providing the corresponding item pool that the collectible is normally located in.
+   *
+   * - If any player currently has the collectible, then it is assumed to be unlocked. (This is
+   *   because in almost all cases, when a collectible is added to a player's inventory, it is
+   *   subsequently removed from all pools.)
+   * - If the collectible is located in more than one item pool, then any item pool can be provided.
+   * - If the collectible is not located in any item pools, then this function will always return
+   *   false.
+   * - If the collectible is non-offensive, any Tainted Losts will be temporarily changed to Isaac
+   *   and then changed back. (This is because Tainted Lost is not able to retrieve non-offensive
+   *   collectibles from item pools).
+   */
+  @Exported
+  public isCollectibleUnlocked(
+    collectibleType: CollectibleType,
+    itemPoolType: ItemPoolType,
+  ): boolean {
+    if (anyPlayerHasCollectible(collectibleType)) {
+      return true;
+    }
+
+    return this.isCollectibleInItemPool(collectibleType, itemPoolType);
+  }
+}
+
+/**
+ * Before checking the item pools, remove any collectibles or trinkets that would affect the
+ * retrieved collectible types.
+ */
+function removeItemsAndTrinketsThatAffectItemPools(): [
+  removedItemsMap: Map<PlayerIndex, CollectibleType[]>,
+  removedTrinketsMap: Map<PlayerIndex, TrinketType[]>,
+] {
+  const removedItemsMap = new Map<PlayerIndex, CollectibleType[]>();
+  const removedTrinketsMap = new Map<PlayerIndex, TrinketType[]>();
+  for (const player of getAllPlayers()) {
+    const removedItems: CollectibleType[] = [];
+    for (const itemToRemove of COLLECTIBLES_THAT_AFFECT_ITEM_POOLS) {
+      // We need to include non-real collectibles (like Lilith's Incubus), so we omit the second
+      // argument.
+      const numCollectibles = player.GetCollectibleNum(itemToRemove);
+      repeat(numCollectibles, () => {
+        player.RemoveCollectible(itemToRemove);
+        removedItems.push(itemToRemove);
+      });
+    }
+
+    mapSetPlayer(removedItemsMap, player, removedItems);
+
+    const removedTrinkets: TrinketType[] = [];
+    for (const trinketToRemove of TRINKETS_THAT_AFFECT_ITEM_POOLS) {
+      if (player.HasTrinket(trinketToRemove)) {
+        const numTrinkets = player.GetTrinketMultiplier(trinketToRemove);
+        repeat(numTrinkets, () => {
+          player.TryRemoveTrinket(trinketToRemove);
+          removedTrinkets.push(trinketToRemove);
+        });
+      }
+    }
+
+    mapSetPlayer(removedTrinketsMap, player, removedTrinkets);
+  }
+
+  return [removedItemsMap, removedTrinketsMap];
+}
+
+function restoreItemsAndTrinketsThatAffectItemPools(
+  removedItemsMap: Map<PlayerIndex, CollectibleType[]>,
+  removedTrinketsMap: Map<PlayerIndex, TrinketType[]>,
+) {
+  for (const player of getAllPlayers()) {
+    const removedItems = mapGetPlayer(removedItemsMap, player);
+    if (removedItems !== undefined) {
+      for (const collectibleType of removedItems) {
+        player.AddCollectible(collectibleType, 0, false); // Prevent Chaos from spawning pickups
+      }
+    }
+
+    const removedTrinkets = mapGetPlayer(removedTrinketsMap, player);
+    if (removedTrinkets !== undefined) {
+      for (const trinketType of removedTrinkets) {
+        player.AddTrinket(trinketType, false);
+      }
+    }
+  }
+}