isaacscript-common 14.1.3 → 14.2.0

package/src/classes/callbacks/PostTearInitVeryLate.ts

@@ -0,0 +1,33 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackTear } from "./validation/CustomCallbackTear";
+
+export class PostTearInitVeryLate extends CustomCallbackTear<ModCallbackCustom2.POST_TEAR_INIT_VERY_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_TEAR_UPDATE, [this.postTearUpdate]], // 40
+    ];
+  }
+
+  // ModCallback.POST_TEAR_UPDATE (40)
+  private postTearUpdate = (tear: EntityTear): void => {
+    // This callback fires on frame 1.
+    if (tear.FrameCount === 0) {
+      return;
+    }
+
+    const index = GetPtrHash(tear);
+    if (!this.v.room.firedSet.has(index)) {
+      this.v.room.firedSet.add(index);
+      this.fire(tear);
+    }
+  };
+}

package/src/classes/callbacks/PostTransformation.ts

@@ -0,0 +1,71 @@
+import { PlayerForm } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getEnumValues } from "../../functions/enums";
+import { defaultMapGetPlayer } from "../../functions/playerDataStructures";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { DefaultMap } from "../DefaultMap";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_TRANSFORMATION;
+
+export class PostTransformation extends CustomCallback<T> {
+  public override v = {
+    run: {
+      // We cannot use a nested `DefaultMap` here.
+      playersTransformationsMap: new DefaultMap<
+        PlayerIndex,
+        Map<PlayerForm, boolean>
+      >(() => new Map()),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED,
+        [this.postPEffectUpdateReordered],
+      ],
+    ];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackPlayerForm] = optionalArgs;
+    if (callbackPlayerForm === undefined) {
+      return true;
+    }
+
+    const [_player, playerForm] = fireArgs;
+    return playerForm === callbackPlayerForm;
+  }
+
+  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+  private postPEffectUpdateReordered = (player: EntityPlayer) => {
+    const playerTransformationsMap = defaultMapGetPlayer(
+      this.v.run.playersTransformationsMap,
+      player,
+    );
+
+    for (const playerForm of getEnumValues(PlayerForm)) {
+      const hasForm = player.HasPlayerForm(playerForm);
+      let storedForm = playerTransformationsMap.get(playerForm);
+      if (storedForm === undefined) {
+        storedForm = false;
+      }
+
+      if (hasForm !== storedForm) {
+        playerTransformationsMap.set(playerForm, hasForm);
+        this.fire(player, playerForm, hasForm);
+      }
+    }
+  };
+}

package/src/classes/callbacks/PreBerserkDeath.ts

@@ -1,4 +1,4 @@
-import { CollectibleType } from "isaac-typescript-definitions";
+import { CollectibleType, ModCallback } from "isaac-typescript-definitions";
 import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
 import { isChildPlayer } from "../../functions/playerIndex";
 import { getPlayerNumHitsRemaining } from "../../functions/players";
@@ -9,16 +9,13 @@ export class PreBerserkDeath extends CustomCallbackPlayer<ModCallbackCustom2.PRE
   constructor() {
     super();
 
-    this.customCallbacksUsed = [
-      [
-        ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED,
-        [this.postPEffectUpdateReordered],
-      ],
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
     ];
   }
 
