isaacscript-common 2.3.0 → 2.3.1

package/src/callbacks/postSlotInitUpdate.ts

@@ -1,63 +0,0 @@
-// This provides the logic for the PostSlotInit and PostSlotUpdate callbacks. (The other slot
-// callbacks are handled in a different file.)
-
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getSlots } from "../functions/entitySpecific";
-import {
-  postSlotInitFire,
-  postSlotInitHasSubscriptions,
-} from "./subscriptions/postSlotInit";
-import {
-  postSlotUpdateFire,
-  postSlotUpdateHasSubscriptions,
-} from "./subscriptions/postSlotUpdate";
-
-const v = {
-  room: {
-    initializedSlots: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postSlotInitUpdateCallbacksInit(mod: Mod): void {
-  saveDataManager("postSlotInitUpdate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-  mod.AddCallback(ModCallback.POST_NEW_ROOM, postNewRoom); // 9
-}
-
-function hasSubscriptions() {
-  return postSlotInitHasSubscriptions() || postSlotUpdateHasSubscriptions();
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const slot of getSlots()) {
-    checkNewEntity(slot);
-    postSlotUpdateFire(slot);
-  }
-}
-
-// ModCallback.POST_NEW_ROOM (9)
-function postNewRoom() {
-  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,96 +0,0 @@
-// This provides the logic for the following callbacks:
-// - PostSlotRender
-// - PostSlotAnimationChanged
-// - PostSlotBroken
-
-import { ModCallback } from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getSlots } from "../functions/entitySpecific";
-import {
-  postSlotAnimationChangedFire,
-  postSlotAnimationChangedHasSubscriptions,
-} from "./subscriptions/postSlotAnimationChanged";
-import {
-  postSlotDestroyedFire,
-  postSlotDestroyedHasSubscriptions,
-} from "./subscriptions/postSlotDestroyed";
-import {
-  postSlotRenderFire,
-  postSlotRenderHasSubscriptions,
-} from "./subscriptions/postSlotRender";
-
-const BROKEN_ANIMATIONS: ReadonlySet<string> = new Set([
-  "Broken", // Normal machines
-  "Death", // Restock machines
-]);
-
-const v = {
-  room: {
-    slotAnimations: new DefaultMap<PtrHash, string, [slot: Entity]>(
-      (slot: Entity) => {
-        const sprite = slot.GetSprite();
-        return sprite.GetAnimation();
-      },
-    ),
-    brokenSlots: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postSlotRenderCallbacksInit(mod: Mod): void {
-  saveDataManager("postSlotRender", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return (
-    postSlotRenderHasSubscriptions() ||
-    postSlotDestroyedHasSubscriptions() ||
-    postSlotAnimationChangedHasSubscriptions()
-  );
-}
-
-// ModCallback.POST_UPDATE (1)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const slot of getSlots()) {
-    postSlotRenderFire(slot);
-    checkSlotAnimationChanged(slot);
-    checkSlotBroken(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);
-  }
-}
-
-function checkSlotBroken(slot: EntitySlot) {
-  const ptrHash = GetPtrHash(slot);
-  const alreadyBroken = v.room.brokenSlots.has(ptrHash);
-  if (alreadyBroken) {
-    return;
-  }
-
-  const sprite = slot.GetSprite();
-  const animation = sprite.GetAnimation();
-  if (BROKEN_ANIMATIONS.has(animation)) {
-    v.room.brokenSlots.add(ptrHash);
-    postSlotDestroyedFire(slot);
-  }
-}

package/src/callbacks/postSpikesRender.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getSpikes } from "../functions/gridEntitySpecific";
-import {
-  postSpikesRenderFire,
-  postSpikesRenderHasSubscriptions,
-} from "./subscriptions/postSpikesRender";
-
-/** @internal */
-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,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getSpikes } from "../functions/gridEntitySpecific";
-import {
-  postSpikesUpdateFire,
-  postSpikesUpdateHasSubscriptions,
-} from "./subscriptions/postSpikesUpdate";
-
-/** @internal */
-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,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getTNT } from "../functions/gridEntitySpecific";
-import {
-  postTNTRenderFire,
-  postTNTRenderHasSubscriptions,
-} from "./subscriptions/postTNTRender";
-
-/** @internal */
-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,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getTNT } from "../functions/gridEntitySpecific";
-import {
-  postTNTUpdateFire,
-  postTNTUpdateHasSubscriptions,
-} from "./subscriptions/postTNTUpdate";
-
-/** @internal */
-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,36 +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>(),
-  },
-};
-
-/** @internal */
-export function postTearInitLateCallbackInit(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,41 +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>(),
-  },
-};
-
-/** @internal */
-export function postTearInitVeryLateCallbackInit(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,59 +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: {
-    playersTransformationsMap: new DefaultMap<
-      PlayerIndex,
-      DefaultMap<PlayerForm, boolean>
-    >(() => new DefaultMap(false)),
-  },
-};
-
-/** @internal */
-export function postTransformationCallbackInit(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);
-    const storedForm = playerTransformationsMap.getAndSetDefault(playerForm);
-
-    if (hasForm !== storedForm) {
-      playerTransformationsMap.set(playerForm, hasForm);
-      postTransformationFire(player, playerForm, hasForm);
-    }
-  }
-}

