isaacscript-common 14.1.3 → 14.2.0

package/src/classes/callbacks/PostItemDischarge.ts

@@ -0,0 +1,181 @@
+import {
+  ActiveSlot,
+  CollectibleType,
+  EntityType,
+  ModCallback,
+  SuckerVariant,
+} from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getTotalCharge } from "../../functions/charge";
+import { getEnumValues } from "../../functions/enums";
+import {
+  defaultMapGetPlayer,
+  mapGetPlayer,
+  mapSetPlayer,
+} from "../../functions/playerDataStructures";
+import { asNumber } from "../../functions/types";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { DefaultMap } from "../DefaultMap";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_ITEM_DISCHARGE;
+
+// Unfortunately, we cannot use a nested `DefaultMap` here.
+type ActiveSlotToCollectibleTypeMap = Map<ActiveSlot, CollectibleType>;
+type ActiveSlotToChargeMap = Map<ActiveSlot, int>;
+
+export class PostItemDischarge extends CustomCallback<T> {
+  public override v = {
+    run: {
+      playersActiveItemMap: new DefaultMap<
+        PlayerIndex,
+        ActiveSlotToCollectibleTypeMap
+      >(() => new Map()),
+      playersActiveChargeMap: new DefaultMap<
+        PlayerIndex,
+        ActiveSlotToChargeMap
+      >(() => new Map()),
+    },
+
+    room: {
+      playersBulbLastCollisionFrame: new Map<PlayerIndex, int>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
+      [
+        ModCallback.PRE_NPC_COLLISION,
+        [this.preNPCCollisionSucker, EntityType.SUCKER],
+      ], // 30
+    ];
+  }
+
+  // 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;
+  }
+
+  // ModCallback.POST_PEFFECT (4)
+  private postPEffectUpdate = (player: EntityPlayer) => {
+    const activeItemMap = defaultMapGetPlayer(
+      this.v.run.playersActiveItemMap,
+      player,
+    );
+    const chargeMap = defaultMapGetPlayer(
+      this.v.run.playersActiveChargeMap,
+      player,
+    );
+
+    for (const activeSlot of getEnumValues(ActiveSlot)) {
+      const currentActiveItem = player.GetActiveItem();
+      let previousActiveItem = activeItemMap.get(activeSlot);
+      if (previousActiveItem === undefined) {
+        previousActiveItem = currentActiveItem;
+      }
+      activeItemMap.set(activeSlot, currentActiveItem);
+
+      if (currentActiveItem !== previousActiveItem) {
+        // The player swapped out their active item for something else, so it should be impossible
+        // for the discharge callback to fire on this frame.
+        continue;
+      }
+
+      const currentCharge = getTotalCharge(player, activeSlot);
+      let previousCharge = chargeMap.get(activeSlot);
+      if (previousCharge === undefined) {
+        previousCharge = currentCharge;
+      }
+      chargeMap.set(activeSlot, currentCharge);
+
+      if (this.playerRecentlyCollidedWithBulb(player)) {
+        continue;
+      }
+
+      if (currentCharge < previousCharge) {
+        const collectibleType = player.GetActiveItem(activeSlot);
+        this.fire(player, collectibleType, activeSlot);
+      }
+    }
+  };
+
+  /**
+   * If the player collided with a Bulb on either this frame or the last frame, then assume a zap
+   * has occurred. (We do not want to fire the discharge callback if this is the case.)
+   */
+  private playerRecentlyCollidedWithBulb(player: EntityPlayer) {
+    const gameFrameCount = game.GetFrameCount();
+    const bulbLastCollisionFrame = mapGetPlayer(
+      this.v.room.playersBulbLastCollisionFrame,
+      player,
+    );
+    const collidedOnThisFrame = gameFrameCount === bulbLastCollisionFrame;
+    const collidedOnLastFrame = gameFrameCount - 1 === bulbLastCollisionFrame;
+    return collidedOnThisFrame || collidedOnLastFrame;
+  }
+
+  // ModCallback.PRE_NPC_COLLISION (30)
+  // EntityType.SUCKER (61)
+  private preNPCCollisionSucker = (
+    npc: EntityNPC,
+    collider: Entity,
+  ): boolean | undefined => {
+    if (npc.Variant === asNumber(SuckerVariant.BULB)) {
+      return this.preNPCCollisionBulb(npc, collider);
+    }
+
+    return undefined;
+  };
+
+  // ModCallback.PRE_NPC_COLLISION (30)
+  // EntityType.SUCKER (61)
+  private preNPCCollisionBulb(
+    _npc: EntityNPC,
+    collider: Entity,
+  ): boolean | undefined {
+    this.checkPlayerCollidedWithBulb(collider);
+    return undefined;
+  }
+
+  /**
+   * The algorithm for detecting a discharge is checking if the current charge is less than the
+   * charge on the previous frame. Thus, when a Bulb zaps a player and drains their charge, this
+   * will be a false position, so Bulbs have to be handled.
+   *
+   * When Bulbs zap a player, they go to `NpcState.STATE_JUMP` for a frame. However, this only
+   * happens on the frame after the player is discharged, which is too late to be of any use.
+   *
+   * Instead, we track the frames that Bulbs collide with players and assume that a collision means
+   * a zap has occurred.
+   */
+  private checkPlayerCollidedWithBulb(collider: Entity) {
+    const player = collider.ToPlayer();
+    if (player === undefined) {
+      return;
+    }
+
+    const gameFrameCount = game.GetFrameCount();
+    mapSetPlayer(
+      this.v.room.playersBulbLastCollisionFrame,
+      player,
+      gameFrameCount,
+    );
+  }
+}

