isaacscript-common 13.3.4 → 14.1.0

package/src/classes/callbacks/PreBerserkDeath.ts

@@ -0,0 +1,42 @@
+import { CollectibleType } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { isChildPlayer } from "../../functions/playerIndex";
+import { getPlayerNumHitsRemaining } from "../../functions/players";
+import { willPlayerRevive } from "../../functions/revive";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PreBerserkDeath extends CustomCallbackPlayer<ModCallbackCustom2.PRE_BERSERK_DEATH> {
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED,
+        [this.postPEffectUpdateReordered],
+      ],
+    ];
+  }
+
+  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+  private postPEffectUpdateReordered = (player: EntityPlayer): void => {
+    // 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)
+    ) {
+      this.fire(player);
+    }
+  };
+}

package/src/classes/callbacks/PreCustomRevive.ts

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

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

@@ -0,0 +1,28 @@
+import { AmbushType } from "../../../enums/AmbushType";
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureAmbush = (ambushType: AmbushType) => void;
+type ModCallbackCustomAmbush = MatchingCallbackCustom<CallbackSignatureAmbush>;
+
+export class CustomCallbackAmbush<
+  T extends ModCallbackCustomAmbush,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackAmbushType] = optionalArgs;
+    if (callbackAmbushType === undefined) {
+      return true;
+    }
+
+    const [ambushType] = fireArgs;
+    return ambushType === callbackAmbushType;
+  }
+}

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

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

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

@@ -0,0 +1,30 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureCollectible = (
+  collectible: EntityPickupCollectible,
+) => void;
+type ModCallbackCustomCollectible =
+  MatchingCallbackCustom<CallbackSignatureCollectible>;
+
+export class CustomCallbackCollectible<
+  T extends ModCallbackCustomCollectible,
+> 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 [collectible] = fireArgs;
+    return collectible.SubType === callbackCollectibleType;
+  }
+}

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

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureDoor = (door: GridEntityDoor) => void;
+type ModCallbackCustomDoor = MatchingCallbackCustom<CallbackSignatureDoor>;
+
+export class CustomCallbackDoor<
+  T extends ModCallbackCustomDoor,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackDoorVariant] = optionalArgs;
+    if (callbackDoorVariant === undefined) {
+      return true;
+    }
+
+    const [door] = fireArgs;
+    const doorVariant = door.GetVariant();
+    return doorVariant === callbackDoorVariant;
+  }
+}

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

@@ -0,0 +1,29 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureEffect =
+  | ((effect: EntityEffect) => void)
+  | ((effect: EntityEffect, previousState: int, currentState: int) => void);
+type ModCallbackCustomEffect = MatchingCallbackCustom<CallbackSignatureEffect>;
+
+export class CustomCallbackEffect<
+  T extends ModCallbackCustomEffect,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackEffectVariant] = optionalArgs;
+    if (callbackEffectVariant === undefined) {
+      return true;
+    }
+
+    const [effect] = fireArgs;
+    return effect.Variant === callbackEffectVariant;
+  }
+}

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

@@ -0,0 +1,30 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureFamiliar =
+  | ((familiar: EntityFamiliar) => void)
+  | ((familiar: EntityFamiliar, previousState: int, currentState: int) => void);
+type ModCallbackCustomFamiliar =
+  MatchingCallbackCustom<CallbackSignatureFamiliar>;
+
+export class CustomCallbackFamiliar<
+  T extends ModCallbackCustomFamiliar,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackFamiliarVariant] = optionalArgs;
+    if (callbackFamiliarVariant === undefined) {
+      return true;
+    }
+
+    const [familiar] = fireArgs;
+    return familiar.Variant === callbackFamiliarVariant;
+  }
+}

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

@@ -0,0 +1,42 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureGridEntity =
+  | ((gridEntity: GridEntity) => void)
+  | ((gridEntity: GridEntity, oldState: int, newState: int) => void);
+type ModCallbackCustomGridEntity =
+  MatchingCallbackCustom<CallbackSignatureGridEntity>;
+
+export class CustomCallbackGridEntity<
+  T extends ModCallbackCustomGridEntity,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [gridEntity] = fireArgs;
+    const [callbackGridEntityType, callbackVariant] = optionalArgs;
+
+    const gridEntityType = gridEntity.GetType();
+
+    if (
+      callbackGridEntityType !== undefined &&
+      callbackGridEntityType !== gridEntityType
+    ) {
+      return false;
+    }
+
+    const variant = gridEntity.GetVariant();
+
+    if (callbackVariant !== undefined && callbackVariant !== variant) {
+      return false;
+    }
+
+    return true;
+  }
+}

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

