isaacscript-common 14.1.3 → 15.0.0

package/src/callbacks/postSlotDestroyed.ts

@@ -1,92 +0,0 @@
-// Normally, when a slot is destroyed, the grid collision class changes to
-// `EntityGridCollisionClass.GROUND` and sticks around in the room. Thus, checking for this case is
-// simple.
-
-// The special case is when a slot pays out with a collectible item. In this case, it will not stay
-// in the room. Instead, it will play the "Prize" animation for 3 game frames, and then despawn (to
-// be replaced by a collectible entity). Subsequently, we handle this case by assuming that if the
-// slot disappeared 3 frames after it changed to a prize animation, it was a destruction pay-out.
-
-import {
-  EntityGridCollisionClass,
-  EntityType,
-  ModCallback,
-} from "isaac-typescript-definitions";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { game } from "../core/cachedClasses";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { SlotDestructionType } from "../enums/SlotDestructionType";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postSlotDestroyedFire,
-  postSlotDestroyedHasSubscriptions,
-} from "./subscriptions/postSlotDestroyed";
-
-const PRIZE_GAME_FRAME_DELAY_UNTIL_REMOVAL = 3;
-
-const v = {
-  room: {
-    brokenSlots: new Set<PtrHash>(),
-    slotPrizeAnimationGameFrame: new Map<PtrHash, int>(),
-  },
-};
-
-export function postSlotDestroyedInit(mod: ModUpgraded): void {
-  saveDataManager("postSlotDestroyed", v, hasSubscriptions);
-
-  mod.AddCallback(
-    ModCallback.POST_ENTITY_REMOVE,
-    postEntityRemoveSlot,
-    EntityType.SLOT,
-  ); // 67
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED,
-    postSlotAnimationChanged,
-  );
-}
-
-function hasSubscriptions() {
-  return postSlotDestroyedHasSubscriptions();
-}
-
-// ModCallback.POST_ENTITY_REMOVE (67)
-// EntityType.SLOT (6)
-function postEntityRemoveSlot(entity: Entity) {
-  const slot = entity as EntitySlot;
-  const ptrHash = GetPtrHash(slot);
-  const gameFrameCount = game.GetFrameCount();
-
-  const prizeFrame = v.room.slotPrizeAnimationGameFrame.get(ptrHash);
-  if (prizeFrame === undefined) {
-    return;
-  }
-
-  if (prizeFrame + PRIZE_GAME_FRAME_DELAY_UNTIL_REMOVAL === gameFrameCount) {
-    postSlotDestroyedFire(slot, SlotDestructionType.COLLECTIBLE_PAYOUT);
-  }
-}
-
-// ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED
-function postSlotAnimationChanged(slot: EntitySlot) {
-  const ptrHash = GetPtrHash(slot);
-  const gameFrameCount = game.GetFrameCount();
-
-  const alreadyBroken = v.room.brokenSlots.has(ptrHash);
-  if (alreadyBroken) {
-    return;
-  }
-
-  if (slot.GridCollisionClass === EntityGridCollisionClass.GROUND) {
-    v.room.brokenSlots.add(ptrHash);
-    postSlotDestroyedFire(slot, SlotDestructionType.NORMAL);
-  }
-
-  const sprite = slot.GetSprite();
-  const animation = sprite.GetAnimation();
-  if (animation === "Prize") {
-    v.room.slotPrizeAnimationGameFrame.set(ptrHash, gameFrameCount);
-  } else {
-    v.room.slotPrizeAnimationGameFrame.delete(ptrHash);
-  }
-}

package/src/callbacks/postSlotInitUpdate.ts

@@ -1,70 +0,0 @@
-// This provides the logic for the following callbacks:
-// - `POST_SLOT_INIT`
-// - `POST_SLOT_UPDATE`
-
-// (The other slot callbacks are handled in a different file.)
-
-import { ModCallback } from "isaac-typescript-definitions";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getSlots } from "../functions/entitiesSpecific";
-import {
-  postSlotInitFire,
-  postSlotInitHasSubscriptions,
-} from "./subscriptions/postSlotInit";
-import {
-  postSlotUpdateFire,
-  postSlotUpdateHasSubscriptions,
-} from "./subscriptions/postSlotUpdate";
-
-const v = {
-  room: {
-    initializedSlots: new Set<PtrHash>(),
-  },
-};
-
-export function postSlotInitUpdateCallbacksInit(mod: ModUpgraded): void {
-  saveDataManager("postSlotInitUpdate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
-    postNewRoomReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return postSlotInitHasSubscriptions() || postSlotUpdateHasSubscriptions();
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const slot of getSlots()) {
-    checkNewEntity(slot);
-    postSlotUpdateFire(slot);
-  }
-}
-
-// ModCallbackCustom.POST_NEW_ROOM_REORDERED
-function postNewRoomReordered() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const slot of getSlots()) {
-    checkNewEntity(slot);
-  }
-}
-
-function checkNewEntity(slot: EntitySlot) {
-  const ptrHash = GetPtrHash(slot);
-  if (!v.room.initializedSlots.has(ptrHash)) {
-    v.room.initializedSlots.add(ptrHash);
-    postSlotInitFire(slot);
-  }
-}