-  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-  private postPEffectUpdateReordered = (player: EntityPlayer): void => {
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffectUpdate = (player: EntityPlayer): void => {
     // This callback should not trigger for the Strawman Keeper and other players that are "child"
     // players.
     if (isChildPlayer(player)) {

package/src/classes/callbacks/PreItemPickup.ts

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

package/src/classes/callbacks/validation/CustomCallbackCollectibleType.ts

@@ -0,0 +1,32 @@
+import { CollectibleType } from "isaac-typescript-definitions";
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureCollectibleType = (
+  player: EntityPlayer,
+  collectibleType: CollectibleType,
+) => void;
+type ModCallbackCustomCollectibleType =
+  MatchingCallbackCustom<CallbackSignatureCollectibleType>;
+
+export class CustomCallbackCollectibleType<
+  T extends ModCallbackCustomCollectibleType,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackCollectibleType] = optionalArgs;
+    if (callbackCollectibleType === undefined) {
+      return true;
+    }
+
+    const [_player, collectibleType] = fireArgs;
+    return collectibleType === callbackCollectibleType;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackItemPickup.ts

@@ -0,0 +1,48 @@
+import {
+  PickingUpItem,
+  PickingUpItemCollectible,
+  PickingUpItemTrinket,
+} from "../../../types/PickingUpItem";
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureItemPickup =
+  | ((player: EntityPlayer, pickingUpItem: PickingUpItem) => void)
+  | ((player: EntityPlayer, pickingUpItem: PickingUpItemCollectible) => void)
+  | ((player: EntityPlayer, pickingUpItem: PickingUpItemTrinket) => void);
+
+type ModCallbackCustomItemPickup =
+  MatchingCallbackCustom<CallbackSignatureItemPickup>;
+
+export class CustomCallbackItemPickup<
+  T extends ModCallbackCustomItemPickup,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [_player, pickingUpItem] = fireArgs;
+    const [callbackItemType, callbackSubtype] = optionalArgs;
+
+    if (
+      callbackItemType !== undefined &&
+      callbackItemType !== pickingUpItem.itemType
+    ) {
+      return false;
+    }
+
+    if (
+      callbackSubtype !== undefined &&
+      callbackSubtype !== pickingUpItem.subType
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackLaser.ts

@@ -0,0 +1,27 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureLaser = (laser: EntityLaser) => void;
+type ModCallbackCustomLaser = MatchingCallbackCustom<CallbackSignatureLaser>;
+
+export class CustomCallbackLaser<
+  T extends ModCallbackCustomLaser,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackLaserVariant] = optionalArgs;
+    if (callbackLaserVariant === undefined) {
+      return true;
+    }
+
+    const [laser] = fireArgs;
+    return laser.Variant === callbackLaserVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackNPC.ts

@@ -0,0 +1,34 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureNPC =
+  | ((npc: EntityNPC) => void)
+  | ((npc: EntityNPC, previousState: int, currentState: int) => void);
+type ModCallbackCustomNPC = MatchingCallbackCustom<CallbackSignatureNPC>;
+
+export class CustomCallbackNPC<
+  T extends ModCallbackCustomNPC,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [npc] = fireArgs;
+    const [callbackEntityType, callbackVariant] = optionalArgs;
+
+    if (callbackEntityType !== undefined && callbackEntityType !== npc.Type) {
+      return false;
+    }
+
+    if (callbackVariant !== undefined && callbackVariant !== npc.Variant) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackPickup.ts

@@ -0,0 +1,41 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignaturePickup =
+  | ((pickup: EntityPickup) => void)
+  | ((pickup: EntityPickup, player: EntityPlayer) => void)
+  | ((pickup: EntityPickup, previousState: int, currentState: int) => void);
+type ModCallbackCustomPickup = MatchingCallbackCustom<CallbackSignaturePickup>;
+
+export class CustomCallbackPickup<
+  T extends ModCallbackCustomPickup,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [pickup] = fireArgs;
+    const [callbackPickupVariant, callbackPickupSubType] = optionalArgs;
+
+    if (
+      callbackPickupVariant !== undefined &&
+      callbackPickupVariant !== pickup.Variant
+    ) {
+      return false;
+    }
+
+    if (
+      callbackPickupSubType !== undefined &&
+      callbackPickupSubType !== pickup.SubType
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackPlayer.ts

@@ -1,4 +1,7 @@
-import { DamageFlag } from "isaac-typescript-definitions";
+import { DamageFlag, PlayerType } from "isaac-typescript-definitions";
+import { HealthType } from "../../../enums/HealthType";
+import { StatType } from "../../../enums/StatType";
+import { StatTypeType } from "../../../interfaces/StatTypeType";
 import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
 import {
   CustomCallback,
@@ -9,13 +12,33 @@ import {
 type CallbackSignaturePlayer =
   | ((player: EntityPlayer) => void)
   | ((player: EntityPlayer) => int | undefined)
+  | ((
+      player: EntityPlayer,
+      oldCharacter: PlayerType,
+      newCharacter: PlayerType,
+    ) => void)
   | ((
       player: EntityPlayer,
       amount: float,
       damageFlags: BitFlags<DamageFlag>,
       source: EntityRef,
       countdownFrames: int,
-    ) => boolean | undefined);
+    ) => boolean | undefined)
+  | ((
+      player: EntityPlayer,
+      healthType: HealthType,
+      difference: int,
+      oldValue: int,
+      newValue: int,
+    ) => void)
+  | (<T extends StatType>(
+      player: EntityPlayer,
+      statType: StatType,
+      difference: int,
+      oldValue: StatTypeType[T],
+      newValue: StatTypeType[T],
+    ) => void);
+
 type ModCallbackCustomPlayer = MatchingCallbackCustom<CallbackSignaturePlayer>;
 
 export class CustomCallbackPlayer<

package/src/classes/callbacks/validation/CustomCallbackPoop.ts

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignaturePoop = (poop: GridEntityPoop) => void;
+type ModCallbackCustomPoop = MatchingCallbackCustom<CallbackSignaturePoop>;
+
+export class CustomCallbackPoop<
+  T extends ModCallbackCustomPoop,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackPoopGridEntityVariant] = optionalArgs;
+    if (callbackPoopGridEntityVariant === undefined) {
+      return true;
+    }
+
+    const [poop] = fireArgs;
+    const poopGridEntityVariant = poop.GetVariant();
+    return poopGridEntityVariant === callbackPoopGridEntityVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackPressurePlate.ts

@@ -0,0 +1,31 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignaturePressurePlate = (
+  pressurePlate: GridEntityPressurePlate,
+) => void;
+type ModCallbackCustomPressurePlate =
+  MatchingCallbackCustom<CallbackSignaturePressurePlate>;
+
+export class CustomCallbackPressurePlate<
+  T extends ModCallbackCustomPressurePlate,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackPressurePlateVariant] = optionalArgs;
+    if (callbackPressurePlateVariant === undefined) {
+      return true;
+    }
+
+    const [pressurePlate] = fireArgs;
+    const poopGridEntityVariant = pressurePlate.GetVariant();
+    return poopGridEntityVariant === callbackPressurePlateVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackProjectile.ts

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureProjectile = (projectile: EntityProjectile) => void;
+type ModCallbackCustomProjectile =
+  MatchingCallbackCustom<CallbackSignatureProjectile>;
+
+export class CustomCallbackProjectile<
+  T extends ModCallbackCustomProjectile,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackProjectileVariant] = optionalArgs;
+    if (callbackProjectileVariant === undefined) {
+      return true;
+    }
+
+    const [projectile] = fireArgs;
+    return projectile.Variant === callbackProjectileVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackRock.ts