@@ -0,0 +1,36 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureGridEntityCustom =
+  | ((gridEntity: GridEntity, gridEntityTypeCustom: GridEntityType) => void)
+  | ((
+      gridEntity: GridEntity,
+      gridEntityTypeCustom: GridEntityType,
+      oldState: int,
+      newState: int,
+    ) => void);
+type ModCallbackCustomGridEntityCustom =
+  MatchingCallbackCustom<CallbackSignatureGridEntityCustom>;
+
+export class CustomCallbackGridEntityCustom<
+  T extends ModCallbackCustomGridEntityCustom,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackGridEntityTypeCustom] = optionalArgs;
+    if (callbackGridEntityTypeCustom === undefined) {
+      return true;
+    }
+
+    const [_gridEntity, gridEntityTypeCustom] = fireArgs;
+    return gridEntityTypeCustom === callbackGridEntityTypeCustom;
+  }
+}

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

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

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

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignaturePit = (pit: GridEntityPit) => void;
+type ModCallbackCustomPit = MatchingCallbackCustom<CallbackSignaturePit>;
+
+export class CustomCallbackPit<
+  T extends ModCallbackCustomPit,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackPitVariant] = optionalArgs;
+    if (callbackPitVariant === undefined) {
+      return true;
+    }
+
+    const [pit] = fireArgs;
+    const pitVariant = pit.GetVariant();
+    return pitVariant === callbackPitVariant;
+  }
+}

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

@@ -0,0 +1,47 @@
+import { DamageFlag } from "isaac-typescript-definitions";
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignaturePlayer =
+  | ((player: EntityPlayer) => void)
+  | ((player: EntityPlayer) => int | undefined)
+  | ((
+      player: EntityPlayer,
+      amount: float,
+      damageFlags: BitFlags<DamageFlag>,
+      source: EntityRef,
+      countdownFrames: int,
+    ) => boolean | undefined);
+type ModCallbackCustomPlayer = MatchingCallbackCustom<CallbackSignaturePlayer>;
+
+export class CustomCallbackPlayer<
+  T extends ModCallbackCustomPlayer,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [player] = fireArgs;
+    const [callbackPlayerVariant, callbackCharacter] = optionalArgs;
+
+    if (
+      callbackPlayerVariant !== undefined &&
+      callbackPlayerVariant !== player.Variant
+    ) {
+      return false;
+    }
+
+    const character = player.GetPlayerType();
+
+    if (callbackCharacter !== undefined && callbackCharacter !== character) {
+      return false;
+    }
+
+    return true;
+  }
+}

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

@@ -0,0 +1,27 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureRevive = (player: EntityPlayer, revivalType: int) => void;
+type ModCallbackCustomRevive = MatchingCallbackCustom<CallbackSignatureRevive>;
+
+export class CustomCallbackRevive<
+  T extends ModCallbackCustomRevive,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackRevivalType] = optionalArgs;
+    if (callbackRevivalType === undefined) {
+      return true;
+    }
+
+    const [_player, revivalType] = fireArgs;
+    return revivalType === callbackRevivalType;
+  }
+}

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

@@ -0,0 +1,28 @@
+import { MatchingCallbackCustom } from "../../../types/private/MatchingCallbackCustom";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../../private/CustomCallback";
+
+type CallbackSignatureSpikes = (spikes: GridEntitySpikes) => void;
+type ModCallbackCustomSpikes = MatchingCallbackCustom<CallbackSignatureSpikes>;
+
+export class CustomCallbackSpikes<
+  T extends ModCallbackCustomSpikes,
+> extends CustomCallback<T> {
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackSpikesVariant] = optionalArgs;
+    if (callbackSpikesVariant === undefined) {
+      return true;
+    }
+
+    const [spikes] = fireArgs;
+    const spikesVariant = spikes.GetVariant();
+    return spikesVariant === callbackSpikesVariant;
+  }
+}