isaacscript-common 13.3.4 → 14.1.0

package/src/classes/callbacks/PostCursedTeleport.ts

@@ -0,0 +1,186 @@
+import {
+  CollectibleType,
+  DamageFlag,
+  EntityType,
+  ModCallback,
+  PlayerVariant,
+  RoomType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { hasFlag } from "../../functions/flag";
+import {
+  mapGetPlayer,
+  mapSetPlayer,
+} from "../../functions/playerDataStructures";
+import { getPlayerNumHitsRemaining } from "../../functions/players";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.POST_CURSED_TELEPORT> {
+  public override v = {
+    run: {
+      playersDamageFrameMap: new Map<
+        PlayerIndex,
+        [lastDamageFrame: int, callbackFiredOnThisFrame: boolean]
+      >(),
+    },
+
+    level: {
+      numSacrifices: 0,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.ENTITY_TAKE_DMG,
+        [this.entityTakeDmgPlayer, EntityType.PLAYER],
+      ], // 11
+      [
+        ModCallback.POST_PLAYER_RENDER,
+        // Co-op babies cannot perform Cursed Eye teleports.
+        [this.postPlayerRenderPlayer, PlayerVariant.PLAYER],
+      ], // 32
+    ];
+  }
+
+  // ModCallback.ENTITY_TAKE_DMG (11)
+  // EntityType.PLAYER (1)
+  private entityTakeDmgPlayer = (
+    entity: Entity,
+    _amount: float,
+    damageFlags: BitFlags<DamageFlag>,
+    _source: EntityRef,
+    _countdownFrames: int,
+  ): boolean | undefined => {
+    this.incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame.
+    this.setDamageFrame(entity, damageFlags);
+
+    return undefined;
+  };
+
+  private setDamageFrame(
+    entity: Entity,
+    damageFlags: BitFlags<DamageFlag>,
+  ): void {
+    const gameFrameCount = game.GetFrameCount();
+
+    const player = entity.ToPlayer();
+    if (player === undefined) {
+      return;
+    }
+
+    // Don't do anything if we already activated the callback on this frame.
+    const trackingArray = mapGetPlayer(
+      this.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 (this.isPotentialNaturalTeleportFromSacrificeRoom(damageFlags)) {
+      return;
+    }
+
+    const newTrackingArray = [gameFrameCount, false];
+    mapSetPlayer(this.v.run.playersDamageFrameMap, player, newTrackingArray);
+  }
+
+  private isPotentialNaturalTeleportFromSacrificeRoom(
+    damageFlags: BitFlags<DamageFlag>,
+  ): boolean {
+    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 &&
+      (this.v.level.numSacrifices === 6 || this.v.level.numSacrifices >= 12)
+    );
+  }
+
+  private incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>): void {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+    if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
+      this.v.level.numSacrifices++;
+    }
+  }
+
+  // ModCallback.POST_PLAYER_RENDER (32)
+  // PlayerVariant.PLAYER (0)
+  private postPlayerRenderPlayer = (
+    player: EntityPlayer,
+    _renderOffset: Vector,
+  ): void => {
+    // Retrieve information about this player.
+    const trackingArray = mapGetPlayer(
+      this.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(this.v.run.playersDamageFrameMap, player, newTrackingArray);
+
+    this.fire(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/src/classes/callbacks/PostCustomRevive.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackRevive } from "./validation/CustomCallbackRevive";
+
+export class PostCustomRevive extends CustomCallbackRevive<ModCallbackCustom2.POST_CUSTOM_REVIVE> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.CUSTOM_REVIVE];
+  }
+}

package/src/classes/callbacks/PostDiceRoomActivated.ts

@@ -0,0 +1,68 @@
+import {
+  DiceFloorSubType,
+  EffectVariant,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { isCloseEnoughToTriggerDiceFloor } from "../../functions/effects";
+import { getClosestPlayer } from "../../functions/players";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_DICE_ROOM_ACTIVATED;
+
+export class PostDiceRoomActivated extends CustomCallback<T> {
+  public override v = {
+    room: {
+      diceRoomActivated: false,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.POST_EFFECT_UPDATE,
+        [this.postEffectUpdateDiceFloor, EffectVariant.DICE_FLOOR],
+      ], // 55
+    ];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackDiceFloorSubType] = optionalArgs;
+    if (callbackDiceFloorSubType === undefined) {
+      return true;
+    }
+
+    const [_player, diceFloorSubType] = fireArgs;
+    return diceFloorSubType === callbackDiceFloorSubType;
+  }
+
+  // ModCallback.POST_EFFECT_UPDATE (55)
+  // EffectVariant.DICE_FLOOR (76)
+  private postEffectUpdateDiceFloor = (effect: EntityEffect): void => {
+    if (this.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)) {
+      this.v.room.diceRoomActivated = true;
+      this.fire(closestPlayer, effect.SubType as DiceFloorSubType);
+    }
+  };
+}

