isaacscript-common 4.0.3 → 4.0.6

package/callbacks/postPitRender.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getPits } from "../functions/gridEntitySpecific";
-import {
-  postPitRenderFire,
-  postPitRenderHasSubscriptions,
-} from "./subscriptions/postPitRender";
-
-/** @internal */
-export function postPitRenderInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return postPitRenderHasSubscriptions();
-}
-
-// ModCallback.POST_RENDER (2)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const pit of getPits()) {
-    postPitRenderFire(pit);
-  }
-}

package/callbacks/postPitUpdate.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getPits } from "../functions/gridEntitySpecific";
-import {
-  postPitUpdateFire,
-  postPitUpdateHasSubscriptions,
-} from "./subscriptions/postPitUpdate";
-
-/** @internal */
-export function postPitUpdateInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-}
-
-function hasSubscriptions() {
-  return postPitUpdateHasSubscriptions();
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const pit of getPits()) {
-    postPitUpdateFire(pit);
-  }
-}

package/callbacks/postPlayerChangeHealth.ts

@@ -1,62 +0,0 @@
-import { DefaultMap } from "../classes/DefaultMap";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { HealthType } from "../enums/HealthType";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getEnumValues } from "../functions/enums";
-import { getPlayerHealthType } from "../functions/playerHealth";
-import { getPlayerIndex } from "../functions/playerIndex";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPlayerChangeHealthFire,
-  postPlayerChangeHealthHasSubscriptions,
-} from "./subscriptions/postPlayerChangeHealth";
-
-const v = {
-  run: {
-    playersHealthMap: new DefaultMap<PlayerIndex, Map<HealthType, int>>(
-      () => new Map(),
-    ),
-  },
-};
-
-/** @internal */
-export function postPlayerChangeHealthInit(mod: ModUpgraded): void {
-  saveDataManager("postPlayerChangeHealth", v, hasSubscriptions);
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return postPlayerChangeHealthHasSubscriptions();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  // We call the "getPlayerIndex" function with the "differentiateForgottenAndSoul" argument. If we
-  // don't differentiate between The Forgotten and The Soul, the callback will fire every time the
-  // player switches between the two.
-  const playerIndex = getPlayerIndex(player, true);
-  const playerHealthMap = v.run.playersHealthMap.getAndSetDefault(playerIndex);
-
-  for (const healthType of getEnumValues(HealthType)) {
-    const storedHealthValue = playerHealthMap.get(healthType);
-    const currentHealthValue = getPlayerHealthType(player, healthType);
-    playerHealthMap.set(healthType, currentHealthValue);
-
-    if (
-      storedHealthValue !== undefined &&
-      storedHealthValue !== currentHealthValue
-    ) {
-      const difference = currentHealthValue - storedHealthValue;
-      postPlayerChangeHealthFire(player, healthType, difference);
-    }
-  }
-}

package/callbacks/postPlayerChangeType.ts

@@ -1,56 +0,0 @@
-import { PlayerType } from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  defaultMapGetPlayer,
-  mapSetPlayer,
-} from "../functions/playerDataStructures";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPlayerChangeTypeFire,
-  postPlayerChangeTypeHasSubscriptions,
-} from "./subscriptions/postPlayerChangeType";
-
-const v = {
-  run: {
-    playersCharacterMap: new DefaultMap<
-      PlayerIndex,
-      PlayerType,
-      [character: PlayerType]
-    >((character: PlayerType) => character), // eslint-disable-line isaacscript/strict-enums
-  },
-};
-
-/** @internal */
-export function postPlayerChangeTypeInit(mod: ModUpgraded): void {
-  saveDataManager("postPlayerChangeType", v, hasSubscriptions);
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return postPlayerChangeTypeHasSubscriptions();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const character = player.GetPlayerType();
-  const storedCharacter = defaultMapGetPlayer(
-    v.run.playersCharacterMap,
-    player,
-    character,
-  );
-  if (character !== storedCharacter) {
-    mapSetPlayer(v.run.playersCharacterMap, player, character);
-    postPlayerChangeTypeFire(player, storedCharacter, character);
-  }
-}

package/callbacks/postPlayerCollectible.ts

