isaacscript-common 13.3.3 → 14.0.0

package/src/classes/ModUpgraded.ts

@@ -1,15 +1,32 @@
 import { ModCallback } from "isaac-typescript-definitions";
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { ModCallbackCustom2 } from "../enums/ModCallbackCustom2";
+import { saveDataManager } from "../features/saveDataManager/exports";
 import { getTime } from "../functions/debugFunctions";
 import { getParentFunctionDescription } from "../functions/log";
-import { AddCallbackParameterCustom } from "../interfaces/private/AddCallbackParameterCustom";
+import { getTSTLClassName } from "../functions/tstlClass";
+import { AddCallbackParametersCustom } from "../interfaces/private/AddCallbackParametersCustom";
+import { AddCallbackParametersCustom2 } from "../interfaces/private/AddCallbackParametersCustom2";
 import { CALLBACK_REGISTER_FUNCTIONS } from "../objects/callbackRegisterFunctions";
+import { PostAmbushFinished } from "./callbacks/PostAmbushFinished";
+import { PostAmbushStarted } from "./callbacks/PostAmbushStarted";
+import { PostBombExploded } from "./callbacks/PostBombExploded";
+import { PostBombInitLate } from "./callbacks/PostBombInitLate";
+import { PostBoneSwing } from "./callbacks/PostBoneSwing";
+import { PostCollectibleEmpty } from "./callbacks/PostCollectibleEmpty";
+import { PostCollectibleInitFirst } from "./callbacks/PostCollectibleInitFirst";
+import { PostCursedTeleport } from "./callbacks/PostCursedTeleport";
+import { PostKnifeInitLate } from "./callbacks/PostKnifeInitLate";
+import { PostNewRoomEarly } from "./callbacks/PostNewRoomEarly";
+import { PostPitRender } from "./callbacks/PostPitRender";
+import { PostRoomClearChanged } from "./callbacks/PostRoomClearChanged";
+import { PostSpikesRender } from "./callbacks/PostSpikesRender";
+import { CustomCallback } from "./private/CustomCallback";
 
 /**
  * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
  * hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
- * extends the base class and adds a new method of `AddCallbackCustom`. (There is no corresponding
- * `RemoveCallbackCustom`.)
+ * extends the base class and adds a new method of `AddCallbackCustom`.
  *
  * To upgrade your mod, use the `upgradeMod` helper function.
  */
