isaacscript-common 2.2.0 → 2.3.0

package/src/features/extraConsoleCommands/v.ts

@@ -0,0 +1,14 @@
+const v = {
+  persistent: {
+    disableCurses: false,
+  },
+
+  run: {
+    chaosCardTears: false,
+    spamBloodRights: false,
+    maxDamage: false,
+    maxSpeed: false,
+    maxTears: false,
+  },
+};
+export default v;

package/src/features/fadeInRemover.ts

@@ -0,0 +1,60 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "fade-in remover";
+const FADE_IN_SPEED = 1;
+
+let enabled = false;
+
+const v = {
+  run: {
+    removedFadeIn: false,
+  },
+};
+
+/** @internal */
+export function fadeInRemoverInit(mod: Mod): void {
+  saveDataManager("fadeInRemover", v, () => false);
+
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function postRender() {
+  if (!enabled) {
+    return;
+  }
+
+  if (shouldRemoveFadeIn()) {
+    v.run.removedFadeIn = true;
+    game.Fadein(FADE_IN_SPEED);
+  }
+}
+
+function shouldRemoveFadeIn() {
+  const gameFrameCount = game.GetFrameCount();
+  return !v.run.removedFadeIn && gameFrameCount === 0;
+}
+
+/**
+ * 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.
+ */
+export function removeFadeIn(): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  enabled = true;
+}
+
+/**
+ * Disables the fade-in remover. Only useful if you have previously called the `removeFadeIn`
+ * function.
+ */
+export function restoreFadeIn(): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  enabled = false;
+}

package/src/features/fastReset.ts

@@ -0,0 +1,75 @@
+import { ButtonAction, ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import {
+  isActionTriggeredOnAnyInput,
+  isModifierKeyPressed,
+} from "../functions/input";
+import { restart } from "../functions/run";
+
+const FEATURE_NAME = "fast reset";
+
+let enabled = false;
+
+/** @internal */
+export function fastResetInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!enabled) {
+    return;
+  }
+
+  checkResetInput();
+}
+
+/** 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 the custom console is 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();
+  }
+}
+
+/**
+ * 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.
+ */
+export function enableFastReset(): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  enabled = true;
+}
+
+/**
+ * Disables the fast-reset feature. Only useful if you have previously called the `enableFastReset`
+ * function.
+ */
+export function disableFastReset(): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  enabled = false;
+}

package/src/features/forgottenSwitch.ts

