isaacscript-common 4.0.3 → 4.0.4

package/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/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/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/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/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/features/persistentEntities.ts

@@ -1,183 +0,0 @@
-import {
-  EntityFlag,
-  EntityType,
-  ModCallback,
-} from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { spawn } from "../functions/entity";
-import { getRoomListIndex } from "../functions/roomData";
-import { saveDataManager } from "./saveDataManager/exports";
-
-interface PersistentEntityDescription {
-  entityType: EntityType;
-  variant: int;
-  subType: int;
-  roomListIndex: int;
-  position: Vector;
-}
-
-/** Iterates upward as new persistent entities are created. */
-let persistentEntityIndexCounter = 0;
-
-const v = {
-  level: {
-    /**
-     * Indexed by persistent entity index.
-     *
-     * When the entity is spawned in the currently room, its corresponding entry in this map will be
-     * temporarily deleted (until the entity itself is despawned).
-     */
-    persistentEntities: new Map<int, PersistentEntityDescription>(),
-  },
-
-  room: {
-    spawnedPersistentEntities: new Map<
-      PtrHash,
-      [index: int, entityPtr: EntityPtr]
-    >(),
-  },
-};
-
-/** @internal */
-export function persistentEntitiesInit(mod: ModUpgraded): void {
-  saveDataManager("persistentEntities", v);
-
-  mod.AddCallback(ModCallback.POST_ENTITY_REMOVE, postEntityRemove); // 67
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
-    postNewRoomReordered,
-  );
-}
-
-// ModCallback.POST_ENTITY_REMOVE (67)
-function postEntityRemove(entity: Entity) {
-  const ptrHash = GetPtrHash(entity);
-  const tuple = v.room.spawnedPersistentEntities.get(ptrHash);
-  if (tuple === undefined) {
-    return;
-  }
-  const index = tuple[0];
-
-  // The persistent entity is despawning, presumably because the player is in the process of leaving
-  // the room. Keep track of the position for later. We use the previous room list index because at
-  // this point, the PostNewRoom callback has already fired and we are in a new room.
-  const level = game.GetLevel();
-  const previousRoomGridIndex = level.GetPreviousRoomIndex();
-  const previousRoomListIndex = getRoomListIndex(previousRoomGridIndex);
-  v.level.persistentEntities.set(index, {
-    entityType: entity.Type,
-    variant: entity.Variant,
-    subType: entity.SubType,
-    roomListIndex: previousRoomListIndex,
-    position: entity.Position,
-  });
-}
-
-// ModCallbackCustom.POST_NEW_ROOM_REORDERED
-function postNewRoomReordered() {
-  const roomListIndex = getRoomListIndex();
-
-  for (const [index, description] of v.level.persistentEntities.entries()) {
-    if (roomListIndex !== description.roomListIndex) {
-      continue;
-    }
-
-    v.level.persistentEntities.delete(index);
-    spawnAndTrack(
-      description.entityType,
-      description.variant,
-      description.subType,
-      description.position,
-      index,
-      true,
-    );
-  }
-}
-
-/**
- * Helper function to spawn an entity that will have persistence similar to a pickup.
- *
- * By default, as soon as you leave a room, any spawned entities will be despawned and will not
- * return if the player revisits the room. This means that if you want to have an entity like a
- * pickup, you have to manually respawn it when the player re-enters the room. Use this helper
- * function to avoid having to do any tracking on your own.
- *
- * Conventionally, the word "persistent" refers to `EntityFlag.FLAG_PERSISTENT`, which is used on
- * e.g. familiars to make them appear in every room. On the other hand, pickups are also persistent,
- * but they are not present in every room, only one specific room. This function spawns entities
- * like pickups, not familiars.
- *
- * @returns A tuple containing the entity and the persistent entity index. You can use the index
- *          with the `removePersistentEntity` function.
- */
-export function spawnPersistentEntity(
-  entityType: EntityType,
-  variant: int,
-  subType: int,
-  position: Vector,
-): [Entity, int] {
-  persistentEntityIndexCounter += 1;
-
-  const entity = spawnAndTrack(
-    entityType,
-    variant,
-    subType,
-    position,
-    persistentEntityIndexCounter,
-  );
-
-  return [entity, persistentEntityIndexCounter];
-}
-
-function spawnAndTrack(
-  entityType: EntityType,
-  variant: int,
-  subType: int,
-  position: Vector,
-  index: int,
-  respawning = false,
-): Entity {
-  const entity = spawn(entityType, variant, subType, position);
-  if (respawning) {
-    entity.ClearEntityFlags(EntityFlag.APPEAR);
-  }
-
-  const ptrHash = GetPtrHash(entity);
-
-  // Keep track that we spawned it so that we can respawn it if the player re-enters the room.
-  const tuple: [int, EntityPtr] = [index, EntityPtr(entity)];
-  v.room.spawnedPersistentEntities.set(ptrHash, tuple);
-
-  return entity;
-}
-
-/**
- * Helper function to stop an entity spawned with the `spawnPersistentEntity` helper function from
- * respawning.
- *
- * @param persistentEntityIndex The index that was returned by the `spawnPersistentEntity` function.
- * @param removeEntity Optional. True by default. Set to false if you want to stop an entity from
- *                     being persistent but you don't want to actually remove the currently-spawned
- *                     entity from the room.
- */
-export function removePersistentEntity(
-  persistentEntityIndex: int,
-  removeEntity = true,
-): void {
-  v.level.persistentEntities.delete(persistentEntityIndex);
-
-  for (const [ptrHash, tuple] of v.room.spawnedPersistentEntities.entries()) {
-    const [index, entityPtr] = tuple;
-    if (index !== persistentEntityIndex) {
-      continue;
-    }
-
-    v.room.spawnedPersistentEntities.delete(ptrHash);
-
-    if (removeEntity && entityPtr.Ref !== undefined) {
-      entityPtr.Ref.Remove();
-    }
-  }
-}