package/src/classes/callbacks/PostItemPickup.ts

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

package/src/classes/callbacks/PostLaserInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackLaser } from "./validation/CustomCallbackLaser";
+
+export class PostLaserInitLate extends CustomCallbackLaser<ModCallbackCustom2.POST_LASER_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_LASER_UPDATE, [this.postLaserUpdate]], // 51
+    ];
+  }
+
+  // ModCallback.POST_LASER_UPDATE (48)
+  private postLaserUpdate = (laser: EntityLaser) => {
+    const index = GetPtrHash(laser);
+    if (!this.v.room.firedSet.has(index)) {
+      this.v.room.firedSet.add(index);
+      this.fire(laser);
+    }
+  };
+}

package/src/classes/callbacks/PostNPCInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackNPC } from "./validation/CustomCallbackNPC";
+
+export class PostNPCInitLate extends CustomCallbackNPC<ModCallbackCustom2.POST_NPC_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_NPC_UPDATE, [this.postNPCUpdate]], // 0
+    ];
+  }
+
+  // ModCallback.POST_NPC_UPDATE (0)
+  private postNPCUpdate = (npc: EntityNPC) => {
+    const index = GetPtrHash(npc);
+    if (!this.v.room.firedSet.has(index)) {
+      this.v.room.firedSet.add(index);
+      this.fire(npc);
+    }
+  };
+}

package/src/classes/callbacks/PostNPCStateChanged.ts

@@ -0,0 +1,37 @@
+import { ModCallback, NpcState } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallbackNPC } from "./validation/CustomCallbackNPC";
+
+export class PostNPCStateChanged extends CustomCallbackNPC<ModCallbackCustom2.POST_NPC_STATE_CHANGED> {
+  public override v = {
+    run: {
+      stateMap: new DefaultMap<PtrHash, NpcState, [NpcState]>(
+        (state) => state, // eslint-disable-line isaacscript/strict-enums
+      ),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_NPC_UPDATE, [this.postNPCUpdate]], // 0
+    ];
+  }
+
+  // ModCallback.POST_NPC_UPDATE (0)
+  private postNPCUpdate = (npc: EntityNPC) => {
+    const ptrHash = GetPtrHash(npc);
+    const previousState = this.v.run.stateMap.getAndSetDefault(
+      ptrHash,
+      npc.State,
+    );
+    const currentState = npc.State;
+    this.v.run.stateMap.set(ptrHash, currentState);
+
+    if (previousState !== currentState) {
+      this.fire(npc, previousState, currentState);
+    }
+  };
+}

package/src/classes/callbacks/PostPickupCollect.ts

@@ -0,0 +1,37 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getClosestPlayer } from "../../functions/players";
+import { CustomCallbackPickup } from "./validation/CustomCallbackPickup";
+
+export class PostPickupCollect extends CustomCallbackPickup<ModCallbackCustom2.POST_PICKUP_COLLECT> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PICKUP_RENDER, [this.postPickupRender]], // 36
+    ];
+  }
+
+  // ModCallback.POST_PICKUP_RENDER (36)
+  private postPickupRender = (pickup: EntityPickup) => {
+    const sprite = pickup.GetSprite();
+    const animation = sprite.GetAnimation();
+    if (animation !== "Collect") {
+      return;
+    }
+
+    const index = GetPtrHash(pickup);
+    if (!this.v.room.firedSet.has(index)) {
+      this.v.room.firedSet.add(index);
+
+      const player = getClosestPlayer(pickup.Position);
+      this.fire(pickup, player);
+    }
+  };
+}

package/src/classes/callbacks/PostPickupInitFirst.ts

