isaacscript-common 4.0.2 → 4.0.5

package/callbacks/postBombExploded.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { BOMB_EXPLODE_FRAME } from "../constants";
-import {
-  postBombExplodedFire,
-  postBombExplodedHasSubscriptions,
-} from "./subscriptions/postBoneExploded";
-
-/** @internal */
-export function postBombExplodedInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_BOMB_UPDATE, postBombUpdate); // 58
-}
-
-function hasSubscriptions() {
-  return postBombExplodedHasSubscriptions();
-}
-
-// ModCallback.POST_BOMB_UPDATE (58)
-function postBombUpdate(bomb: EntityBomb) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (bomb.FrameCount === BOMB_EXPLODE_FRAME) {
-    postBombExplodedFire(bomb);
-  }
-}

package/callbacks/postBombInitLate.ts

@@ -1,36 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postBombInitLateFire,
-  postBombInitLateHasSubscriptions,
-} from "./subscriptions/postBombInitLate";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postBombInitLateInit(mod: Mod): void {
-  saveDataManager("postBombInitLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_BOMB_UPDATE, postBombUpdate); // 58
-}
-
-function hasSubscriptions() {
-  return postBombInitLateHasSubscriptions();
-}
-
-// ModCallback.POST_BOMB_UPDATE (58)
-function postBombUpdate(bomb: EntityBomb) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const index = GetPtrHash(bomb);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-    postBombInitLateFire(bomb);
-  }
-}

package/callbacks/postBoneSwing.ts

@@ -1,64 +0,0 @@
-import { KnifeVariant, ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postBoneSwingFire,
-  postBoneSwingHasSubscriptions,
-} from "./subscriptions/postBoneSwing";
-
-const BONE_SWING_ANIMATIONS: ReadonlySet<string> = new Set([
-  "Swing",
-  "Swing2",
-  "Spin",
-]);
-
-const v = {
-  room: {
-    boneClubAnimations: new Map<PtrHash, string>(),
-  },
-};
-
-/** @internal */
-export function postBoneSwingInit(mod: Mod): void {
-  saveDataManager("postBoneSwing", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_KNIFE_RENDER, postKnifeRender); // 52
-}
-
-function hasSubscriptions() {
-  return postBoneSwingHasSubscriptions();
-}
-
-// ModCallback.POST_KNIFE_RENDER (52)
-function postKnifeRender(knife: EntityKnife) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  // The PostKnifeRender callback cannot be registered with knife variants for some reason.
-  if (knife.Variant !== KnifeVariant.BONE_CLUB) {
-    return;
-  }
-
-  postKnifeRenderBoneClub(knife);
-}
-
-function postKnifeRenderBoneClub(boneClub: EntityKnife) {
-  const sprite = boneClub.GetSprite();
-  const animation = sprite.GetAnimation();
-  const ptrHash = GetPtrHash(boneClub);
-  const animationOnLastFrame = v.room.boneClubAnimations.get(ptrHash);
-  v.room.boneClubAnimations.set(ptrHash, animation);
-
-  if (
-    animationOnLastFrame !== undefined &&
-    animation !== animationOnLastFrame
-  ) {
-    boneClubAnimationChanged(boneClub, animation);
-  }
-}
-
-function boneClubAnimationChanged(boneClub: EntityKnife, animation: string) {
-  if (BONE_SWING_ANIMATIONS.has(animation)) {
-    postBoneSwingFire(boneClub);
-  }
-}

package/callbacks/postCollectibleInitFirst.ts

@@ -1,40 +0,0 @@
-import { ModCallback, PickupVariant } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getCollectibleIndex } from "../functions/collectibles";
-import { CollectibleIndex } from "../types/CollectibleIndex";
-import {
-  postCollectibleInitFirstFire,
-  postCollectibleInitFirstHasSubscriptions,
-} from "./subscriptions/postCollectibleInitFirst";
-
-const v = {
-  run: {
-    seenCollectibles: new Set<CollectibleIndex>(),
-  },
-};
-
-/** @internal */
-export function postCollectibleInitFirstInit(mod: Mod): void {
-  saveDataManager("postCollectibleInitFirst", v, hasSubscriptions);
-
-  mod.AddCallback(
-    ModCallback.POST_PICKUP_INIT,
-    postPickupInitCollectible,
-    PickupVariant.COLLECTIBLE,
-  ); // 34
-}
-
-function hasSubscriptions() {
-  return postCollectibleInitFirstHasSubscriptions();
-}
-
-function postPickupInitCollectible(pickup: EntityPickup) {
-  const collectible = pickup as EntityPickupCollectible;
-  const collectibleIndex = getCollectibleIndex(collectible);
-  if (v.run.seenCollectibles.has(collectibleIndex)) {
-    return;
-  }
-
-  v.run.seenCollectibles.add(collectibleIndex);
-  postCollectibleInitFirstFire(collectible);
-}

