isaacscript-common 2.3.0 → 3.0.0

package/src/features/extraConsoleCommands/v.ts

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

package/src/features/fadeInRemover.ts

@@ -1,60 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,66 +0,0 @@
-// 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

@@ -1,187 +0,0 @@
-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

@@ -1,74 +0,0 @@
-// 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

@@ -1,113 +0,0 @@
-// 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}`;
-}