package/src/callbacks/postSlotRender.ts

@@ -1,68 +0,0 @@
-// This provides the logic for the following callbacks:
-// - `POST_SLOT_RENDER`
-// - `POST_SLOT_ANIMATION_CHANGED`
-
-import { ModCallback } from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getSlots } from "../functions/entitiesSpecific";
-import {
-  postSlotAnimationChangedFire,
-  postSlotAnimationChangedHasSubscriptions,
-} from "./subscriptions/postSlotAnimationChanged";
-import {
-  postSlotRenderFire,
-  postSlotRenderHasSubscriptions,
-} from "./subscriptions/postSlotRender";
-
-const v = {
-  room: {
-    slotAnimations: new DefaultMap<PtrHash, string, [slot: Entity]>(
-      (slot: Entity) => {
-        const sprite = slot.GetSprite();
-        return sprite.GetAnimation();
-      },
-    ),
-    brokenSlots: new Set<PtrHash>(),
-  },
-};
-
-export function postSlotRenderCallbacksInit(mod: Mod): void {
-  saveDataManager("postSlotRender", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return (
-    postSlotRenderHasSubscriptions() ||
-    postSlotAnimationChangedHasSubscriptions()
-  );
-}
-
-// ModCallback.POST_UPDATE (1)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const slot of getSlots()) {
-    postSlotRenderFire(slot);
-    checkSlotAnimationChanged(slot);
-  }
-}
-
-function checkSlotAnimationChanged(slot: EntitySlot) {
-  const sprite = slot.GetSprite();
-  const currentAnimation = sprite.GetAnimation();
-  const ptrHash = GetPtrHash(slot);
-  const previousAnimation = v.room.slotAnimations.getAndSetDefault(
-    ptrHash,
-    slot,
-  );
-  v.room.slotAnimations.set(ptrHash, currentAnimation);
-
-  if (currentAnimation !== previousAnimation) {
-    postSlotAnimationChangedFire(slot, previousAnimation, currentAnimation);
-  }
-}

package/src/callbacks/postSpikesRender.ts

@@ -1,25 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getSpikes } from "../functions/gridEntitiesSpecific";
-import {
-  postSpikesRenderFire,
-  postSpikesRenderHasSubscriptions,
-} from "./subscriptions/postSpikesRender";
-
-export function postSpikesRenderInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return postSpikesRenderHasSubscriptions();
-}
-
-// ModCallback.POST_RENDER (2)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const spikes of getSpikes()) {
-    postSpikesRenderFire(spikes);
-  }
-}

package/src/callbacks/postSpikesUpdate.ts

@@ -1,25 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getSpikes } from "../functions/gridEntitiesSpecific";
-import {
-  postSpikesUpdateFire,
-  postSpikesUpdateHasSubscriptions,
-} from "./subscriptions/postSpikesUpdate";
-
-export function postSpikesUpdateInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-}
-
-function hasSubscriptions() {
-  return postSpikesUpdateHasSubscriptions();
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const spikes of getSpikes()) {
-    postSpikesUpdateFire(spikes);
-  }
-}

package/src/callbacks/postTNTRender.ts

@@ -1,25 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getTNT } from "../functions/gridEntitiesSpecific";
-import {
-  postTNTRenderFire,
-  postTNTRenderHasSubscriptions,
-} from "./subscriptions/postTNTRender";
-
-export function postTNTRenderInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return postTNTRenderHasSubscriptions();
-}
-
-// ModCallback.POST_RENDER (2)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const tnt of getTNT()) {
-    postTNTRenderFire(tnt);
-  }
-}

package/src/callbacks/postTNTUpdate.ts

@@ -1,25 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getTNT } from "../functions/gridEntitiesSpecific";
-import {
-  postTNTUpdateFire,
-  postTNTUpdateHasSubscriptions,
-} from "./subscriptions/postTNTUpdate";
-
-export function postTNTUpdateInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-}
-
-function hasSubscriptions() {
-  return postTNTUpdateHasSubscriptions();
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const tnt of getTNT()) {
-    postTNTUpdateFire(tnt);
-  }
-}