package/src/classes/callbacks/PostDoorRender.ts

@@ -0,0 +1,19 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getDoors } from "../../functions/doors";
+import { CustomCallbackDoor } from "./validation/CustomCallbackDoor";
+
+export class PostDoorRender extends CustomCallbackDoor<ModCallbackCustom2.POST_DOOR_RENDER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [[ModCallback.POST_RENDER, [this.postRender]]]; // 2
+  }
+
+  // ModCallback.POST_RENDER (2)
+  private postRender = (): void => {
+    for (const door of getDoors()) {
+      this.fire(door);
+    }
+  };
+}

package/src/classes/callbacks/PostDoorUpdate.ts

@@ -0,0 +1,19 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getDoors } from "../../functions/doors";
+import { CustomCallbackDoor } from "./validation/CustomCallbackDoor";
+
+export class PostDoorUpdate extends CustomCallbackDoor<ModCallbackCustom2.POST_DOOR_UPDATE> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [[ModCallback.POST_UPDATE, [this.postUpdate]]]; // 1
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    for (const door of getDoors()) {
+      this.fire(door);
+    }
+  };
+}

package/src/classes/callbacks/PostEffectInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackEffect } from "./validation/CustomCallbackEffect";
+
+export class PostEffectInitLate extends CustomCallbackEffect<ModCallbackCustom2.POST_EFFECT_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_EFFECT_UPDATE, [this.postEffectUpdate]],
+    ]; // 55
+  }
+
+  // ModCallback.POST_EFFECT_UPDATE (55)
+  private postEffectUpdate = (effect: EntityEffect): void => {
+    const index = GetPtrHash(effect);
+    if (!this.v.room.firedSet.has(index)) {
+      this.v.room.firedSet.add(index);
+      this.fire(effect);
+    }
+  };
+}

package/src/classes/callbacks/PostEffectStateChanged.ts

@@ -0,0 +1,35 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallbackEffect } from "./validation/CustomCallbackEffect";
+
+export class PostEffectStateChanged extends CustomCallbackEffect<ModCallbackCustom2.POST_EFFECT_STATE_CHANGED> {
+  public override v = {
+    run: {
+      stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_EFFECT_UPDATE, [this.postEffectUpdate]],
+    ]; // 55
+  }
+
+  // ModCallback.POST_EFFECT_UPDATE (55)
+  private postEffectUpdate = (effect: EntityEffect): void => {
+    const ptrHash = GetPtrHash(effect);
+    const previousState = this.v.run.stateMap.getAndSetDefault(
+      ptrHash,
+      effect.State,
+    );
+    const currentState = effect.State;
+    this.v.run.stateMap.set(ptrHash, currentState);
+
+    if (previousState !== currentState) {
+      this.fire(effect, previousState, currentState);
+    }
+  };
+}

package/src/classes/callbacks/PostEsauJr.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostEsauJr extends CustomCallback<ModCallbackCustom2.POST_ESAU_JR> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.ESAU_JR_DETECTION];
+  }
+}

package/src/classes/callbacks/PostFamiliarInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackFamiliar } from "./validation/CustomCallbackFamiliar";
+
+export class PostFamiliarInitLate extends CustomCallbackFamiliar<ModCallbackCustom2.POST_FAMILIAR_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_FAMILIAR_UPDATE, [this.postFamiliarUpdate]],
+    ]; // 6
+  }
+
+  // ModCallback.POST_FAMILIAR_UPDATE (6)
+  private postFamiliarUpdate = (familiar: EntityFamiliar): void => {
+    const index = GetPtrHash(familiar);
+    if (!this.v.room.firedSet.has(index)) {
+      this.v.room.firedSet.add(index);
+      this.fire(familiar);
+    }
+  };
+}

package/src/classes/callbacks/PostFamiliarStateChanged.ts