@@ -1,113 +0,0 @@
-// This provides the logic for the following callbacks:
-// - PostPlayerCollectibleAdded
-// - PostPlayerCollectibleRemoved
-
-import { CollectibleType, ModCallback } from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getPlayerCollectibleMap } from "../functions/player";
-import {
-  defaultMapGetPlayer,
-  mapGetPlayer,
-  mapSetPlayer,
-} from "../functions/playerDataStructures";
-import { repeat } from "../functions/utils";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPlayerCollectibleAddedFire,
-  postPlayerCollectibleAddedHasSubscriptions,
-} from "./subscriptions/postPlayerCollectibleAdded";
-import {
-  postPlayerCollectibleRemovedFire,
-  postPlayerCollectibleRemovedHasSubscriptions,
-} from "./subscriptions/postPlayerCollectibleRemoved";
-
-const v = {
-  run: {
-    playersCollectibleCount: new Map<PlayerIndex, int>(),
-    playersCollectibleMap: new DefaultMap<
-      PlayerIndex,
-      Map<CollectibleType, int>,
-      [player: EntityPlayer]
-    >((player) => getPlayerCollectibleMap(player)),
-  },
-};
-
-/** @internal */
-export function postPlayerCollectibleCallbacksInit(mod: Mod): void {
-  saveDataManager("postPlayerCollectible", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
-}
-
-function hasSubscriptions() {
-  return (
-    postPlayerCollectibleAddedHasSubscriptions() ||
-    postPlayerCollectibleRemovedHasSubscriptions()
-  );
-}
-
-// ModCallback.POST_PEFFECT_UPDATE (4)
-function postPEffectUpdate(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const oldCollectibleCount = mapGetPlayer(
-    v.run.playersCollectibleCount,
-    player,
-  );
-  const newCollectibleCount = player.GetCollectibleCount();
-  mapSetPlayer(v.run.playersCollectibleCount, player, newCollectibleCount);
-
-  if (oldCollectibleCount === undefined) {
-    return;
-  }
-
-  const difference = newCollectibleCount - oldCollectibleCount;
-
-  if (difference > 0) {
-    collectibleCountChanged(player, difference, true);
-  } else if (difference < 0) {
-    collectibleCountChanged(player, difference * -1, false);
-  }
-}
-
-function collectibleCountChanged(
-  player: EntityPlayer,
-  numCollectiblesChanged: int,
-  increased: boolean,
-) {
-  const oldCollectibleMap = defaultMapGetPlayer(
-    v.run.playersCollectibleMap,
-    player,
-    player,
-  );
-  const newCollectibleMap = getPlayerCollectibleMap(player);
-  mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
-
-  const collectibleTypes = [
-    ...oldCollectibleMap.keys(),
-    ...newCollectibleMap.keys(),
-  ];
-
-  let numFired = 0;
-  for (const collectibleType of collectibleTypes) {
-    const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
-    const newNum = newCollectibleMap.get(collectibleType) ?? 0;
-    const difference = Math.abs(newNum - oldNum);
-
-    repeat(difference, () => {
-      if (increased) {
-        postPlayerCollectibleAddedFire(player, collectibleType);
-      } else {
-        postPlayerCollectibleRemovedFire(player, collectibleType);
-      }
-      numFired += 1;
-    });
-
-    if (numFired === numCollectiblesChanged) {
-      return;
-    }
-  }
-}

package/callbacks/postPlayerFatalDamage.ts

@@ -1,141 +0,0 @@
-import {
-  BossID,
-  CollectibleType,
-  DamageFlag,
-  DamageFlagZero,
-  EntityType,
-  ModCallback,
-} from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { mapGetPlayer, mapSetPlayer } from "../functions/playerDataStructures";
-import { isChildPlayer } from "../functions/playerIndex";
-import { isDamageToPlayerFatal, willPlayerRevive } from "../functions/revive";
-import { inBossRoomOf } from "../functions/rooms";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPlayerFatalDamageFire,
-  postPlayerFatalDamageHasSubscriptions,
-} from "./subscriptions/postPlayerFatalDamage";
-
-const v = {
-  run: {
-    /** Needed to detect if Glass Cannon will kill the player or not. */
-    playersLastDamageGameFrame: new Map<PlayerIndex, int>(),
-  },
-};
-
-/** @internal */
-export function postPlayerFatalDamageInit(mod: Mod): void {
-  saveDataManager("postPlayerFatalDamage", v);
-
-  mod.AddCallback(
-    ModCallback.ENTITY_TAKE_DMG,
-    entityTakeDmgPlayer,
-    EntityType.PLAYER,
-  ); // 11
-
-  mod.AddCallback(
-    ModCallback.PRE_USE_ITEM,
-    preUseItemBible,
-    CollectibleType.BIBLE,
-  ); // 23
-}
-
-function hasSubscriptions() {
-  return postPlayerFatalDamageHasSubscriptions();
-}
-
-// ModCallback.ENTITY_TAKE_DMG (11)
-// EntityType.PLAYER (1)
-function entityTakeDmgPlayer(
-  tookDamage: Entity,
-  damageAmount: float,
-  damageFlags: BitFlags<DamageFlag>,
-  damageSource: EntityRef,
-  damageCountdownFrames: int,
-): boolean | undefined {
-  if (!hasSubscriptions()) {
-    return undefined;
-  }
-
-  const player = tookDamage.ToPlayer();
-  if (player === undefined) {
-    return undefined;
-  }
-
-  // This callback should not trigger for the Strawman Keeper and other players that are "child"
-  // players.
-  if (isChildPlayer(player)) {
-    return undefined;
-  }
-
-  const gameFrameCount = game.GetFrameCount();
-  const lastDamageGameFrame = mapGetPlayer(
-    v.run.playersLastDamageGameFrame,
-    player,
-  );
-  mapSetPlayer(v.run.playersLastDamageGameFrame, player, gameFrameCount);
-
-  // If the player has a revival item such as Dead Cat, this will not be fatal damage.
-  if (willPlayerRevive(player)) {
-    return undefined;
-  }
-
-  if (
-    !isDamageToPlayerFatal(
-      player,
-      damageAmount,
-      damageSource,
-      lastDamageGameFrame,
-    )
-  ) {
-    return undefined;
-  }
-
-  const shouldSustainDeath = postPlayerFatalDamageFire(
-    player,
-    damageAmount,
-    damageFlags,
-    damageSource,
-    damageCountdownFrames,
-  );
-  if (shouldSustainDeath !== undefined) {
-    return shouldSustainDeath;
-  }
-
-  return undefined;
-}
-
-// ModCallback.PRE_USE_ITEM (23)
-// CollectibleType.BIBLE (33)
-function preUseItemBible(
-  _collectibleType: CollectibleType,
-  _rng: RNG,
-  player: EntityPlayer,
-): boolean | undefined {
-  if (!hasSubscriptions()) {
-    return undefined;
-  }
-
-  // Using The Bible on Satan is one of the few ways to die without taking damage, so we need to
-  // handle this case.
-  if (!inBossRoomOf(BossID.SATAN)) {
-    return undefined;
-  }
-
-  const shouldSustainDeath = postPlayerFatalDamageFire(
-    player,
-    0,
-    DamageFlagZero,
-    EntityRef(player),
-    0,
-  );
-  if (shouldSustainDeath !== undefined) {
-    // End-users will return false to stop the damage from being fatal. We have to return true to
-    // prevent the Bible from firing.
-    return !shouldSustainDeath;
-  }
-
-  return undefined;
-}