package/callbacks/postCursedTeleport.ts

@@ -1,185 +0,0 @@
-import {
-  CollectibleType,
-  DamageFlag,
-  EntityType,
-  ModCallback,
-  PlayerVariant,
-  RoomType,
-  TrinketType,
-} from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { hasFlag } from "../functions/flag";
-import { getPlayerNumHitsRemaining } from "../functions/player";
-import { mapGetPlayer, mapSetPlayer } from "../functions/playerDataStructures";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postCursedTeleportFire,
-  postCursedTeleportHasSubscriptions,
-} from "./subscriptions/postCursedTeleport";
-
-const v = {
-  run: {
-    playersDamageFrameMap: new Map<
-      PlayerIndex,
-      [lastDamageFrame: int, callbackFiredOnThisFrame: boolean]
-    >(),
-  },
-
-  level: {
-    numSacrifices: 0,
-  },
-};
-
-/** @internal */
-export function postCursedTeleportInit(mod: Mod): void {
-  saveDataManager("postCursedTeleport", v, hasSubscriptions);
-
-  mod.AddCallback(
-    ModCallback.ENTITY_TAKE_DMG,
-    entityTakeDmgPlayer,
-    EntityType.PLAYER,
-  ); // 11
-
-  mod.AddCallback(
-    ModCallback.POST_PLAYER_RENDER,
-    postPlayerRenderPlayer,
-    PlayerVariant.PLAYER, // Co-op babies cannot perform Cursed Eye teleports
-  ); // 32
-}
-
-function hasSubscriptions() {
-  return postCursedTeleportHasSubscriptions();
-}
-
-// 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;
-  }
-
-  incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame
-  setDamageFrame(tookDamage, damageFlags);
-
-  return undefined;
-}
-
-function setDamageFrame(tookDamage: Entity, damageFlags: BitFlags<DamageFlag>) {
-  const gameFrameCount = game.GetFrameCount();
-
-  const player = tookDamage.ToPlayer();
-  if (player === undefined) {
-    return;
-  }
-
-  // Don't do anything if we already activated the callback on this frame.
-  const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
-  if (trackingArray !== undefined) {
-    const [lastDamageFrame, callbackFiredOnThisFrame] = trackingArray;
-    if (lastDamageFrame === gameFrameCount && callbackFiredOnThisFrame) {
-      return;
-    }
-  }
-
-  // Don't do anything if this could be a Sacrifice Room teleport.
-  if (isPotentialNaturalTeleportFromSacrificeRoom(damageFlags)) {
-    return;
-  }
-
-  const newTrackingArray = [gameFrameCount, false];
-  mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
-}
-
-function isPotentialNaturalTeleportFromSacrificeRoom(
-  damageFlags: BitFlags<DamageFlag>,
-) {
-  const room = game.GetRoom();
-  const roomType = room.GetType();
-  const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
-
-  // Don't record the frame if we are potentially going to the Angel Room or the Dark Room from a
-  // Sacrifice Room.
-  return (
-    roomType === RoomType.SACRIFICE &&
-    isSpikeDamage &&
-    (v.level.numSacrifices === 6 || v.level.numSacrifices >= 12)
-  );
-}
-
-function incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>) {
-  const room = game.GetRoom();
-  const roomType = room.GetType();
-  const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
-
-  if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
-    v.level.numSacrifices += 1;
-  }
-}
-
-// ModCallback.POST_PLAYER_RENDER (32)
-// PlayerVariant.PLAYER (0)
-function postPlayerRenderPlayer(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  // Retrieve information about this player.
-  const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
-  if (trackingArray === undefined) {
-    return;
-  }
-  const [lastDamageFrame, callbackActivatedOnThisFrame] = trackingArray;
-
-  if (!playerIsTeleportingFromCursedTeleport(player, lastDamageFrame)) {
-    return;
-  }
-
-  // Do nothing if the callback already fired on this frame.
-  if (callbackActivatedOnThisFrame) {
-    return;
-  }
-
-  const gameFrameCount = game.GetFrameCount();
-  const newTrackingArray = [gameFrameCount, true];
-  mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
-
-  postCursedTeleportFire(player);
-}
-
-function playerIsTeleportingFromCursedTeleport(
-  player: EntityPlayer,
-  lastDamageFrame: int,
-) {
-  // Check to see if this is the frame that we last took damage.
-  const gameFrameCount = game.GetFrameCount();
-  if (gameFrameCount !== lastDamageFrame) {
-    return false;
-  }
-
-  // Check to see if this is the 1st frame that we are teleporting.
-  const sprite = player.GetSprite();
-  if (
-    !sprite.IsPlaying("TeleportUp") ||
-    sprite.GetFrame() !== 1 // The 0th frame never fires
-  ) {
-    return false;
-  }
-
-  if (player.HasCollectible(CollectibleType.CURSED_EYE)) {
-    return true;
-  }
-
-  const numHitsRemaining = getPlayerNumHitsRemaining(player);
-  if (player.HasTrinket(TrinketType.CURSED_SKULL) && numHitsRemaining === 1) {
-    return true;
-  }
-
-  return false;
-}