package/src/callbacks/postTearInitLate.ts

@@ -1,35 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postTearInitLateFire,
-  postTearInitLateHasSubscriptions,
-} from "./subscriptions/postTearInitLate";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-export function postTearInitLateInit(mod: Mod): void {
-  saveDataManager("postTearInitLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_TEAR_UPDATE, postTearUpdate); // 40
-}
-
-function hasSubscriptions() {
-  return postTearInitLateHasSubscriptions();
-}
-
-// ModCallback.POST_TEAR_UPDATE (40)
-function postTearUpdate(tear: EntityTear) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const index = GetPtrHash(tear);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-    postTearInitLateFire(tear);
-  }
-}

package/src/callbacks/postTearInitVeryLate.ts

@@ -1,40 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postTearInitVeryLateFire,
-  postTearInitVeryLateHasSubscriptions,
-} from "./subscriptions/postTearInitVeryLate";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-export function postTearInitVeryLateInit(mod: Mod): void {
-  saveDataManager("postTearInitVeryLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_TEAR_UPDATE, postTearUpdate); // 40
-}
-
-function hasSubscriptions() {
-  return postTearInitVeryLateHasSubscriptions();
-}
-
-// ModCallback.POST_TEAR_UPDATE (40)
-function postTearUpdate(tear: EntityTear) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  // This callback fires on frame 1.
-  if (tear.FrameCount === 0) {
-    return;
-  }
-
-  const index = GetPtrHash(tear);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-    postTearInitVeryLateFire(tear);
-  }
-}

package/src/callbacks/postTransformation.ts

@@ -1,62 +0,0 @@
-import { PlayerForm } 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 { getEnumValues } from "../functions/enums";
-import { defaultMapGetPlayer } from "../functions/playerDataStructures";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postTransformationFire,
-  postTransformationHasSubscriptions,
-} from "./subscriptions/postTransformation";
-
-const PLAYER_FORMS: readonly PlayerForm[] = getEnumValues(PlayerForm);
-
-const v = {
-  run: {
-    // We cannot use a nested `DefaultMap` here.
-    playersTransformationsMap: new DefaultMap<
-      PlayerIndex,
-      Map<PlayerForm, boolean>
-    >(() => new Map()),
-  },
-};
-
-export function postTransformationInit(mod: ModUpgraded): void {
-  saveDataManager("postTransformation", v, hasSubscriptions);
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return postTransformationHasSubscriptions();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const playerTransformationsMap = defaultMapGetPlayer(
-    v.run.playersTransformationsMap,
-    player,
-  );
-
-  for (const playerForm of PLAYER_FORMS) {
-    const hasForm = player.HasPlayerForm(playerForm);
-    let storedForm = playerTransformationsMap.get(playerForm);
-    if (storedForm === undefined) {
-      storedForm = false;
-    }
-
-    if (hasForm !== storedForm) {
-      playerTransformationsMap.set(playerForm, hasForm);
-      postTransformationFire(player, playerForm, hasForm);
-    }
-  }
-}

package/src/callbacks/postTrinketBreak.ts

@@ -1,115 +0,0 @@
-import {
-  DamageFlag,
-  EntityType,
-  ModCallback,
-  PickupVariant,
-  TrinketType,
-} 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 } from "../functions/playerDataStructures";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postTrinketBreakFire,
-  postTrinketBreakHasSubscriptions,
-} from "./subscriptions/postTrinketBreak";
-
-const TRINKETS_THAT_CAN_BREAK: readonly TrinketType[] = [
-  TrinketType.WISH_BONE,
-  TrinketType.WALNUT,
-];
-
-const v = {
-  run: {
-    // We cannot use a nested `DefaultMap` here.
-    playersTrinketMap: new DefaultMap<PlayerIndex, Map<TrinketType, int>>(
-      () => new Map(),
-    ),
-  },
-};
-
-export function postTrinketBreakInit(mod: ModUpgraded): void {
-  saveDataManager("postTrinketBreak", v, hasSubscriptions);
-
-  mod.AddCallback(
-    ModCallback.ENTITY_TAKE_DMG,
-    entityTakeDmgPlayer,
-    EntityType.PLAYER,
-  ); // 11
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return postTrinketBreakHasSubscriptions();
-}
-
-// ModCallback.ENTITY_TAKE_DMG (11)
-// EntityType.PLAYER (1)
-function entityTakeDmgPlayer(
-  entity: Entity,
-  _amount: float,
-  _damageFlags: BitFlags<DamageFlag>,
-  _source: EntityRef,
-  _countdownFrames: int,
-): boolean | undefined {
-  if (!hasSubscriptions()) {
-    return undefined;
-  }
-
-  const player = entity.ToPlayer();
-  if (player === undefined) {
-    return undefined;
-  }
-
-  const trinketMap = defaultMapGetPlayer(v.run.playersTrinketMap, player);
-
-  for (const trinketType of TRINKETS_THAT_CAN_BREAK) {
-    const numTrinketsHeld = player.GetTrinketMultiplier(trinketType);
-    let oldNumTrinketsHeld = trinketMap.get(trinketType);
-    if (oldNumTrinketsHeld === undefined) {
-      oldNumTrinketsHeld = 0;
-    }
-
-    if (numTrinketsHeld >= oldNumTrinketsHeld) {
-      continue;
-    }
-
-    trinketMap.set(trinketType, numTrinketsHeld);
-
-    // Ensure that the trinket was not dropped on the ground.
-    const numTrinketsOnGround = Isaac.CountEntities(
-      undefined,
-      EntityType.PICKUP,
-      PickupVariant.TRINKET,
-      trinketType,
-    );
-    if (numTrinketsOnGround > 0) {
-      continue;
-    }
-
-    postTrinketBreakFire(player, trinketType);
-  }
-
-  return undefined;
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  // On every frame, keep track of how many trinkets we have.
-  const trinketMap = defaultMapGetPlayer(v.run.playersTrinketMap, player);
-
-  for (const trinketType of TRINKETS_THAT_CAN_BREAK) {
-    const numTrinkets = player.GetTrinketMultiplier(trinketType);
-    trinketMap.set(trinketType, numTrinkets);
-  }
-}