@@ -0,0 +1,35 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallbackFamiliar } from "./validation/CustomCallbackFamiliar";
+
+export class PostFamiliarStateChanged extends CustomCallbackFamiliar<ModCallbackCustom2.POST_FAMILIAR_STATE_CHANGED> {
+  public override v = {
+    run: {
+      stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_FAMILIAR_UPDATE, [this.postFamiliarUpdate]],
+    ]; // 6
+  }
+
+  // ModCallback.POST_FAMILIAR_UPDATE (6)
+  private postFamiliarUpdate = (familiar: EntityFamiliar): void => {
+    const ptrHash = GetPtrHash(familiar);
+    const previousState = this.v.run.stateMap.getAndSetDefault(
+      ptrHash,
+      familiar.State,
+    );
+    const currentState = familiar.State;
+    this.v.run.stateMap.set(ptrHash, currentState);
+
+    if (previousState !== currentState) {
+      this.fire(familiar, previousState, currentState);
+    }
+  };
+}

package/src/classes/callbacks/PostFirstEsauJr.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostFirstEsauJr extends CustomCallback<ModCallbackCustom2.POST_FIRST_ESAU_JR> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.ESAU_JR_DETECTION];
+  }
+}

package/src/classes/callbacks/PostFirstFlip.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostFirstFlip extends CustomCallback<ModCallbackCustom2.POST_FIRST_FLIP> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.FLIP_DETECTION];
+  }
+}

package/src/classes/callbacks/PostFlip.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostFlip extends CustomCallback<ModCallbackCustom2.POST_FLIP> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.FLIP_DETECTION];
+  }
+}

package/src/classes/callbacks/PostGameStartedReordered.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostGameStartedReordered extends CustomCallback<ModCallbackCustom2.POST_GAME_STARTED_REORDERED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GAME_REORDERED_CALLBACKS];
+  }
+}

package/src/classes/callbacks/PostGameStartedReorderedLast.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostGameStartedReorderedLast extends CustomCallback<ModCallbackCustom2.POST_GAME_STARTED_REORDERED> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GAME_REORDERED_CALLBACKS];
+  }
+}

package/src/classes/callbacks/PostGreedModeWave.ts

@@ -0,0 +1,37 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { isGreedMode } from "../../functions/run";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostGreedModeWave extends CustomCallback<ModCallbackCustom2.POST_GREED_MODE_WAVE> {
+  public override v = {
+    run: {
+      currentGreedWave: 0,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    if (!isGreedMode()) {
+      return;
+    }
+
+    const level = game.GetLevel();
+    const newWave = level.GreedModeWave;
+    const oldWave = this.v.run.currentGreedWave;
+    this.v.run.currentGreedWave = newWave;
+
+    if (newWave > oldWave) {
+      this.fire(oldWave, newWave);
+    }
+  };
+}

package/src/classes/callbacks/PostGridEntityBroken.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntity } from "./validation/CustomCallbackGridEntity";
+
+export class PostGridEntityBroken extends CustomCallbackGridEntity<ModCallbackCustom2.POST_GRID_ENTITY_BROKEN> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}

package/src/classes/callbacks/PostGridEntityCollision.ts

@@ -0,0 +1,65 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_GRID_ENTITY_COLLISION;
+
+export class PostGridEntityCollision extends CustomCallback<T> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [gridEntity, entity] = fireArgs;
+    const [
+      callbackGridEntityType,
+      callbackGridEntityVariant,
+      callbackEntityType,
+      callbackEntityVariant,
+    ] = optionalArgs;
+
+    const gridEntityType = gridEntity.GetType();
+
+    if (
+      callbackGridEntityType !== undefined &&
+      callbackGridEntityType !== gridEntityType
+    ) {
+      return false;
+    }
+
+    const gridEntityVariant = gridEntity.GetVariant();
+
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      return false;
+    }
+
+    if (
+      callbackEntityType !== undefined &&
+      callbackEntityType !== entity.Type
+    ) {
+      return false;
+    }
+
+    if (
+      callbackEntityVariant !== undefined &&
+      callbackEntityVariant !== entity.Variant
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/classes/callbacks/PostGridEntityCustomBroken.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackGridEntityCustom } from "./validation/CustomCallbackGridEntityCustom";
+
+export class PostGridEntityCustomBroken extends CustomCallbackGridEntityCustom<ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_BROKEN> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.GRID_ENTITY_DETECTION];
+  }
+}