isaacscript-common 4.0.0 → 4.0.1-dev.0

package/callbacks/postPlayerChangeHealth.ts

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

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+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);
+  }
+}

package/callbacks/postPressurePlateUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPressurePlates } from "../functions/gridEntitySpecific";
+import {
+  postPressurePlateUpdateFire,
+  postPressurePlateUpdateHasSubscriptions,
+} from "./subscriptions/postPressurePlateUpdate";
+
+/** @internal */
+export function postPressurePlateUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postPressurePlateUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const pressurePlate of getPressurePlates()) {
+    postPressurePlateUpdateFire(pressurePlate);
+  }
+}

package/callbacks/postProjectileInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postProjectileInitLateFire,
+  postProjectileInitLateHasSubscriptions,
+} from "./subscriptions/postProjectileInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postProjectileInitLateInit(mod: Mod): void {
+  saveDataManager("postProjectileInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PROJECTILE_UPDATE, postProjectileUpdate); // 44
+}
+
+function hasSubscriptions() {
+  return postProjectileInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_PROJECTILE_UPDATE (44)
+function postProjectileUpdate(projectile: EntityProjectile) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(projectile);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postProjectileInitLateFire(projectile);
+  }
+}