package/src/callbacks/preBerserkDeath.ts

@@ -1,48 +0,0 @@
-import { CollectibleType } from "isaac-typescript-definitions";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { isChildPlayer } from "../functions/playerIndex";
-import { getPlayerNumHitsRemaining } from "../functions/players";
-import { willPlayerRevive } from "../functions/revive";
-import {
-  preBerserkDeathFire,
-  preBerserkDeathHasSubscriptions,
-} from "./subscriptions/preBerserkDeath";
-
-export function preBerserkDeathInit(mod: ModUpgraded): void {
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return preBerserkDeathHasSubscriptions();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  // This callback should not trigger for the Strawman Keeper and other players that are "child"
-  // players.
-  if (isChildPlayer(player)) {
-    return;
-  }
-
-  const effects = player.GetEffects();
-  const berserkEffect = effects.GetCollectibleEffect(CollectibleType.BERSERK);
-  const numHitsRemaining = getPlayerNumHitsRemaining(player);
-
-  // If the Berserk effect will end on the next frame and we have no hearts left.
-  if (
-    berserkEffect !== undefined &&
-    berserkEffect.Cooldown === 1 &&
-    numHitsRemaining === 0 &&
-    !willPlayerRevive(player)
-  ) {
-    preBerserkDeathFire(player);
-  }
-}

package/src/callbacks/preGetPedestal.ts

@@ -1,60 +0,0 @@
-import {
-  CollectibleType,
-  ModCallback,
-  PickupVariant,
-} from "isaac-typescript-definitions";
-import {
-  preGetPedestalFire,
-  preGetPedestalHasSubscriptions,
-} from "./subscriptions/preGetPedestal";
-
-export function preGetPedestalInit(mod: Mod): void {
-  mod.AddCallback(
-    ModCallback.PRE_PICKUP_COLLISION,
-    prePickupCollision,
-    PickupVariant.COLLECTIBLE,
-  ); // 38
-}
-
-function hasSubscriptions() {
-  return preGetPedestalHasSubscriptions();
-}
-
-// ModCallback.PRE_PICKUP_COLLISION (35)
-function prePickupCollision(
-  pickup: EntityPickup,
-  collider: Entity,
-  _low: boolean,
-): boolean | undefined {
-  if (!hasSubscriptions()) {
-    return undefined;
-  }
-
-  const collectible = pickup as EntityPickupCollectible;
-
-  if (collectible.SubType === CollectibleType.NULL) {
-    return undefined;
-  }
-
-  const player = collider.ToPlayer();
-  if (player === undefined) {
-    return undefined;
-  }
-
-  const numCoins = player.GetNumCoins();
-  if (collectible.Price > numCoins) {
-    return undefined;
-  }
-
-  // Collectibles have a special variable to prevent them from being picked up for a certain time.
-  // Players have special variable to prevent them from picking up a collectible for a certain time.
-  if (collectible.Wait > 0 || player.ItemHoldCooldown > 0) {
-    return undefined;
-  }
-
-  if (player.IsHoldingItem()) {
-    return undefined;
-  }
-
-  return preGetPedestalFire(player, collectible);
-}