@@ -0,0 +1,50 @@
+import {
+  ButtonAction,
+  InputHook,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "forgotten switcher";
+
+const v = {
+  run: {
+    shouldSwitch: false,
+  },
+};
+
+/** @internal */
+export function forgottenSwitchInit(mod: Mod): void {
+  saveDataManager("forgottenSwitch", v);
+
+  mod.AddCallback(
+    ModCallback.INPUT_ACTION, // 13
+    isActionTriggered,
+    InputHook.IS_ACTION_TRIGGERED, // 1
+  );
+}
+
+// ModCallback.INPUT_ACTION (13)
+// InputHook.IS_ACTION_TRIGGERED (1)
+function isActionTriggered(
+  _entity: Entity | undefined,
+  _inputHook: InputHook,
+  buttonAction: ButtonAction,
+) {
+  if (buttonAction === ButtonAction.DROP && v.run.shouldSwitch) {
+    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.
+ */
+export function forgottenSwitch(): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  v.run.shouldSwitch = true;
+}

package/src/features/getCollectibleItemPoolType.ts

@@ -0,0 +1,66 @@
+// The item pool type of a collectible is not stored on the collectible. Thus, we scan for incoming
+// item pool types in the PreGetCollectible callback, and then assume that the next spawned
+// collectible has this item pool type.
+
+import {
+  ItemPoolType,
+  ModCallback,
+  PickupVariant,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { getEntityID } from "../functions/entity";
+import { isCollectible } from "../functions/pickupVariants";
+import { getRoomItemPoolType } from "../functions/rooms";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "get collectible item pool type";
+
+const v = {
+  run: {
+    collectibleItemPoolTypeMap: new Map<PtrHash, ItemPoolType>(),
+  },
+};
+
+/** @internal */
+export function getCollectibleItemPoolTypeInit(mod: Mod): void {
+  saveDataManager("getCollectibleItemPoolType", v);
+
+  mod.AddCallback(
+    ModCallback.POST_PICKUP_INIT,
+    postPickupInitCollectible,
+    PickupVariant.COLLECTIBLE,
+  ); // 34
+}
+
+// ModCallback.POST_PICKUP_INIT (34)
+// PickupVariant.COLLECTIBLE (100)
+function postPickupInitCollectible(pickup: EntityPickup) {
+  const itemPool = game.GetItemPool();
+  const ptrHash = GetPtrHash(pickup);
+  const lastItemPoolType = itemPool.GetLastPool();
+
+  v.run.collectibleItemPoolTypeMap.set(ptrHash, lastItemPoolType);
+}
+
+/**
+ * Helper function to get the item pool type that a given collectible came from. Since there is no
+ * native method in the API to get this, we listen in the PreGetCollectible callback for item pool
+ * types, and then assume that the next spawned collectible will match.
+ */
+export function getCollectibleItemPoolType(
+  collectible: EntityPickup,
+): ItemPoolType {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  if (!isCollectible(collectible)) {
+    const entityID = getEntityID(collectible);
+    error(
+      `The "getCollectibleItemPoolType" function was given a non-collectible: ${entityID}`,
+    );
+  }
+
+  const ptrHash = GetPtrHash(collectible);
+  const itemPoolType = v.run.collectibleItemPoolTypeMap.get(ptrHash);
+  return itemPoolType === undefined ? getRoomItemPoolType() : itemPoolType;
+}

package/src/features/playerInventory.ts

@@ -0,0 +1,187 @@
+import {
+  ActiveSlot,
+  CollectibleType,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { arrayRemoveInPlace, copyArray } from "../functions/array";
+import { isActiveCollectible } from "../functions/collectibles";
+import { getCollectibleSet } from "../functions/collectibleSet";
+import { getAllPlayers, getPlayerIndex } from "../functions/playerIndex";
+import { repeat } from "../functions/utils";
+import {
+  PickingUpItem,
+  pickingUpItemIsCollectible,
+} from "../types/PickingUpItem";
+import { PlayerIndex } from "../types/PlayerIndex";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "player inventory tracker";
+
+const v = {
+  run: {
+    playersInventory: new DefaultMap<
+      PlayerIndex,
+      CollectibleType[],
+      [player: EntityPlayer]
+    >((player: EntityPlayer) => newPlayerInventory(player)),
+
+    /**
+     * We also keep track of the active items that the player has, so that we can easily flush them
+     * from the inventory when other active items are picked up.
+     */
+    playersActiveCollectibleTypes: new DefaultMap<
+      PlayerIndex,
+      CollectibleType[]
+    >(() => []),
+  },
+};
+
+function newPlayerInventory(player: EntityPlayer) {
+  const inventory: CollectibleType[] = [];
+
+  const collectibleSet = getCollectibleSet();
+  for (const collectibleType of collectibleSet.values()) {
+    const numCollectibles = player.GetCollectibleNum(collectibleType, true);
+    repeat(numCollectibles, () => {
+      inventory.push(collectibleType);
+    });
+  }
+
+  return inventory;
+}
+
+/** @internal */
+export function playerInventoryInit(mod: ModUpgraded): void {
+  saveDataManager("playerInventory", v);
+
+  mod.AddCallback(ModCallback.POST_USE_ITEM, useItemD4, CollectibleType.D4); // 3
+  mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
+  mod.AddCallbackCustom(ModCallbackCustom.POST_ITEM_PICKUP, postItemPickup);
+}
+
+// ModCallback.POST_USE_ITEM (3)
+// CollectibleType.D4 (284)
+function useItemD4(
+  _collectibleType: CollectibleType,
+  _rng: RNG,
+  player: EntityPlayer,
+) {
+  const playerIndex = getPlayerIndex(player);
+  const inventory = newPlayerInventory(player);
+  v.run.playersInventory.set(playerIndex, inventory);
+}
+
+// ModCallback.POST_GAME_STARTED (15)
+function postGameStarted() {
+  // We don't use the PostPlayerInit function 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)) {
+      const inventory = newPlayerInventory(player);
+      v.run.playersInventory.set(playerIndex, inventory);
+    }
+  }
+}
+
+// ModCallbackCustom.POST_ITEM_PICKUP
+function postItemPickup(player: EntityPlayer, pickingUpItem: PickingUpItem) {
+  if (!pickingUpItemIsCollectible(pickingUpItem)) {
+    return;
+  }
+
+  addCollectibleToInventory(player, pickingUpItem.subType);
+}
+
+function addCollectibleToInventory(
+  player: EntityPlayer,
+  collectibleType: CollectibleType,
+) {
+  const playerIndex = getPlayerIndex(player);
+  const inventory = v.run.playersInventory.getAndSetDefault(
+    playerIndex,
+    player,
+  );
+  inventory.push(collectibleType);
+
+  if (!isActiveCollectible(collectibleType)) {
+    return;
+  }
+
+  const activeCollectibleTypes =
+    v.run.playersActiveCollectibleTypes.getAndSetDefault(playerIndex);
+  activeCollectibleTypes.push(collectibleType);
+
+  const droppedActiveCollectibleTypes = activeCollectibleTypes.filter(
+    (activeCollectibleType) => !player.HasCollectible(activeCollectibleType),
+  );
+  for (const activeCollectibleType of droppedActiveCollectibleTypes) {
+    arrayRemoveInPlace(inventory, activeCollectibleType);
+    arrayRemoveInPlace(activeCollectibleTypes, activeCollectibleType);
+  }
+}
+
+/**
+ * Helper function to get all of the collectibles that the player has gotten so far on this run, in
+ * order.
+ *
+ * Note that this does not include active collectibles that have since been dropped for other
+ * collectibles.
+ *
+ * In the case of inventory initialization or the case where the player rerolls their build in the
+ * middle of the run (e.g. with D4), the order of the inventory will not correspond to the order
+ * that the items were actually given to the player. In this case, the inventory will be in the
+ * order of the lowest `CollectibleType` to the highest.
+ */
+export function getPlayerInventory(
+  player: EntityPlayer,
+  includeActiveCollectibles = true,
+): CollectibleType[] {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  const playerIndex = getPlayerIndex(player);
+  const inventory = v.run.playersInventory.getAndSetDefault(
+    playerIndex,
+    player,
+  );
+
+  const copiedInventory = copyArray(inventory);
+  if (includeActiveCollectibles) {
+    return copiedInventory;
+  }
+
+  return copiedInventory.filter(
+    (collectibleType) => !isActiveCollectible(collectibleType),
+  );
+}
+
+/**
+ * Helper function to add a collectible to a player. Use this instead of the
+ * `EntityPlayer.AddCollectible` method if you want the collectible that is added to be
+ * automatically tracked by the player inventory tracker feature.
+ *
+ * You only need to use this function if you are using the inventory feature from the standard
+ * library.
+ */
+export function addCollectible(
+  player: EntityPlayer,
+  collectibleType: CollectibleType,
+  charge?: int,
+  firstTimePickingUp?: boolean,
+  activeSlot?: ActiveSlot,
+  varData?: int,
+): void {
+  player.AddCollectible(
+    collectibleType,
+    charge,
+    firstTimePickingUp,
+    activeSlot,
+    varData,
+  );
+
+  addCollectibleToInventory(player, collectibleType);
+}

package/src/features/ponyDetection.ts

@@ -0,0 +1,74 @@
+// Detecting whether or not A Pony or White Pony is active is difficult with the vanilla API.
+// Normally, activation will cause the player to have the respective temporary collectible effect
+// However, this effect is lost if the player enters a new room (but the effect will still be
+// active). When the effect is active, the player will have some specific entity flags. Thus, we can
+// work around the problem by checking to see if the player has these entity flags and has had a
+// collectible effect on a previous frame.
+
+import { CollectibleType, EntityFlag } from "isaac-typescript-definitions";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { hasFlag } from "../functions/flag";
+import {
+  setAddPlayer,
+  setDeletePlayer,
+  setHasPlayer,
+} from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "pony activation detector";
+
+const FLAGS_WHEN_PONY_IS_ACTIVE: readonly EntityFlag[] = [
+  EntityFlag.NO_KNOCKBACK, // 1 << 26
+  EntityFlag.NO_PHYSICS_KNOCKBACK, // 1 << 30
+  EntityFlag.NO_DAMAGE_BLINK, // 1 << 36
+];
+
+const v = {
+  run: {
+    playersIsPonyActive: new Set<PlayerIndex>(),
+  },
+};
+
+/** @internal */
+export function ponyDetectionInit(mod: ModUpgraded): void {
+  saveDataManager("ponyDetection", v);
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
+}
+
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
+  const effects = player.GetEffects();
+  const entityFlags = player.GetEntityFlags();
+  const hasPonyCollectibleEffect =
+    effects.HasCollectibleEffect(CollectibleType.PONY) ||
+    effects.HasCollectibleEffect(CollectibleType.WHITE_PONY);
+  const isPonyActiveOnPreviousFrame = setHasPlayer(
+    v.run.playersIsPonyActive,
+    player,
+  );
+  const hasPonyFlags = hasFlag(entityFlags, ...FLAGS_WHEN_PONY_IS_ACTIVE);
+
+  const isPonyActiveNow =
+    hasPonyCollectibleEffect || (isPonyActiveOnPreviousFrame && hasPonyFlags);
+  if (isPonyActiveNow) {
+    setAddPlayer(v.run.playersIsPonyActive, player);
+  } else {
+    setDeletePlayer(v.run.playersIsPonyActive, player);
+  }
+}
+
+/**
+ * Helper function to see if the player is under the effects of A Pony or White Pony charge.
+ * Detecting this is difficult, as the temporary effect will disappear upon entering a new room.
+ */
+export function isPonyActive(player: EntityPlayer): boolean {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  return setHasPlayer(v.run.playersIsPonyActive, player);
+}

package/src/features/preventCollectibleRotation.ts

@@ -0,0 +1,113 @@
+// Keep specific items from being affected by the Glitched Crown, Binge Eater, and the Tainted Isaac
+// switching mechanic.
+
+import {
+  Card,
+  CollectibleType,
+  ModCallback,
+  PickupVariant,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { setCollectibleSubType } from "../functions/collectibles";
+import { getEntityID } from "../functions/entity";
+import { isCollectible } from "../functions/pickupVariants";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "prevent collectible rotation";
+
+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>(),
+  },
+};
+
+/** @internal */
+export function preventCollectibleRotationInit(mod: Mod): void {
+  saveDataManager("preventCollectibleRotation", v);
+
+  mod.AddCallback(
+    ModCallback.POST_USE_CARD,
+    useCardSoulOfIsaac,
+    Card.SOUL_ISAAC,
+  ); // 5
+
+  mod.AddCallback(
+    ModCallback.POST_PICKUP_UPDATE,
+    postPickupUpdateCollectible,
+    PickupVariant.COLLECTIBLE,
+  ); // 35
+}
+
+// ModCallback.POST_USE_CARD (5)
+// Card.SOUL_ISAAC (81)
+function useCardSoulOfIsaac() {
+  // Soul of Isaac causes items to flip. Delete all tracked items (assuming that the player
+  // deliberately wants to roll a quest item).
+  v.room.trackedCollectibles.clear();
+}
+
+// ModCallback.POST_PICKUP_UPDATE (35)
+// PickupVariant.COLLECTIBLE (100)
+function postPickupUpdateCollectible(collectible: EntityPickupCollectible) {
+  // Ignore empty pedestals (i.e. items that have already been taken by the player).
+  if (collectible.SubType === CollectibleType.NULL) {
+    return;
+  }
+
+  const index = getMapIndex(collectible);
+  const trackedCollectibleType = v.room.trackedCollectibles.get(index);
+  if (
+    trackedCollectibleType !== undefined &&
+    collectible.SubType !== trackedCollectibleType
+  ) {
+    // This item has switched, so restore it back to the way it was.
+    setCollectibleSubType(collectible, trackedCollectibleType);
+  }
+}
+
+/**
+ * Helper function to prevent a collectible from being affected by Tainted Isaac's rotation
+ * mechanic. (This mechanic also happens from Glitched Crown and Binge Eater.) This is useful
+ * because quest items that are manually spawned by mods will be automatically be affected by this
+ * mechanic.
+ *
+ * It is required to pass the intended collectible type to this function since it is possible for
+ * collectibles to rotate on the first frame that they are spawned.
+ */
+export function preventCollectibleRotation(
+  collectible: EntityPickup,
+  collectibleType: CollectibleType,
+): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  if (!isCollectible(collectible)) {
+    const entityID = getEntityID(collectible);
+    error(
+      `The "preventCollectibleRotate" function was given a non-collectible: ${entityID}`,
+    );
+  }
+
+  const index = getMapIndex(collectible);
+  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.
+  postPickupUpdateCollectible(collectible);
+}
+
+function getMapIndex(collectible: EntityPickup) {
+  const room = game.GetRoom();
+  const gridIndex = room.GetGridIndex(collectible.Position);
+  return `${gridIndex},${collectible.InitSeed}`;
+}