@@ -0,0 +1,34 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getRoomVisitedCount } from "../../functions/roomData";
+import { CustomCallbackPickup } from "./validation/CustomCallbackPickup";
+
+export class PostPickupInitFirst extends CustomCallbackPickup<ModCallbackCustom2.POST_PICKUP_INIT_FIRST> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PICKUP_INIT, [this.postPickupInit]], // 34
+    ];
+  }
+
+  // ModCallback.POST_PICKUP_INIT (34)
+  private postPickupInit = (pickup: EntityPickup) => {
+    const room = game.GetRoom();
+    const roomFrameCount = room.GetFrameCount();
+    const roomVisitedCount = getRoomVisitedCount();
+
+    // The room visited count is not reset when re-entering a Treasure Room or Boss room in the
+    // Ascent.
+    if (roomFrameCount > 0 || roomVisitedCount === 0) {
+      this.fire(pickup);
+    }
+  };
+}

package/src/classes/callbacks/PostPickupInitLate.ts

@@ -0,0 +1,28 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackPickup } from "./validation/CustomCallbackPickup";
+
+export class PostPickupInitLate extends CustomCallbackPickup<ModCallbackCustom2.POST_PICKUP_INIT_LATE> {
+  public override v = {
+    room: {
+      firedSet: new Set<PtrHash>(),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PICKUP_UPDATE, [this.postPickupUpdate]], // 35
+    ];
+  }
+
+  // ModCallback.POST_PICKUP_UPDATE (35)
+  private postPickupUpdate = (pickup: EntityPickup) => {
+    const index = GetPtrHash(pickup);
+    if (!this.v.room.firedSet.has(index)) {
+      this.v.room.firedSet.add(index);
+      this.fire(pickup);
+    }
+  };
+}

package/src/classes/callbacks/PostPickupStateChanged.ts

@@ -0,0 +1,35 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallbackPickup } from "./validation/CustomCallbackPickup";
+
+export class PostPickupStateChanged extends CustomCallbackPickup<ModCallbackCustom2.POST_PICKUP_STATE_CHANGED> {
+  public override v = {
+    run: {
+      stateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PICKUP_UPDATE, [this.postPickupUpdate]], // 35
+    ];
+  }
+
+  // ModCallback.POST_PICKUP_UPDATE (35)
+  private postPickupUpdate = (pickup: EntityPickup) => {
+    const ptrHash = GetPtrHash(pickup);
+    const previousState = this.v.run.stateMap.getAndSetDefault(
+      ptrHash,
+      pickup.State,
+    );
+    const currentState = pickup.State;
+    this.v.run.stateMap.set(ptrHash, currentState);
+
+    if (previousState !== currentState) {
+      this.fire(pickup, previousState, currentState);
+    }
+  };
+}

package/src/classes/callbacks/PostPitUpdate.ts

@@ -0,0 +1,21 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getPits } from "../../functions/gridEntitiesSpecific";
+import { CustomCallbackPit } from "./validation/CustomCallbackPit";
+
+export class PostPitUpdate extends CustomCallbackPit<ModCallbackCustom2.POST_PIT_UPDATE> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    for (const pit of getPits()) {
+      this.fire(pit);
+    }
+  };
+}

package/src/classes/callbacks/PostPlayerChangeHealth.ts

@@ -0,0 +1,57 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { HealthType } from "../../enums/HealthType";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { getEnumValues } from "../../functions/enums";
+import { getPlayerHealthType } from "../../functions/playerHealth";
+import { getPlayerIndex } from "../../functions/playerIndex";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerChangeHealth extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_CHANGE_HEALTH> {
+  public override v = {
+    run: {
+      playersHealthMap: new DefaultMap<PlayerIndex, Map<HealthType, int>>(
+        () => new Map(),
+      ),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffect]], // 4
+    ];
+  }
+
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffect = (player: EntityPlayer) => {
+    // We call the "getPlayerIndex" function with the "differentiateForgottenAndSoul" argument. If
+    // we don't differentiate between The Forgotten and The Soul, the callback will fire every time
+    // the player switches between the two.
+    const playerIndex = getPlayerIndex(player, true);
+    const playerHealthMap =
+      this.v.run.playersHealthMap.getAndSetDefault(playerIndex);
+
+    for (const healthType of getEnumValues(HealthType)) {
+      const storedHealthValue = playerHealthMap.get(healthType);
+      const currentHealthValue = getPlayerHealthType(player, healthType);
+      playerHealthMap.set(healthType, currentHealthValue);
+
+      if (
+        storedHealthValue !== undefined &&
+        storedHealthValue !== currentHealthValue
+      ) {
+        const difference = currentHealthValue - storedHealthValue;
+        this.fire(
+          player,
+          healthType,
+          difference,
+          storedHealthValue,
+          currentHealthValue,
+        );
+      }
+    }
+  };
+}

package/src/classes/callbacks/PostPlayerChangeStat.ts