@@ -20,7 +37,7 @@ export class ModUpgraded implements Mod {
 
   /**
    * The vanilla mod object stores the name of the mod for some reason. (It is never used or
-   * referenced.
+   * referenced. (We match the casing of the vanilla variable.)
    */
   Name: string;
 
@@ -29,16 +46,40 @@ export class ModUpgraded implements Mod {
   // ----------------
 
   /** We store a copy of the original mod object so that we can re-implement its functions. */
-  Mod: Mod;
-
-  Debug: boolean;
-  TimeThreshold: float | undefined;
+  private mod: Mod;
+
+  private debug: boolean;
+  private timeThreshold: float | undefined;
+
+  private callbacks: {
+    readonly [key in ModCallbackCustom2]: CustomCallback<key>;
+  } = {
+    [ModCallbackCustom2.POST_AMBUSH_FINISHED]: new PostAmbushFinished(),
+    [ModCallbackCustom2.POST_AMBUSH_STARTED]: new PostAmbushStarted(),
+    [ModCallbackCustom2.POST_BOMB_EXPLODED]: new PostBombExploded(),
+    [ModCallbackCustom2.POST_BOMB_INIT_LATE]: new PostBombInitLate(),
+    [ModCallbackCustom2.POST_BONE_SWING]: new PostBoneSwing(),
+    [ModCallbackCustom2.POST_COLLECTIBLE_EMPTY]: new PostCollectibleEmpty(),
+    [ModCallbackCustom2.POST_COLLECTIBLE_INIT_FIRST]:
+      new PostCollectibleInitFirst(),
+    [ModCallbackCustom2.POST_CURSED_TELEPORT]: new PostCursedTeleport(),
+
+    [ModCallbackCustom2.POST_KNIFE_INIT_LATE]: new PostKnifeInitLate(),
+    [ModCallbackCustom2.POST_NEW_ROOM_EARLY]: new PostNewRoomEarly(),
+    [ModCallbackCustom2.POST_PIT_RENDER]: new PostPitRender(),
+    [ModCallbackCustom2.POST_ROOM_CLEAR_CHANGED]: new PostRoomClearChanged(),
+    [ModCallbackCustom2.POST_SPIKES_RENDER]: new PostSpikesRender(),
+  };
+
+  // -----------
+  // Constructor
+  // -----------
 
   constructor(mod: Mod, debug: boolean, timeThreshold?: float) {
     this.Name = mod.Name;
-    this.Mod = mod;
-    this.Debug = debug;
-    this.TimeThreshold = timeThreshold;
+    this.mod = mod;
+    this.debug = debug;
+    this.timeThreshold = timeThreshold;
   }
 
   // ---------------
@@ -47,9 +88,9 @@ export class ModUpgraded implements Mod {
 
   AddCallback<T extends ModCallback>(
     modCallback: T,
-    ...args: AddCallbackParameter[T]
+    ...args: AddCallbackParameters[T]
   ): void {
-    if (this.Debug) {
+    if (this.debug) {
       const callback = args[0];
       const optionalArg = args[1];
 
@@ -61,42 +102,49 @@ export class ModUpgraded implements Mod {
           : `${parentFunctionDescription} - ${callbackName}`;
 
       /**
-       * We don't use the "log" helper function since it will always show the same "unknown" prefix.
+       * We don't use the "log" helper function here since it will always show the same "unknown"
+       * prefix.
        */
-      const callbackWithLogger = (...callbackArgs: unknown[]) => {
+      const callbackWithLogger: typeof callback = (
+        ...callbackArgs: Parameters<typeof callback>
+      ) => {
         const startTime = getTime();
         Isaac.DebugString(`${signature} - START`);
 
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        callback(...callbackArgs);
+        // @ts-expect-error The compiler is not smart enough to know that the callback args should
+        // match the callback.
+        const returnValue = callback(...callbackArgs);
 
         const endTime = getTime();
         const elapsedTime = endTime - startTime;
         if (
-          this.TimeThreshold === undefined ||
-          this.TimeThreshold <= elapsedTime
+          this.timeThreshold === undefined ||
+          this.timeThreshold <= elapsedTime
         ) {
           Isaac.DebugString(`${signature} - END - time: ${elapsedTime}`);
         } else {
           Isaac.DebugString(`${signature} - END`);
         }
+
+        return returnValue;
       };
 
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-expect-error
-      this.Mod.AddCallback(modCallback, callbackWithLogger, optionalArg);
+      const newArgs = [
+        callbackWithLogger,
+        optionalArg,
+      ] as unknown as AddCallbackParameters[T];
+      this.mod.AddCallback(modCallback, ...newArgs);
     } else {
-      this.Mod.AddCallback(modCallback, ...args);
+      this.mod.AddCallback(modCallback, ...args);
     }
   }
 
   HasData(): boolean {
-    return this.Mod.HasData();
+    return this.mod.HasData();
   }
 
   LoadData(): string {
-    return this.Mod.LoadData();
+    return this.mod.LoadData();
   }
 
   /**
@@ -105,17 +153,17 @@ export class ModUpgraded implements Mod {
    */
   RemoveCallback<T extends ModCallback>(
     modCallback: T,
-    callback: AddCallbackParameter[T][0],
+    callback: AddCallbackParameters[T][0],
   ): void {
-    this.Mod.RemoveCallback(modCallback, callback);
+    this.mod.RemoveCallback(modCallback, callback);
   }
 
   RemoveData(): void {
-    this.Mod.RemoveData();
+    this.mod.RemoveData();
   }
 
   SaveData(data: string): void {
-    this.Mod.SaveData(data);
+    this.mod.SaveData(data);
   }
 
   // --------------
@@ -125,10 +173,63 @@ export class ModUpgraded implements Mod {
   // eslint-disable-next-line class-methods-use-this
   AddCallbackCustom<T extends ModCallbackCustom>(
     modCallbackCustom: T,
-    ...args: AddCallbackParameterCustom[T]
+    ...args: AddCallbackParametersCustom[T]
   ): void {
     const callbackRegisterFunction =
       CALLBACK_REGISTER_FUNCTIONS[modCallbackCustom];
     callbackRegisterFunction(...args);
   }
+
+  AddCallbackCustom2<T extends ModCallbackCustom2>(
+    modCallbackCustom: T,
+    ...args: AddCallbackParametersCustom2[T]
+  ): void {
+    const callback = this.callbacks[modCallbackCustom];
+    callback.add(...args);
+
+    if (callback.initialized) {
+      return;
+    }
+    callback.initialized = true;
+
+    if (callback.otherCallbacksUsed !== undefined) {
+      for (const callbackTuple of callback.otherCallbacksUsed) {
+        const [modCallback, callbackArgs] = callbackTuple;
+        this.AddCallback(modCallback, ...callbackArgs);
+      }
+    }
+
+    if (callback.otherCustomCallbacksUsed !== undefined) {
+      for (const callbackTuple of callback.otherCustomCallbacksUsed) {
+        const [modCallback, callbackArgs] = callbackTuple;
+        this.AddCallbackCustom(modCallback, ...callbackArgs);
+      }
+    }
+
+    if (callback.v !== undefined) {
+      const callbackName = getTSTLClassName(callback);
+      if (callbackName === undefined) {
+        error(
+          `Failed to get the name of the callback: ModCallbackCustom.${ModCallbackCustom2[modCallbackCustom]} (${modCallbackCustom})`,
+        );
+      }
+      saveDataManager(callbackName, callback.v);
+    }
+
+    /*
+    if (callback.feature !== undefined) {}
+    */
+  }
+
+  /**
+   * This method does not care about the tertiary argument. Regardless of the conditions of how you
+   * registered the callback, it will be removed.
+   */
+  RemoveCallbackCustom<T extends ModCallbackCustom>(
+    modCallback: T,
+    callback: AddCallbackParametersCustom[T][0],
+  ): void {
+    // TODO
+    print(this, modCallback, callback);
+  }
 }

package/src/classes/callbacks/PostAmbushFinished.ts

@@ -0,0 +1,39 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getAmbushType } from "../../functions/ambush";
+import { CustomCallbackAmbush } from "./validation/CustomCallbackAmbush";
+
+export class PostAmbushFinished extends CustomCallbackAmbush<ModCallbackCustom2.POST_AMBUSH_FINISHED> {
+  override v = {
+    room: {
+      ambushDone: false,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  postUpdate = (): void => {
+    if (this.v.room.ambushDone) {
+      return;
+    }
+
+    const room = game.GetRoom();
+    const ambushDone = room.IsAmbushDone();
+    if (!ambushDone) {
+      return;
+    }
+    this.v.room.ambushDone = true;
+
+    const ambushType = getAmbushType();
+    if (ambushType !== undefined) {
+      this.fire(ambushType);
+    }
+  };
+}

package/src/classes/callbacks/PostAmbushStarted.ts

@@ -0,0 +1,39 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getAmbushType } from "../../functions/ambush";
+import { CustomCallbackAmbush } from "./validation/CustomCallbackAmbush";
+
+export class PostAmbushStarted extends CustomCallbackAmbush<ModCallbackCustom2.POST_AMBUSH_STARTED> {
+  override v = {
+    room: {
+      ambushActive: false,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  postUpdate = (): void => {
+    if (this.v.room.ambushActive) {
+      return;
+    }
+
+    const room = game.GetRoom();
+    const ambushActive = room.IsAmbushActive();
+    if (!ambushActive) {
+      return;
+    }
+    this.v.room.ambushActive = true;
+
+    const ambushType = getAmbushType();
+    if (ambushType !== undefined) {
+      this.fire(ambushType);
+    }
+  };
+}

package/src/classes/callbacks/PostBombExploded.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { BOMB_EXPLODE_FRAME } from "../../core/constants";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackBomb } from "./validation/CustomCallbackBomb";
+
+export class PostBombExploded extends CustomCallbackBomb<ModCallbackCustom2.POST_BOMB_EXPLODED> {
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_BOMB_UPDATE, [this.postBombUpdate]], // 58
+    ];
+  }
+
+  // ModCallback.POST_BOMB_UPDATE (58)
+  postBombUpdate = (bomb: EntityBomb): void => {
+    if (bomb.FrameCount === BOMB_EXPLODE_FRAME) {
+      this.fire(bomb);
+    }
+  };
+}

package/src/classes/callbacks/PostBombInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackBomb } from "./validation/CustomCallbackBomb";
+
+export class PostBombInitLate extends CustomCallbackBomb<ModCallbackCustom2.POST_BOMB_INIT_LATE> {
+  override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_BOMB_UPDATE, [this.postBombUpdate]], // 58
+    ];
+  }
+
+  // ModCallback.POST_BOMB_UPDATE (58)
+  postBombUpdate = (bomb: EntityBomb): void => {
+    const ptrHash = GetPtrHash(bomb);
+    if (!this.v.room.firedSet.has(ptrHash)) {
+      this.v.room.firedSet.add(ptrHash);
+      this.fire(bomb);
+    }
+  };
+}