package/src/callbacks/postTrinketBreak.ts

@@ -1,110 +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: {
-    playersTrinketMap: new DefaultMap<
-      PlayerIndex,
-      DefaultMap<TrinketType, int>
-    >(() => new DefaultMap(0)),
-  },
-};
-
-/** @internal */
-export function postTrinketBreakCallbackInit(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(
-  tookDamage: Entity,
-  _damageAmount: float,
-  _damageFlags: BitFlags<DamageFlag>,
-  _damageSource: EntityRef,
-  _damageCountdownFrames: int,
-) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const player = tookDamage.ToPlayer();
-  if (player === undefined) {
-    return;
-  }
-
-  const trinketMap = defaultMapGetPlayer(v.run.playersTrinketMap, player);
-
-  for (const trinketType of TRINKETS_THAT_CAN_BREAK) {
-    const numTrinketsHeld = player.GetTrinketMultiplier(trinketType);
-    const oldNumTrinketsHeld = trinketMap.getAndSetDefault(trinketType);
-    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);
-  }
-}
-
-// 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,49 +0,0 @@
-import { CollectibleType } from "isaac-typescript-definitions";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { getPlayerNumHitsRemaining } from "../functions/player";
-import { isChildPlayer } from "../functions/playerIndex";
-import { willPlayerRevive } from "../functions/revive";
-import {
-  preBerserkDeathFire,
-  preBerserkDeathHasSubscriptions,
-} from "./subscriptions/preBerserkDeath";
-
-/** @internal */
-export function preBerserkDeathCallbackInit(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/preNewLevel.ts

@@ -1,55 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getLastFrameOfAnimation } from "../functions/sprite";
-import { getEffectiveStage } from "../functions/stage";
-import {
-  preNewLevelFire,
-  preNewLevelHasSubscriptions,
-} from "./subscriptions/preNewLevel";
-
-const TRAVELING_TO_NEXT_FLOOR_ANIMATIONS: ReadonlySet<string> = new Set([
-  "Trapdoor",
-  "LightTravel",
-]);
-
-/**
- * Since there can be multiple players, use this variable to ensure that we only fire the custom
- * callback once per stage.
- */
-let firedOnStage: int | null = null;
-
-/** @internal */
-export function preNewLevelCallbackInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_PLAYER_RENDER, postPlayerRender); // 32
-}
-
-function hasSubscriptions() {
-  return preNewLevelHasSubscriptions();
-}
-
-// ModCallback.POST_PLAYER_RENDER (32)
-function postPlayerRender(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const effectiveStage = getEffectiveStage();
-  if (effectiveStage === firedOnStage) {
-    return;
-  }
-
-  const sprite = player.GetSprite();
-  const animation = sprite.GetAnimation();
-  if (!TRAVELING_TO_NEXT_FLOOR_ANIMATIONS.has(animation)) {
-    return;
-  }
-
-  // We can't use the `Sprite.IsFinished` method to detect when we are at the end of the animation
-  // because the player will stop rendering at that point. Thus, revert to checking for the final
-  // frame manually.
-  const frame = sprite.GetFrame();
-  const finalFrame = getLastFrameOfAnimation(sprite);
-  if (frame === finalFrame) {
-    firedOnStage = effectiveStage;
-    preNewLevelFire(player);
-  }
-}