package/features/playerInventory.ts

@@ -1,135 +0,0 @@
-import { 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 {
-  defaultMapGetPlayer,
-  mapSetPlayer,
-} from "../functions/playerDataStructures";
-import { getAllPlayers, getPlayerIndex } from "../functions/playerIndex";
-import { repeat } from "../functions/utils";
-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)),
-  },
-};
-
-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;
-}
-
-function resetInventory(player: EntityPlayer) {
-  const inventory = newPlayerInventory(player);
-  mapSetPlayer(v.run.playersInventory, player, 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_PLAYER_COLLECTIBLE_ADDED,
-    postCollectibleAdded,
-  );
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED,
-    postCollectibleRemoved,
-  );
-}
-
-// ModCallback.POST_USE_ITEM (3)
-// CollectibleType.D4 (284)
-function useItemD4(
-  _collectibleType: CollectibleType,
-  _rng: RNG,
-  player: EntityPlayer,
-): boolean | undefined {
-  resetInventory(player);
-
-  return undefined;
-}
-
-// 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.
-  for (const player of getAllPlayers()) {
-    const playerIndex = getPlayerIndex(player);
-    if (!v.run.playersInventory.has(playerIndex)) {
-      resetInventory(player);
-    }
-  }
-}
-
-// ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED
-function postCollectibleAdded(
-  player: EntityPlayer,
-  collectibleType: CollectibleType,
-) {
-  const inventory = defaultMapGetPlayer(v.run.playersInventory, player, player);
-  inventory.push(collectibleType);
-}
-
-// ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED
-function postCollectibleRemoved(
-  player: EntityPlayer,
-  collectibleType: CollectibleType,
-) {
-  const inventory = defaultMapGetPlayer(v.run.playersInventory, player, player);
-  arrayRemoveInPlace(inventory, collectibleType);
-}
-
-/**
- * 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 inventory = defaultMapGetPlayer(v.run.playersInventory, player, player);
-
-  const copiedInventory = copyArray(inventory);
-  if (includeActiveCollectibles) {
-    return copiedInventory;
-  }
-
-  return copiedInventory.filter(
-    (collectibleType) => !isActiveCollectible(collectibleType),
-  );
-}

package/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);
-}