package/callbacks/postCustomDoorEnter.ts

@@ -1,292 +0,0 @@
-/* eslint-disable sort-exports/sort-exports */
-
-import {
-  Direction,
-  DoorSlot,
-  DoorState,
-  EffectVariant,
-  GridCollisionClass,
-  GridEntityType,
-  ModCallback,
-} from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { directionToVector } from "../functions/direction";
-import { doorSlotToDirection } from "../functions/doors";
-import { getEffects, spawnEffect } from "../functions/entitySpecific";
-import { getClosestPlayer } from "../functions/player";
-import {
-  postCustomDoorEnterFire,
-  postCustomDoorEnterHasSubscriptions,
-} from "./subscriptions/postCustomDoorEnter";
-
-interface CustomDoorData {
-  slot: DoorSlot;
-  state: DoorState;
-}
-
-const POSITION_OFFSET_MULTIPLIER = -23;
-
-const initializedEffectVariants = new Set<int>();
-
-const v = {
-  room: {
-    customDoors: new Map<PtrHash, CustomDoorData>(),
-    customDoorSlots: new Set<DoorSlot>(),
-  },
-};
-
-/** @internal */
-export function postCustomDoorEnterInit(): void {
-  saveDataManager("postCustomDoorEnter", v, hasSubscriptions);
-}
-
-function hasSubscriptions() {
-  return postCustomDoorEnterHasSubscriptions();
-}
-
-/**
- * `isaacscript-common` provides custom doors that can be spawned where any wall segment is. If you
- * use this feature, you must first call this initialization function at the beginning of your mod.
- *
- * Each kind of custom door that you create must have an entry in the "content/entities2.xml" file,
- * like so:
- *
- * ```xml
- * <entity id="1000" name="Foo Custom Door" anm2path="grid/door_foo.anm2" />
- * ```
- *
- * (Custom door entities must have an id of "1000", which corresponds to an effect. If you do not
- * specify the variant, then the game will automatically assign it.)
- *
- * Next, pass the variant into this function:
- *
- * ```ts
- * const modVanilla = RegisterMod("My Mod", 1);
- * const mod = upgradeMod(modVanilla);
- * const fooEffectVariant = Isaac.GetEntityVariantByName("Foo Custom Door");
- * initCustomDoor(mod, fooEffectVariant);
- * ```
- *
- * Also see the `spawnCustomDoor` function.
- */
-export function initCustomDoor(
-  mod: ModUpgraded,
-  effectVariant: EffectVariant,
-): void {
-  initializedEffectVariants.add(effectVariant);
-
-  mod.AddCallback(
-    ModCallback.POST_EFFECT_UPDATE,
-    postEffectUpdaterCustomEntity,
-    effectVariant,
-  ); // 55
-
-  mod.AddCallback(
-    ModCallback.POST_EFFECT_RENDER,
-    postEffectRenderCustomEntity,
-    effectVariant,
-  ); // 56
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_ROOM_CLEAR_CHANGED,
-    (roomClear: boolean) => {
-      postRoomClearChanged(roomClear, effectVariant);
-    },
-  );
-}
-
-// ModCallback.POST_EFFECT_UPDATE (55)
-function postEffectUpdaterCustomEntity(effect: EntityEffect) {
-  const ptrHash = GetPtrHash(effect);
-  const doorData = v.room.customDoors.get(ptrHash);
-  if (doorData === undefined) {
-    return;
-  }
-
-  if (doorData.state === (effect.State as DoorState)) {
-    return;
-  }
-  doorData.state = effect.State as DoorState;
-
-  doorChangedState(effect);
-}
-
-function doorChangedState(effect: EntityEffect) {
-  const room = game.GetRoom();
-
-  const sprite = effect.GetSprite();
-  const animation = getAnimationForCustomDoor(effect);
-  sprite.Play(animation, true);
-
-  const gridIndex = room.GetGridIndex(effect.Position);
-  const wall = room.GetGridEntity(gridIndex);
-  if (wall !== undefined) {
-    wall.CollisionClass =
-      (effect.State as DoorState) === DoorState.OPEN
-        ? GridCollisionClass.WALL_EXCEPT_PLAYER
-        : GridCollisionClass.WALL;
-  }
-}
-
-function getAnimationForCustomDoor(effect: EntityEffect): string {
-  const freshlySpawned = effect.FrameCount === 0;
-
-  switch (effect.State as DoorState) {
-    case DoorState.OPEN: {
-      return freshlySpawned ? "Opened" : "Open";
-    }
-
-    case DoorState.CLOSED: {
-      return freshlySpawned ? "Closed" : "Close";
-    }
-
-    default: {
-      return "Opened";
-    }
-  }
-}
-
-// ModCallback.POST_EFFECT_RENDER (56)
-function postEffectRenderCustomEntity(effect: EntityEffect) {
-  const ptrHash = GetPtrHash(effect);
-  const doorData = v.room.customDoors.get(ptrHash);
-  if (doorData === undefined) {
-    return;
-  }
-
-  const direction = doorSlotToDirection(doorData.slot);
-  const player = getClosestPlayer(effect.Position);
-  if (isPlayerPastDoorThreshold(effect, player, direction)) {
-    postCustomDoorEnterFire(player, effect.Variant, doorData.slot, direction);
-  }
-}
-
-function isPlayerPastDoorThreshold(
-  effect: EntityEffect,
-  player: EntityPlayer,
-  direction: Direction,
-) {
-  switch (direction) {
-    case Direction.NO_DIRECTION: {
-      return false;
-    }
-
-    // 1
-    case Direction.UP: {
-      return player.Position.Y <= effect.Position.Y;
-    }
-
-    // 2
-    case Direction.RIGHT: {
-      return player.Position.X >= effect.Position.X;
-    }
-
-    // 3
-    case Direction.DOWN: {
-      return player.Position.Y >= effect.Position.Y;
-    }
-
-    // 4
-    case Direction.LEFT: {
-      return player.Position.X <= effect.Position.X;
-    }
-  }
-}
-
-// ModCallbackCustom.POST_ROOM_CLEAR_CHANGED
-function postRoomClearChanged(
-  roomClear: boolean,
-  effectVariant: EffectVariant,
-) {
-  const state = roomClear ? DoorState.OPEN : DoorState.CLOSED;
-  const customDoors = getEffects(effectVariant);
-  for (const customDoor of customDoors) {
-    customDoor.State = state;
-  }
-}
-
-/**
- * Helper function to spawn a custom door. This is intended to be called from the `POST_NEW_ROOM`
- * callback when the player enters a room that should have a custom door. (You could also call it
- * from another callback if you want the door to appear e.g. after clearing all enemies.)
- *
- * Like other entities, the door is not persistent, so you must spawn it every time when re-entering
- * the room.
- *
- * Handle when a player enters the door by hooking the custom `POST_CUSTOM_DOOR_ENTER` callback.
- *
- * The custom door is an `EntityEffect`. You can manually open or close the door by modifying its
- * state. (The values to use correspond to the `DoorState` enum.)
- *
- * This function will throw a runtime error if:
- * - the door slot already has a vanilla door
- * - the door slot already has a custom door
- * - the tile at the door slot does not have a wall
- *
- * Before using this function, you must first initialize the effect/door variant with the
- * `initCustomDoor` function.
- */
-export function spawnCustomDoor(
-  effectVariant: EffectVariant,
-  doorSlot: DoorSlot,
-): EntityEffect {
-  if (!initializedEffectVariants.has(effectVariant)) {
-    error(
-      'In order to spawn custom doors, you must first initialize them with the "initCustomDoor" function at the beginning of your mod.',
-    );
-  }
-
-  if (v.room.customDoorSlots.has(doorSlot)) {
-    error(
-      `There is already a custom door initialized on door slot: ${doorSlot}`,
-    );
-  }
-
-  const room = game.GetRoom();
-  const roomClear = room.IsClear();
-  const position = room.GetDoorSlotPosition(doorSlot);
-  const gridEntity = room.GetGridEntityFromPos(position);
-  if (gridEntity === undefined) {
-    error(
-      `Failed to initialize a custom door at slot ${doorSlot} because the wall on that tile does not exist.`,
-    );
-  }
-
-  const gridEntityType = gridEntity.GetType();
-  if (gridEntityType !== GridEntityType.WALL) {
-    error(
-      `Failed to initialize a custom door at slot ${doorSlot} because there is another grid entity on that tile with a type of: ${gridEntityType}`,
-    );
-  }
-
-  const effect = spawnEffect(effectVariant, 0, position);
-
-  // Do initial setup for the door.
-  effect.State = roomClear ? DoorState.OPEN : DoorState.CLOSED;
-  effect.RenderZOffset = -10000;
-  effect.PositionOffset = getPositionOffset(doorSlot);
-  const sprite = effect.GetSprite();
-  sprite.Rotation = (doorSlot as int) * 90 - 90;
-
-  // Keep track of metadata about this door.
-  const ptrHash = GetPtrHash(effect);
-  const doorData: CustomDoorData = {
-    slot: doorSlot,
-    state: effect.State,
-  };
-  v.room.customDoors.set(ptrHash, doorData);
-  v.room.customDoorSlots.add(doorSlot);
-
-  doorChangedState(effect);
-
-  return effect;
-}
-
-function getPositionOffset(doorSlot: DoorSlot) {
-  const direction = doorSlotToDirection(doorSlot);
-  const vector = directionToVector(direction);
-  return vector.mul(POSITION_OFFSET_MULTIPLIER);
-}