package/src/classes/callbacks/PostBoneSwing.ts

@@ -0,0 +1,58 @@
+import { KnifeVariant, ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallback } from "../private/CustomCallback";
+
+const BONE_SWING_ANIMATIONS: ReadonlySet<string> = new Set([
+  "Swing",
+  "Swing2",
+  "Spin",
+]);
+
+export class PostBoneSwing extends CustomCallback<ModCallbackCustom2.POST_BONE_SWING> {
+  override v = {
+    room: {
+      boneClubAnimations: new Map<PtrHash, string>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [ModCallback.POST_KNIFE_RENDER, [this.postKnifeRender]], // 52
+    ];
+  }
+
+  // ModCallback.POST_KNIFE_RENDER (52)
+  postKnifeRender = (knife: EntityKnife): void => {
+    // The tertiary argument of the `POST_KNIFE_RENDER` callback takes sub-types instead of knife
+    // variants.
+    if (knife.Variant === KnifeVariant.BONE_CLUB) {
+      this.postKnifeRenderBoneClub(knife);
+    }
+  };
+
+  // ModCallback.POST_KNIFE_RENDER (52)
+  // KnifeVariant.BONE_CLUB (1)
+  postKnifeRenderBoneClub(knife: EntityKnife): void {
+    const sprite = knife.GetSprite();
+    const animation = sprite.GetAnimation();
+    const ptrHash = GetPtrHash(knife);
+
+    const animationOnLastFrame = this.v.room.boneClubAnimations.get(ptrHash);
+    this.v.room.boneClubAnimations.set(ptrHash, animation);
+
+    if (
+      animationOnLastFrame !== undefined &&
+      animation !== animationOnLastFrame
+    ) {
+      this.boneClubAnimationChanged(knife, animation);
+    }
+  }
+
+  boneClubAnimationChanged(knife: EntityKnife, animation: string): void {
+    if (BONE_SWING_ANIMATIONS.has(animation)) {
+      this.fire(knife);
+    }
+  }
+}