@@ -0,0 +1,102 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { StatType } from "../../enums/StatType";
+import { isBitSet128 } from "../../functions/bitSet128";
+import { colorEquals, isColor } from "../../functions/color";
+import { getEnumValues } from "../../functions/enums";
+import { getPlayerIndex } from "../../functions/playerIndex";
+import { getPlayerStat } from "../../functions/playerStats";
+import { isBoolean, isNumber } from "../../functions/types";
+import { isVector, vectorEquals } from "../../functions/vector";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { PossibleStatType } from "../../types/PossibleStatType";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerChangeStat extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_CHANGE_STAT> {
+  public override v = {
+    run: {
+      playersStatMap: new DefaultMap<
+        PlayerIndex,
+        Map<StatType, PossibleStatType>
+      >(() => new Map()),
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffect]], // 4
+    ];
+  }
+
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffect = (player: EntityPlayer) => {
+    // We call the "getPlayerIndex" function with the "differentiateForgottenAndSoul" argument. If
+    // we don't differentiate between The Forgotten and The Soul, the callback will fire every time
+    // the player switches between the two.
+    const playerIndex = getPlayerIndex(player, true);
+    const playerStatMap =
+      this.v.run.playersStatMap.getAndSetDefault(playerIndex);
+
+    for (const statType of getEnumValues(StatType)) {
+      const storedStatValue = playerStatMap.get(statType);
+      const currentStatValue = getPlayerStat(player, statType);
+      playerStatMap.set(statType, currentStatValue);
+
+      if (storedStatValue === undefined) {
+        continue;
+      }
+
+      if (!statEquals(storedStatValue, currentStatValue)) {
+        const isNumberStat =
+          isNumber(storedStatValue) && isNumber(currentStatValue);
+        const difference = isNumberStat
+          ? currentStatValue - storedStatValue
+          : 0;
+        this.fire(
+          player,
+          statType,
+          difference,
+          storedStatValue,
+          currentStatValue,
+        );
+      }
+    }
+  };
+}
+
+function statEquals(
+  oldValue: PossibleStatType,
+  newValue: PossibleStatType,
+): boolean {
+  const isNumberStat = isNumber(oldValue) && isNumber(newValue);
+  if (isNumberStat) {
+    return oldValue === newValue;
+  }
+
+  const isBooleanStat = isBoolean(oldValue) && isBoolean(newValue);
+  if (isBooleanStat) {
+    return oldValue === newValue;
+  }
+
+  const isBitSet128Stat = isBitSet128(oldValue) && isBitSet128(newValue);
+  if (isBitSet128Stat) {
+    return oldValue === newValue; // The class has the "__eq" meta-method.
+  }
+
+  const isColorStat = isColor(oldValue) && isColor(newValue);
+  if (isColorStat) {
+    return colorEquals(oldValue, newValue);
+  }
+
+  const isVectorStat = isVector(oldValue) && isVector(newValue);
+  if (isVectorStat) {
+    return vectorEquals(oldValue, newValue);
+  }
+
+  error(
+    'Failed to determine the type of a stat in the "POST_PLAYER_CHANGE_STAT" callback.',
+  );
+}

package/src/classes/callbacks/PostPlayerChangeType.ts

@@ -0,0 +1,44 @@
+import { ModCallback, PlayerType } from "isaac-typescript-definitions";
+import { postPlayerChangeTypeFire } from "../../callbacks/subscriptions/postPlayerChangeType";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import {
+  defaultMapGetPlayer,
+  mapSetPlayer,
+} from "../../functions/playerDataStructures";
+import { PlayerIndex } from "../../types/PlayerIndex";
+import { DefaultMap } from "../DefaultMap";
+import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
+
+export class PostPlayerChangeType extends CustomCallbackPlayer<ModCallbackCustom2.POST_PLAYER_CHANGE_TYPE> {
+  public override v = {
+    run: {
+      playersCharacterMap: new DefaultMap<
+        PlayerIndex,
+        PlayerType,
+        [character: PlayerType]
+      >((character: PlayerType) => character), // eslint-disable-line isaacscript/strict-enums
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffect]], // 4
+    ];
+  }
+
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffect = (player: EntityPlayer) => {
+    const character = player.GetPlayerType();
+    const storedCharacter = defaultMapGetPlayer(
+      this.v.run.playersCharacterMap,
+      player,
+      character,
+    );
+    if (character !== storedCharacter) {
+      mapSetPlayer(this.v.run.playersCharacterMap, player, character);
+      postPlayerChangeTypeFire(player, storedCharacter, character);
+    }
+  };
+}

package/src/classes/callbacks/PostPlayerCollectibleAdded.ts

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

package/src/classes/callbacks/PostPlayerCollectibleRemoved.ts

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