package/callbacks/postDiceRoomActivated.ts

@@ -1,60 +0,0 @@
-import {
-  DiceFloorSubType,
-  EffectVariant,
-  ModCallback,
-} from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { isCloseEnoughToTriggerDiceFloor } from "../functions/effects";
-import { getClosestPlayer } from "../functions/player";
-import {
-  postDiceRoomActivatedFire,
-  postDiceRoomActivatedHasSubscriptions,
-} from "./subscriptions/postDiceRoomActivated";
-
-const v = {
-  room: {
-    diceRoomActivated: false,
-  },
-};
-
-/** @internal */
-export function postDiceRoomActivatedInit(mod: Mod): void {
-  saveDataManager("postDiceRoomActivated", v, hasSubscriptions);
-
-  mod.AddCallback(
-    ModCallback.POST_EFFECT_UPDATE,
-    postEffectUpdateDiceFloor,
-    EffectVariant.DICE_FLOOR,
-  ); // 55
-}
-
-function hasSubscriptions() {
-  return postDiceRoomActivatedHasSubscriptions();
-}
-
-// ModCallback.POST_EFFECT_UPDATE (55)
-// EffectVariant.DICE_FLOOR (76)
-function postEffectUpdateDiceFloor(effect: EntityEffect) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (v.room.diceRoomActivated) {
-    return;
-  }
-
-  // When using the debug console to go to a dice room, the player can appear on top of the dice
-  // floor before they snap to the door.
-  if (effect.FrameCount === 0) {
-    return;
-  }
-
-  const closestPlayer = getClosestPlayer(effect.Position);
-  if (isCloseEnoughToTriggerDiceFloor(closestPlayer, effect)) {
-    v.room.diceRoomActivated = true;
-    postDiceRoomActivatedFire(
-      closestPlayer,
-      effect.SubType as DiceFloorSubType,
-    );
-  }
-}