package/callbacks/postPlayerInitLate.ts

@@ -1,37 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { setAddPlayer, setHasPlayer } from "../functions/playerDataStructures";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPlayerInitLateFire,
-  postPlayerInitLateHasSubscriptions,
-} from "./subscriptions/postPlayerInitLate";
-
-const v = {
-  run: {
-    playersFiredSet: new Set<PlayerIndex>(),
-  },
-};
-
-/** @internal */
-export function postPlayerInitLateInit(mod: Mod): void {
-  saveDataManager("postPlayerInitLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_PLAYER_UPDATE, postPlayerUpdate); // 31
-}
-
-function hasSubscriptions() {
-  return postPlayerInitLateHasSubscriptions();
-}
-
-// ModCallback.POST_PLAYER_UPDATE (31)
-function postPlayerUpdate(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (!setHasPlayer(v.run.playersFiredSet, player)) {
-    setAddPlayer(v.run.playersFiredSet, player);
-    postPlayerInitLateFire(player);
-  }
-}

package/callbacks/postPlayerReordered.ts

@@ -1,142 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { emptyArray } from "../functions/array";
-import { getPlayerFromIndex, getPlayerIndex } from "../functions/playerIndex";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPEffectUpdateReorderedFire,
-  postPEffectUpdateReorderedHasSubscriptions,
-} from "./subscriptions/postPEffectUpdateReordered";
-import {
-  postPlayerInitReorderedFire,
-  postPlayerInitReorderedHasSubscriptions,
-} from "./subscriptions/postPlayerInitReordered";
-import {
-  postPlayerRenderReorderedFire,
-  postPlayerRenderReorderedHasSubscriptions,
-} from "./subscriptions/postPlayerRenderReordered";
-import {
-  postPlayerUpdateReorderedFire,
-  postPlayerUpdateReorderedHasSubscriptions,
-} from "./subscriptions/postPlayerUpdateReordered";
-
-const v = {
-  run: {
-    postGameStartedFiredOnThisRun: false,
-
-    postPlayerInitQueue: [] as PlayerIndex[],
-    postPEffectUpdateQueue: [] as PlayerIndex[],
-    postPlayerUpdateQueue: [] as PlayerIndex[],
-    postPlayerRenderQueue: [] as PlayerIndex[],
-  },
-};
-
-/** @internal */
-export function postPlayerReorderedCallbacksInit(mod: Mod): void {
-  saveDataManager("postPlayerReordered", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
-  mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit); // 9
-  mod.AddCallback(ModCallback.POST_PLAYER_UPDATE, postPlayerUpdate); // 31
-  mod.AddCallback(ModCallback.POST_PLAYER_RENDER, postPlayerRender); // 32
-
-  mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
-}
-
-function hasSubscriptions() {
-  return (
-    postPlayerInitReorderedHasSubscriptions() ||
-    postPEffectUpdateReorderedHasSubscriptions() ||
-    postPlayerUpdateReorderedHasSubscriptions() ||
-    postPlayerRenderReorderedHasSubscriptions()
-  );
-}
-
-// ModCallback.POST_PEFFECT_UPDATE (4)
-function postPEffectUpdate(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (v.run.postGameStartedFiredOnThisRun) {
-    postPEffectUpdateReorderedFire(player);
-  } else {
-    // Defer callback execution until the PostGameStarted callback fires.
-    const playerIndex = getPlayerIndex(player);
-    v.run.postPEffectUpdateQueue.push(playerIndex);
-  }
-}
-
-// ModCallback.POST_PLAYER_INIT (9)
-function postPlayerInit(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (v.run.postGameStartedFiredOnThisRun) {
-    postPlayerInitReorderedFire(player);
-  } else {
-    // Defer callback execution until the PostGameStarted callback fires.
-    const playerIndex = getPlayerIndex(player);
-    v.run.postPlayerInitQueue.push(playerIndex);
-  }
-}
-
-// ModCallback.POST_PLAYER_UPDATE (31)
-function postPlayerUpdate(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (v.run.postGameStartedFiredOnThisRun) {
-    postPlayerUpdateReorderedFire(player);
-  } else {
-    // Defer callback execution until the PostGameStarted callback fires.
-    const playerIndex = getPlayerIndex(player);
-    v.run.postPlayerUpdateQueue.push(playerIndex);
-  }
-}
-
-// ModCallback.POST_PLAYER_RENDER (32)
-function postPlayerRender(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (v.run.postGameStartedFiredOnThisRun) {
-    postPlayerRenderReorderedFire(player);
-  } else {
-    // Defer callback execution until the PostGameStarted callback fires.
-    const playerIndex = getPlayerIndex(player);
-    v.run.postPlayerRenderQueue.push(playerIndex);
-  }
-}
-
-// ModCallback.POST_GAME_STARTED (15)
-function postGameStarted() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  v.run.postGameStartedFiredOnThisRun = true;
-
-  dequeue(v.run.postPlayerInitQueue, postPlayerInitReorderedFire);
-  dequeue(v.run.postPlayerUpdateQueue, postPlayerUpdateReorderedFire);
-  dequeue(v.run.postPlayerRenderQueue, postPlayerRenderReorderedFire);
-}
-
-function dequeue(
-  playerIndexes: PlayerIndex[],
-  fireFunction: (player: EntityPlayer) => void,
-) {
-  for (const playerIndex of playerIndexes) {
-    const player = getPlayerFromIndex(playerIndex);
-    if (player === undefined) {
-      continue;
-    }
-
-    fireFunction(player);
-  }
-
-  emptyArray(playerIndexes);
-}

