isaacscript-common 8.9.1 → 9.1.0

package/src/callbacks/postPlayerCollectible.ts

@@ -2,9 +2,15 @@
 // - `POST_PLAYER_COLLECTIBLE_ADDED`
 // - `POST_PLAYER_COLLECTIBLE_REMOVED`
 
-import { CollectibleType, ModCallback } from "isaac-typescript-definitions";
+import {
+  ActiveSlot,
+  CollectibleType,
+  ModCallback,
+} from "isaac-typescript-definitions";
 import { DefaultMap } from "../classes/DefaultMap";
 import { saveDataManager } from "../features/saveDataManager/exports";
+import { arrayEquals } from "../functions/array";
+import { getEnumValues } from "../functions/enums";
 import {
   defaultMapGetPlayer,
   mapGetPlayer,
@@ -29,6 +35,10 @@ const v = {
       PlayerIndex,
       Map<CollectibleType, int>
     >(() => new Map()),
+    playersActiveItemMap: new DefaultMap<
+      PlayerIndex,
+      Map<ActiveSlot, CollectibleType>
+    >(() => new Map()),
   },
 };
 
@@ -65,16 +75,17 @@ function postPEffectUpdate(player: EntityPlayer) {
   const difference = newCollectibleCount - oldCollectibleCount;
 
   if (difference > 0) {
-    collectibleCountChanged(player, difference, true);
+    collectibleCountChanged(player, difference);
   } else if (difference < 0) {
-    collectibleCountChanged(player, difference * -1, false);
+    collectibleCountChanged(player, difference * -1);
+  } else if (difference === 0) {
+    checkActiveItemsChanged(player);
   }
 }
 
 function collectibleCountChanged(
   player: EntityPlayer,
   numCollectiblesChanged: int,
-  increased: boolean,
 ) {
   const oldCollectibleMap = defaultMapGetPlayer(
     v.run.playersCollectibleMap,
@@ -83,19 +94,20 @@ function collectibleCountChanged(
   const newCollectibleMap = getPlayerCollectibleMap(player);
   mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
 
-  const collectibleTypes = [
+  const collectibleTypeSet = new Set<CollectibleType>([
     ...oldCollectibleMap.keys(),
     ...newCollectibleMap.keys(),
-  ];
-  collectibleTypes.sort();
+  ]);
 
   let numFired = 0;
-  for (const collectibleType of collectibleTypes) {
+  for (const collectibleType of collectibleTypeSet.values()) {
     const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
     const newNum = newCollectibleMap.get(collectibleType) ?? 0;
-    const difference = Math.abs(newNum - oldNum);
+    const difference = newNum - oldNum;
+    const increased = difference > 0;
+    const absoluteDifference = Math.abs(difference);
 
-    repeat(difference, () => {
+    repeat(absoluteDifference, () => {
       if (increased) {
         postPlayerCollectibleAddedFire(player, collectibleType);
       } else {
@@ -109,3 +121,70 @@ function collectibleCountChanged(
     }
   }
 }
+
+/**
+ * The special case is when a player swaps their active item for another active item. In this
+ * situation, their overall collectible count will not change. Thus, we explicitly check for this.
+ */
+function checkActiveItemsChanged(player: EntityPlayer) {
+  const activeItemMap = defaultMapGetPlayer(v.run.playersActiveItemMap, player);
+
+  const oldCollectibleTypes: CollectibleType[] = [];
+  const newCollectibleTypes: CollectibleType[] = [];
+
+  for (const activeSlot of getEnumValues(ActiveSlot)) {
+    const oldCollectibleType =
+      activeItemMap.get(activeSlot) ?? CollectibleType.NULL;
+    const newCollectibleType = player.GetActiveItem(activeSlot);
+    activeItemMap.set(activeSlot, newCollectibleType);
+
+    oldCollectibleTypes.push(oldCollectibleType);
+    newCollectibleTypes.push(newCollectibleType);
+  }
+
+  // For example, it is possible for the player to switch Schoolbag items, which will cause the
+  // collectibles in the array to be the same, but in a different order. Thus, sort both arrays
+  // before comparing them.
+  oldCollectibleTypes.sort();
+  newCollectibleTypes.sort();
+
+  if (!arrayEquals(oldCollectibleTypes, newCollectibleTypes)) {
+    const collectibleTypeSet = new Set<CollectibleType>([
+      ...oldCollectibleTypes,
+      ...newCollectibleTypes,
+    ]);
+    activeItemsChanged(player, collectibleTypeSet);
+  }
+}
+
+/**
+ * One or more active items have changed (with the player's total collectible count remaining the
+ * same).
+ */
+function activeItemsChanged(
+  player: EntityPlayer,
+  collectibleTypesSet: Set<CollectibleType>,
+) {
+  const oldCollectibleMap = defaultMapGetPlayer(
+    v.run.playersCollectibleMap,
+    player,
+  );
+  const newCollectibleMap = getPlayerCollectibleMap(player);
+  mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
+
+  for (const collectibleType of collectibleTypesSet.values()) {
+    const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
+    const newNum = newCollectibleMap.get(collectibleType) ?? 0;
+    const difference = newNum - oldNum;
+    const increased = difference > 0;
+    const absoluteDifference = Math.abs(difference);
+
+    repeat(absoluteDifference, () => {
+      if (increased) {
+        postPlayerCollectibleAddedFire(player, collectibleType);
+      } else {
+        postPlayerCollectibleRemovedFire(player, collectibleType);
+      }
+    });
+  }
+}

package/src/core/constantsFirstLast.ts

@@ -1,7 +1,7 @@
 // Constants related to modded items can be found in the "firstLast.ts" file.
 
 import {
-  Card,
+  CardType,
   CollectibleType,
   LevelStage,
   PillColor,
@@ -48,13 +48,13 @@ export const NUM_VANILLA_TRINKET_TYPES = getEnumLength(TrinketType) - 1;
 // -----
 
 /** Equal to `Card.FOOL`. */
-export const FIRST_CARD = Card.FOOL;
+export const FIRST_CARD_TYPE = CardType.FOOL;
 
 /** Calculated from the `Card` enum. */
-export const LAST_VANILLA_CARD = getLastEnumValue(Card);
+export const LAST_VANILLA_CARD_TYPE = getLastEnumValue(CardType);
 
 /** Calculated from the `Card` enum. `Card.NULL` is not included. */
-export const NUM_VANILLA_CARDS = getEnumLength(Card) - 1;
+export const NUM_VANILLA_CARD_TYPES = getEnumLength(CardType) - 1;
 
 // ------------
 // Pill Effects

package/src/features/extraConsoleCommands/listCommands.ts

@@ -24,7 +24,7 @@
 import {
   ActiveSlot,
   CacheFlag,
-  Card,
+  CardType,
   Challenge,
   CollectibleType,
   Direction,
@@ -43,7 +43,7 @@ import {
 import { game, sfxManager } from "../../core/cachedClasses";
 import { MAX_LEVEL_GRID_INDEX } from "../../core/constants";
 import {
-  FIRST_CARD,
+  FIRST_CARD_TYPE,
   FIRST_CHARACTER,
   FIRST_PILL_EFFECT,
   FIRST_ROOM_TYPE,
@@ -88,13 +88,13 @@ import { gridCoordinatesToWorldPosition } from "../../functions/roomGrid";
 import { changeRoom } from "../../functions/rooms";
 import { onSetSeed, restart, setUnseeded } from "../../functions/run";
 import { getGoldenTrinketType } from "../../functions/trinkets";
-import { asCard } from "../../functions/types";
+import { asCardType } from "../../functions/types";
 import { irange, printConsole, printEnabled } from "../../functions/utils";
 import { CARD_MAP } from "../../maps/cardMap";
 import { CHARACTER_MAP } from "../../maps/characterMap";
 import { PILL_EFFECT_MAP } from "../../maps/pillEffectMap";
 import { ROOM_TYPE_MAP } from "../../maps/roomTypeMap";
-import { getLastCard, getLastPillEffect } from "../firstLast";
+import { getLastCardType, getLastPillEffect } from "../firstLast";
 import {
   addHeart,
   devilAngel,
@@ -326,8 +326,8 @@ export function card(params: string): void {
     return;
   }
 
-  let cardNum: Card;
-  const num = tonumber(params) as Card | undefined;
+  let cardType: CardType;
+  const num = tonumber(params) as CardType | undefined;
   if (num === undefined) {
     const match = getMapPartialMatch(params, CARD_MAP);
     if (match === undefined) {
@@ -335,35 +335,35 @@ export function card(params: string): void {
       return;
     }
 
-    cardNum = match[1];
+    cardType = match[1];
   } else {
-    const lastCard = getLastCard();
-    if (num < FIRST_CARD || num > lastCard) {
+    const lastCardType = getLastCardType();
+    if (num < FIRST_CARD_TYPE || num > lastCardType) {
       printConsole(`Invalid card sub-type: ${num}`);
       return;
     }
 
-    cardNum = num;
+    cardType = num;
   }
 
-  const cardName = getCardName(cardNum);
-  Isaac.ExecuteCommand(`g k${cardNum}`);
-  printConsole(`Gave card: ${cardName} (${cardNum})`);
+  const cardName = getCardName(cardType);
+  Isaac.ExecuteCommand(`g k${cardType}`);
+  printConsole(`Gave card: ${cardName} (${cardType})`);
 }
 
 /** Spawns every card on the ground, starting at the top-left-most tile. */
 export function cards(): void {
-  const lastCard = getLastCard();
+  const lastCardType = getLastCardType();
 
   let cardType = 1;
   for (let y = 0; y <= 6; y++) {
     for (let x = 0; x <= 12; x++) {
-      if (asCard(cardType) === lastCard) {
+      if (asCardType(cardType) === lastCardType) {
         return;
       }
 
       const position = gridCoordinatesToWorldPosition(x, y);
-      spawnCard(asCard(cardType), position);
+      spawnCard(asCardType(cardType), position);
       cardType++;
     }
   }

package/src/features/firstLast.ts

@@ -1,5 +1,5 @@
 import {
-  Card,
+  CardType,
   CollectibleType,
   PillEffect,
   TrinketType,
@@ -7,14 +7,14 @@ import {
 import { ModUpgraded } from "../classes/ModUpgraded";
 import { itemConfig } from "../core/cachedClasses";
 import {
-  FIRST_CARD,
+  FIRST_CARD_TYPE,
   FIRST_PILL_EFFECT,
   FIRST_TRINKET_TYPE,
-  LAST_VANILLA_CARD,
+  LAST_VANILLA_CARD_TYPE,
   LAST_VANILLA_COLLECTIBLE_TYPE,
   LAST_VANILLA_PILL_EFFECT,
   LAST_VANILLA_TRINKET_TYPE,
-  NUM_VANILLA_CARDS,
+  NUM_VANILLA_CARD_TYPES,
   NUM_VANILLA_COLLECTIBLE_TYPES,
   NUM_VANILLA_PILL_EFFECTS,
   NUM_VANILLA_TRINKET_TYPES,
@@ -22,7 +22,7 @@ import {
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
 import {
-  asCard,
+  asCardType,
   asCollectibleType,
   asNumber,
   asPillEffect,
@@ -168,7 +168,7 @@ export function getFirstModdedTrinketType(): TrinketType | undefined {
 }
 
 /**
- * Will change depending on how many modded cards there are.
+ * Will change depending on how many modded trinkets there are.
  *
  * This is equal to the number of trinket types, since all trinket types are contiguous (unlike
  * collectibles).
@@ -206,7 +206,7 @@ export function getModdedTrinketTypes(): TrinketType[] {
 }
 
 /**
- * Will change depending on how many modded cards there are.
+ * Will change depending on how many modded trinkets there are.
  *
  * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
  * `TrinketType.NULL`.)
@@ -254,9 +254,9 @@ export function getTrinketTypes(): TrinketType[] {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getAllCards(): Card[] {
-  const lastCard = getLastCard();
-  return irange(FIRST_CARD, lastCard);
+export function getAllCardTypes(): CardType[] {
+  const lastCardType = getLastCardType();
+  return irange(FIRST_CARD_TYPE, lastCardType);
 }
 
 /**
@@ -265,13 +265,13 @@ export function getAllCards(): Card[] {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getFirstModdedCard(): Card | undefined {
+export function getFirstModdedCardType(): CardType | undefined {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
-  const firstModdedCard = asCard(asNumber(LAST_VANILLA_CARD) + 1);
-  const itemConfigCard = itemConfig.GetCard(firstModdedCard);
-  return itemConfigCard === undefined ? undefined : firstModdedCard;
+  const firstModdedCardType = asCardType(asNumber(LAST_VANILLA_CARD_TYPE) + 1);
+  const itemConfigCard = itemConfig.GetCard(firstModdedCardType);
+  return itemConfigCard === undefined ? undefined : firstModdedCardType;
 }
 
 /**
@@ -283,12 +283,12 @@ export function getFirstModdedCard(): Card | undefined {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getLastCard(): Card {
+export function getLastCardType(): CardType {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
-  const numCards = getNumCards();
-  return asCard(numCards);
+  const numCards = getNumCardTypes();
+  return asCardType(numCards);
 }
 
 /**
@@ -299,14 +299,14 @@ export function getLastCard(): Card {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getModdedCards(): Card[] {
-  const firstModdedCard = getFirstModdedCard();
-  if (firstModdedCard === undefined) {
+export function getModdedCardTypes(): CardType[] {
+  const firstModdedCardType = getFirstModdedCardType();
+  if (firstModdedCardType === undefined) {
     return [];
   }
 
-  const lastCard = getLastCard();
-  return irange(firstModdedCard, lastCard);
+  const lastCardType = getLastCardType();
+  return irange(firstModdedCardType, lastCardType);
 }
 
 /**
@@ -317,7 +317,7 @@ export function getModdedCards(): Card[] {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getNumCards(): int {
+export function getNumCardTypes(): int {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
@@ -328,12 +328,12 @@ export function getNumCards(): int {
  * This function can only be called if at least one callback has been executed. This is because not
  * all trinkets will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getNumModdedCards(): int {
+export function getNumModdedCardTypes(): int {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
-  const numCards = getNumCards();
-  return numCards - NUM_VANILLA_CARDS;
+  const numCardTypes = getNumCardTypes();
+  return numCardTypes - NUM_VANILLA_CARD_TYPES;
 }
 
 // ------------

package/src/features/playerInventory.ts

@@ -35,16 +35,12 @@ function newPlayerInventory(player: EntityPlayer) {
   const inventory: CollectibleType[] = [];
 
   for (const collectibleType of getCollectibleArray()) {
-    // We have to use the `EntityPlayer.HasCollectible` method in addition to the
-    // `EntityPlayer.GetCollectibleNum` method in order to mitigate situations like Lilith's Incubus
-    // counting as a collectible. (The former method will return false for her innate Incubus, but
-    // the latter method will return 1.)
-    if (player.HasCollectible(collectibleType)) {
-      const numCollectibles = player.GetCollectibleNum(collectibleType, true);
-      repeat(numCollectibles, () => {
-        inventory.push(collectibleType);
-      });
-    }
+    // We need to specify "true" as the second argument here to filter out things like Lilith's
+    // Incubus.
+    const numCollectibles = player.GetCollectibleNum(collectibleType, true);
+    repeat(numCollectibles, () => {
+      inventory.push(collectibleType);
+    });
   }
 
   return inventory;

package/src/features/preventCollectibleRotation.ts

@@ -2,7 +2,7 @@
 // switching mechanic.
 
 import {
-  Card,
+  CardType,
   CollectibleType,
   ModCallback,
   PickupVariant,
@@ -39,7 +39,7 @@ export function preventCollectibleRotationInit(mod: Mod): void {
   mod.AddCallback(
     ModCallback.POST_USE_CARD,
     useCardSoulOfIsaac,
-    Card.SOUL_ISAAC,
+    CardType.SOUL_ISAAC,
   ); // 5
 
   mod.AddCallback(