@@ -0,0 +1,30 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureRock = (rock: GridEntityRock) => void;
+type ModCallbackCustomRock = MatchingCallbackCustom<CallbackSignatureRock>;
+
+export class CustomCallbackRock<
+  T extends ModCallbackCustomRock,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackVariant] = optionalArgs;
+    if (callbackVariant === undefined) {
+      return true;
+    }
+
+    const [rock] = fireArgs;
+    // This is not `RockVariant` because `GridEntityRock` can be other grid entity types than just
+    // `GridEntityType.ROCK`.
+    const variant = rock.GetVariant();
+    return variant === callbackVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackSlot.ts

@@ -0,0 +1,37 @@
+import { SlotDestructionType } from "../../../enums/SlotDestructionType";
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureSlot =
+  | ((slot: EntitySlot) => void)
+  | ((slot: EntitySlot, slotDestructionType: SlotDestructionType) => void)
+  | ((slot: EntitySlot, player: EntityPlayer) => void)
+  | ((
+      slot: EntitySlot,
+      previousAnimation: string,
+      currentAnimation: string,
+    ) => void);
+
+type ModCallbackCustomSlot = MatchingCallbackCustom<CallbackSignatureSlot>;
+
+export class CustomCallbackSlot<
+  T extends ModCallbackCustomSlot,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackSlotVariant] = optionalArgs;
+    if (callbackSlotVariant === undefined) {
+      return true;
+    }
+
+    const [slot] = fireArgs;
+    return slot.Variant === callbackSlotVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackSpikes.ts

@@ -16,13 +16,13 @@ export class CustomCallbackSpikes<
     fireArgs: FireArgs<T>,
     optionalArgs: OptionalArgs<T>,
   ): boolean {
-    const [callbackSpikesVariant] = optionalArgs;
-    if (callbackSpikesVariant === undefined) {
+    const [callbackVariant] = optionalArgs;
+    if (callbackVariant === undefined) {
       return true;
     }
 
     const [spikes] = fireArgs;
-    const spikesVariant = spikes.GetVariant();
-    return spikesVariant === callbackSpikesVariant;
+    const variant = spikes.GetVariant();
+    return variant === callbackVariant;
   }
 }

package/src/classes/callbacks/validation/CustomCallbackTNT.ts

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureTNT = (tnt: GridEntityTNT) => void;
+type ModCallbackCustomTNT = MatchingCallbackCustom<CallbackSignatureTNT>;
+
+export class CustomCallbackTNT<
+  T extends ModCallbackCustomTNT,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackVariant] = optionalArgs;
+    if (callbackVariant === undefined) {
+      return true;
+    }
+
+    const [tnt] = fireArgs;
+    const variant = tnt.GetVariant();
+    return variant === callbackVariant;
+  }
+}

package/src/classes/callbacks/validation/CustomCallbackTear.ts

@@ -0,0 +1,27 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureTear = (tear: EntityTear) => void;
+type ModCallbackCustomTear = MatchingCallbackCustom<CallbackSignatureTear>;
+
+export class CustomCallbackTear<
+  T extends ModCallbackCustomTear,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackTearVariant] = optionalArgs;
+    if (callbackTearVariant === undefined) {
+      return true;
+    }
+
+    const [tear] = fireArgs;
+    return tear.Variant === callbackTearVariant;
+  }
+}