package/callbacks/postPoopRender.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getPoops } from "../functions/gridEntitySpecific";
-import {
-  postPoopRenderFire,
-  postPoopRenderHasSubscriptions,
-} from "./subscriptions/postPoopRender";
-
-/** @internal */
-export function postPoopRenderInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return postPoopRenderHasSubscriptions();
-}
-
-// ModCallback.POST_RENDER (2)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const poop of getPoops()) {
-    postPoopRenderFire(poop);
-  }
-}

package/callbacks/postPoopUpdate.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getPoops } from "../functions/gridEntitySpecific";
-import {
-  postPoopUpdateFire,
-  postPoopUpdateHasSubscriptions,
-} from "./subscriptions/postPoopUpdate";
-
-/** @internal */
-export function postPoopUpdateInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-}
-
-function hasSubscriptions() {
-  return postPoopUpdateHasSubscriptions();
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const poop of getPoops()) {
-    postPoopUpdateFire(poop);
-  }
-}

package/callbacks/postPressurePlateRender.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getPressurePlates } from "../functions/gridEntitySpecific";
-import {
-  postPressurePlateRenderFire,
-  postPressurePlateRenderHasSubscriptions,
-} from "./subscriptions/postPressurePlateRender";
-
-/** @internal */
-export function postPressurePlateRenderInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return postPressurePlateRenderHasSubscriptions();
-}
-
-// ModCallback.POST_RENDER (2)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const pressurePlate of getPressurePlates()) {
-    postPressurePlateRenderFire(pressurePlate);
-  }
-}