package/src/classes/callbacks/PostCollectibleEmpty.ts

@@ -0,0 +1,72 @@
+import {
+  CollectibleType,
+  ModCallback,
+  PickupVariant,
+} from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_COLLECTIBLE_EMPTY;
+
+export class PostCollectibleEmpty extends CustomCallback<T> {
+  override v = {
+    room: {
+      collectibleTypeMap: new Map<PtrHash, CollectibleType>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [
+        ModCallback.POST_PICKUP_UPDATE,
+        [this.postPickupUpdateCollectible, PickupVariant.COLLECTIBLE],
+      ], // 35
+    ];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackCollectibleType] = optionalArgs;
+    if (callbackCollectibleType === undefined) {
+      return true;
+    }
+
+    const [_collectible, oldCollectibleType] = fireArgs;
+    return oldCollectibleType === callbackCollectibleType;
+  }
+
+  // ModCallback.POST_PICKUP_UPDATE (35)
+  // PickupVariant.COLLECTIBLE (100)
+  postPickupUpdateCollectible = (pickup: EntityPickup): void => {
+    const collectible = pickup as EntityPickupCollectible;
+
+    const ptrHash = GetPtrHash(collectible);
+    let oldCollectibleType = this.v.room.collectibleTypeMap.get(ptrHash);
+    if (oldCollectibleType === undefined) {
+      oldCollectibleType = collectible.SubType;
+    }
+    this.v.room.collectibleTypeMap.set(ptrHash, collectible.SubType);
+
+    if (oldCollectibleType !== collectible.SubType) {
+      this.collectibleTypeChanged(collectible, oldCollectibleType);
+    }
+  };
+
+  collectibleTypeChanged(
+    collectible: EntityPickupCollectible,
+    oldCollectibleType: CollectibleType,
+  ): void {
+    if (collectible.SubType === CollectibleType.NULL) {
+      this.fire(collectible, oldCollectibleType);
+    }
+  }
+}

package/src/classes/callbacks/PostCollectibleInitFirst.ts

@@ -0,0 +1,37 @@
+import { ModCallback, PickupVariant } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getCollectibleIndex } from "../../functions/collectibles";
+import { CollectibleIndex } from "../../types/CollectibleIndex";
+import { CustomCallbackCollectible } from "./validation/CustomCallbackCollectible";
+
+export class PostCollectibleInitFirst extends CustomCallbackCollectible<ModCallbackCustom2.POST_COLLECTIBLE_INIT_FIRST> {
+  override v = {
+    run: {
+      seenCollectibles: new Set<CollectibleIndex>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.otherCallbacksUsed = [
+      [
+        ModCallback.POST_PICKUP_INIT,
+        [this.postPickupInitCollectible, PickupVariant.COLLECTIBLE],
+      ], // 34
+    ];
+  }
+
+  // ModCallback.POST_PICKUP_INIT (34)
+  // PickupVariant.COLLECTIBLE (100)
+  postPickupInitCollectible = (pickup: EntityPickup): void => {
+    const collectible = pickup as EntityPickupCollectible;
+    const collectibleIndex = getCollectibleIndex(collectible);
+    if (this.v.run.seenCollectibles.has(collectibleIndex)) {
+      return;
+    }
+
+    this.v.run.seenCollectibles.add(collectibleIndex);
+    this.fire(collectible);
+  };
+}