isaacscript-common 6.6.0 → 6.6.1-dev.2

package/functions/player.js

@@ -0,0 +1,808 @@
+import { ActiveSlot, CacheFlag, Challenge, CollectibleType, FamiliarVariant, NullItemID, PlayerForm, PlayerType, TrinketType, } from "isaac-typescript-definitions";
+import { game, itemConfig } from "../cachedClasses";
+import { HealthType } from "../enums/HealthType";
+import { getLastElement, sumArray } from "./array";
+import { countSetBits, getKBitOfN, getNumBitsOfN } from "./bitwise";
+import { getCharacterMaxHeartContainers, getCharacterName, isVanillaCharacter, } from "./character";
+import { getCollectibleMaxCharges } from "./collectibles";
+import { getCollectibleArray } from "./collectibleSet";
+import { getEnumValues } from "./enums";
+import { getPlayerIndexVanilla, getPlayers } from "./playerIndex";
+import { addTearsStat } from "./tears";
+import { repeat } from "./utils";
+const STAT_CACHE_FLAGS_SET = new Set([
+    CacheFlag.DAMAGE,
+    CacheFlag.FIRE_DELAY,
+    CacheFlag.SHOT_SPEED,
+    CacheFlag.RANGE,
+    CacheFlag.SPEED,
+    CacheFlag.LUCK, // 1 << 10
+]);
+export function addCollectibleCostume(player, collectibleType) {
+    const itemConfigItem = itemConfig.GetCollectible(collectibleType);
+    if (itemConfigItem === undefined) {
+        return;
+    }
+    player.AddCostume(itemConfigItem, false);
+}
+/**
+ * Helper function to add a stat to a player based on the `CacheFlag` provided. Call this function
+ * from the EvaluateCache callback.
+ *
+ * Note that for `CacheFlag.FIRE_DELAY`, the "amount" argument will be interpreted as the tear stat
+ * to add (and not the amount to mutate `EntityPlayer.MaxFireDelay` by).
+ *
+ * This function supports the following cache flags:
+ * - CacheFlag.DAMAGE (1 << 0)
+ * - CacheFlag.FIRE_DELAY (1 << 1)
+ * - CacheFlag.SHOT_SPEED (1 << 2)
+ * - CacheFlag.RANGE (1 << 3)
+ * - CacheFlag.SPEED (1 << 4)
+ * - CacheFlag.LUCK (1 << 10)
+ */
+export function addStat(player, cacheFlag, amount) {
+    if (!STAT_CACHE_FLAGS_SET.has(cacheFlag)) {
+        error(`You cannot add a stat to a player with the cache flag of: ${cacheFlag}`);
+    }
+    switch (cacheFlag) {
+        // 1 << 0
+        case CacheFlag.DAMAGE: {
+            player.Damage += amount;
+            break;
+        }
+        // 1 << 1
+        case CacheFlag.FIRE_DELAY: {
+            addTearsStat(player, amount);
+            break;
+        }
+        // 1 << 2
+        case CacheFlag.SHOT_SPEED: {
+            player.ShotSpeed += amount;
+            break;
+        }
+        // 1 << 3
+        case CacheFlag.RANGE: {
+            player.TearHeight += amount;
+            break;
+        }
+        // 1 << 4
+        case CacheFlag.SPEED: {
+            player.MoveSpeed += amount;
+            break;
+        }
+        // 1 << 10
+        case CacheFlag.LUCK: {
+            player.Luck += amount;
+            break;
+        }
+    }
+}
+export function addTrinketCostume(player, trinketType) {
+    const itemConfigTrinket = itemConfig.GetTrinket(trinketType);
+    if (itemConfigTrinket === undefined) {
+        return;
+    }
+    player.AddCostume(itemConfigTrinket, false);
+}
+export function anyPlayerHasCollectible(collectibleType) {
+    const players = getPlayers();
+    return players.some((player) => player.HasCollectible(collectibleType));
+}
+export function anyPlayerHasTrinket(trinketType) {
+    const players = getPlayers();
+    return players.some((player) => player.HasTrinket(trinketType));
+}
+/**
+ * Helper function to determine if the given character is present.
+ *
+ * This function is variadic, meaning that you can supply as many characters as you want to check
+ * for. Returns true if any of the characters supplied are present.
+ */
+export function anyPlayerIs(...matchingCharacters) {
+    const matchingCharacterSet = new Set(matchingCharacters);
+    const characters = getCharacters();
+    return characters.some((character) => matchingCharacterSet.has(character));
+}
+/**
+ * Helper function to determine if a player will destroy a rock/pot/skull if they walk over it.
+ *
+ * The following situations allow for this to be true:
+ * - the player has Leo (collectible 302)
+ * - the player has Thunder Thighs (collectible 314)
+ * - the player is under the effects of Mega Mush (collectible 625)
+ * - the player has Stompy (transformation 13)
+ */
+export function canPlayerCrushRocks(player) {
+    const effects = player.GetEffects();
+    return (player.HasCollectible(CollectibleType.LEO) ||
+        player.HasCollectible(CollectibleType.THUNDER_THIGHS) ||
+        effects.HasCollectibleEffect(CollectibleType.MEGA_MUSH) ||
+        player.HasPlayerForm(PlayerForm.STOMPY));
+}
+/**
+ * Returns whether or not all of the player's soul-heart-type hearts are black hearts.
+ *
+ * Note that this function does not consider red heart containers.
+ *
+ * For example:
+ *
+ * - If the player has one black heart, this function would return true.
+ * - If the player has one soul heart and two black hearts, this function would return false.
+ * - If the player has no black hearts, this function will return false.
+ * - If the player has one red heart container and three black hearts, this function would return
+ *   true.
+ */
+export function doesPlayerHaveAllBlackHearts(player) {
+    const soulHearts = getPlayerSoulHearts(player);
+    const blackHearts = getPlayerBlackHearts(player);
+    return blackHearts > 0 && soulHearts === 0;
+}
+/**
+ * Returns whether or not all of the player's soul-heart-type hearts are soul hearts.
+ *
+ * Note that this function does not consider red heart containers.
+ *
+ * For example:
+ *
+ * - If the player has two soul hearts and one black heart, this function would return false.
+ * - If the player has no soul hearts, this function will return false.
+ * - If the player has one red heart container and three soul hearts, this function would return
+ *   true.
+ */
+export function doesPlayerHaveAllSoulHearts(player) {
+    const soulHearts = getPlayerSoulHearts(player);
+    const blackHearts = getPlayerBlackHearts(player);
+    return soulHearts > 0 && blackHearts === 0;
+}
+/**
+ * Helper function to find the active slot that the player has the corresponding collectible type
+ * in. Returns undefined if the player does not have the collectible in any active slot.
+ */
+export function getActiveItemSlot(player, collectibleType) {
+    const activeSlots = getEnumValues(ActiveSlot);
+    return activeSlots.find((activeSlot) => {
+        const activeItem = player.GetActiveItem(activeSlot);
+        return activeItem === collectibleType;
+    });
+}
+/**
+ * Helper function to get how long Azazel's Brimstone laser should be. You can pass either an
+ * `EntityPlayer` object or a tear height stat.
+ *
+ * The formula for calculating it is: 32 - 2.5 * player.TearHeight
+ */
+export function getAzazelBrimstoneDistance(playerOrTearHeight) {
+    let tearHeight = tonumber(playerOrTearHeight);
+    if (tearHeight === undefined) {
+        const player = playerOrTearHeight;
+        tearHeight = player.TearHeight;
+    }
+    return 32 - 2.5 * tearHeight;
+}
+/** Helper function to get an array containing the characters of all of the current players. */
+export function getCharacters() {
+    const players = getPlayers();
+    return players.map((player) => player.GetPlayerType());
+}
+export function getClosestPlayer(position) {
+    let closestPlayer = null;
+    let closestDistance = math.huge;
+    for (const player of getPlayers()) {
+        const distance = position.Distance(player.Position);
+        if (distance < closestDistance) {
+            closestPlayer = player;
+            closestDistance = distance;
+        }
+    }
+    if (closestPlayer === null) {
+        error("Failed to find the closest player.");
+    }
+    return closestPlayer;
+}
+/**
+ * Helper function to get an array of temporary effects for a player. This is helpful so that you
+ * don't have to manually create an array from an `EffectsList` object.
+ */
+export function getEffectsList(player) {
+    const effects = player.GetEffects();
+    const effectsList = effects.GetEffectsList();
+    const effectArray = [];
+    for (let i = 0; i < effectsList.Size; i++) {
+        const effect = effectsList.Get(i);
+        if (effect !== undefined) {
+            effectArray.push(effect);
+        }
+    }
+    return effectArray;
+}
+/**
+ * Helper function to return the player with the highest ID, according to the `Isaac.GetPlayer`
+ * method.
+ */
+export function getFinalPlayer() {
+    const players = getPlayers();
+    const lastPlayer = getLastElement(players);
+    if (lastPlayer === undefined) {
+        error("Failed to get the final player since there were 0 players.");
+    }
+    return lastPlayer;
+}
+/**
+ * Helper function to get the first player with the lowest frame count. Useful to find a freshly
+ * spawned player after using items like Esau Jr. Don't use this function if two or more players
+ * will be spawned on the same frame.
+ */
+export function getNewestPlayer() {
+    let newestPlayer = null;
+    let lowestFrame = math.huge;
+    for (const player of getPlayers()) {
+        if (player.FrameCount < lowestFrame) {
+            newestPlayer = player;
+            lowestFrame = player.FrameCount;
+        }
+    }
+    if (newestPlayer === null) {
+        error("Failed to find the newest player.");
+    }
+    return newestPlayer;
+}
+/**
+ * Returns the number of slots that the player has remaining for new heart containers, accounting
+ * for broken hearts. For example, if the player is Judas and has 1 red heart containers and 2 full
+ * soul hearts and 3 broken hearts, then this function would return 6 (i.e. 12 - 1 - 2 - 3).
+ */
+export function getPlayerAvailableHeartSlots(player) {
+    const maxHeartContainers = getPlayerMaxHeartContainers(player);
+    const effectiveMaxHearts = player.GetEffectiveMaxHearts();
+    const normalAndBoneHeartContainers = effectiveMaxHearts / 2;
+    const soulHearts = player.GetSoulHearts();
+    const soulHeartContainers = math.ceil(soulHearts / 2);
+    const totalHeartContainers = normalAndBoneHeartContainers + soulHeartContainers;
+    const brokenHearts = player.GetBrokenHearts();
+    const totalOccupiedHeartSlots = totalHeartContainers + brokenHearts;
+    return maxHeartContainers - totalOccupiedHeartSlots;
+}
+/**
+ * Returns the number of black hearts that the player has, excluding any soul hearts. For example,
+ * if the player has one full black heart, one full soul heart, and one half black heart, this
+ * function returns 3.
+ *
+ * This is different from the `EntityPlayer.GetBlackHearts` method, since that returns a bitmask.
+ */
+export function getPlayerBlackHearts(player) {
+    const blackHeartsBitmask = player.GetBlackHearts();
+    const blackHeartBits = countSetBits(blackHeartsBitmask);
+    return blackHeartBits * 2;
+}
+/**
+ * Iterates over all players and checks if any are close enough to the specified position.
+ *
+ * @returns The first player found when iterating upwards from index 0.
+ */
+export function getPlayerCloserThan(position, distance) {
+    const players = getPlayers();
+    return players.find((player) => player.Position.Distance(position) <= distance);
+}
+/**
+ * Helper function to return the total amount of collectibles that a player has that match the
+ * collectible type(s) provided.
+ *
+ * This function is variadic, meaning that you can specify N collectible types.
+ */
+export function getPlayerCollectibleCount(player, ...collectibleTypes) {
+    let numCollectibles = 0;
+    for (const collectibleType of collectibleTypes) {
+        numCollectibles += player.GetCollectibleNum(collectibleType, true);
+    }
+    return numCollectibles;
+}
+/**
+ * Iterates over every item in the game and returns a map containing the number of each item that
+ * the player has.
+ */
+export function getPlayerCollectibleMap(player) {
+    const collectibleArray = getCollectibleArray();
+    const collectibleMap = new Map();
+    for (const collectibleType of collectibleArray) {
+        const collectibleNum = player.GetCollectibleNum(collectibleType, true);
+        if (collectibleNum > 0) {
+            collectibleMap.set(collectibleType, collectibleNum);
+        }
+    }
+    return collectibleMap;
+}
+/** Helper function to get the player from a tear, laser, bomb, etc. */
+export function getPlayerFromTear(entity) {
+    if (entity.Parent !== undefined) {
+        const player = entity.Parent.ToPlayer();
+        if (player !== undefined) {
+            return player;
+        }
+        const familiar = entity.Parent.ToFamiliar();
+        if (familiar !== undefined &&
+            familiar.Variant === FamiliarVariant.INCUBUS) {
+            return familiar.Player;
+        }
+    }
+    if (entity.SpawnerEntity !== undefined) {
+        const player = entity.SpawnerEntity.ToPlayer();
+        if (player !== undefined) {
+            return player;
+        }
+        const familiar = entity.SpawnerEntity.ToFamiliar();
+        if (familiar !== undefined &&
+            familiar.Variant === FamiliarVariant.INCUBUS) {
+            return familiar.Player;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns the number of red hearts that the player has, excluding any rotten hearts. For example,
+ * if the player has one full black heart, one full soul heart, and one half black heart, this
+ * function returns 3.
+ *
+ * This is different from the `EntityPlayer.GetHearts` method, since that returns a value that
+ * includes rotten hearts.
+ */
+export function getPlayerHearts(player) {
+    const rottenHearts = player.GetRottenHearts();
+    const hearts = player.GetHearts();
+    return hearts - rottenHearts * 2;
+}
+/**
+ * Helper function that returns the type of the rightmost heart. This does not including golden
+ * hearts or broken hearts, since they cannot be damaged directly.
+ */
+export function getPlayerLastHeart(player) {
+    const hearts = player.GetHearts();
+    const effectiveMaxHearts = player.GetEffectiveMaxHearts();
+    const soulHearts = player.GetSoulHearts();
+    const blackHearts = player.GetBlackHearts();
+    const eternalHearts = player.GetEternalHearts();
+    const boneHearts = player.GetBoneHearts();
+    const rottenHearts = player.GetRottenHearts();
+    const soulHeartSlots = soulHearts / 2;
+    const lastHeartIndex = boneHearts + soulHeartSlots - 1;
+    const isLastHeartBone = player.IsBoneHeart(lastHeartIndex);
+    if (isLastHeartBone) {
+        const isLastContainerEmpty = hearts <= effectiveMaxHearts - 2;
+        if (isLastContainerEmpty) {
+            return HealthType.BONE;
+        }
+        if (rottenHearts > 0) {
+            return HealthType.ROTTEN;
+        }
+        if (eternalHearts > 0) {
+            return HealthType.ETERNAL;
+        }
+        return HealthType.RED;
+    }
+    if (soulHearts > 0) {
+        const numBits = getNumBitsOfN(blackHearts);
+        const finalBit = getKBitOfN(numBits - 1, blackHearts);
+        const isBlack = finalBit === 1;
+        if (isBlack) {
+            return HealthType.BLACK;
+        }
+        // If it is not a black heart, it must be a soul heart.
+        return HealthType.SOUL;
+    }
+    if (eternalHearts > 0) {
+        return HealthType.ETERNAL;
+    }
+    if (rottenHearts > 0) {
+        return HealthType.ROTTEN;
+    }
+    return HealthType.RED;
+}
+/**
+ * Returns the maximum heart containers that the provided player can have. Normally, this is 12, but
+ * it can change depending on the character (e.g. Keeper) and other things (e.g. Mother's Kiss).
+ * This function does not account for Broken Hearts; use the `getPlayerAvailableHeartSlots` helper
+ * function for that.
+ */
+export function getPlayerMaxHeartContainers(player) {
+    const character = player.GetPlayerType();
+    const characterMaxHeartContainers = getCharacterMaxHeartContainers(character);
+    // 1
+    // Magdalene can increase her maximum heart containers with Birthright.
+    if (character === PlayerType.MAGDALENE &&
+        player.HasCollectible(CollectibleType.BIRTHRIGHT)) {
+        const extraMaxHeartContainersFromBirthright = 6;
+        return characterMaxHeartContainers + extraMaxHeartContainersFromBirthright;
+    }
+    // 14, 33
+    // Keeper and Tainted Keeper can increase their coin containers with Mother's Kiss and Greed's
+    // Gullet.
+    if (isKeeper(player)) {
+        const numMothersKisses = player.GetTrinketMultiplier(TrinketType.MOTHERS_KISS);
+        const hasGreedsGullet = player.HasCollectible(CollectibleType.GREEDS_GULLET);
+        const coins = player.GetNumCoins();
+        const greedsGulletCoinContainers = hasGreedsGullet
+            ? Math.floor(coins / 25)
+            : 0;
+        return (characterMaxHeartContainers +
+            numMothersKisses +
+            greedsGulletCoinContainers);
+    }
+    return characterMaxHeartContainers;
+}
+/**
+ * Helper function to get the proper name of the player. Use this instead of the
+ * `EntityPlayer.GetName` method because it accounts for Blue Baby, Lazarus II, and Tainted
+ * characters.
+ */
+export function getPlayerName(player) {
+    const character = player.GetPlayerType();
+    // Account for modded characters.
+    return isModdedPlayer(player)
+        ? player.GetName()
+        : getCharacterName(character);
+}
+/**
+ * Returns the combined value of all of the player's red hearts, soul/black hearts, and bone hearts,
+ * minus the value of the player's rotten hearts.
+ *
+ * This is equivalent to the number of hits that the player can currently take, but does not take
+ * into account double damage from champion enemies and/or being on later floors. (For example, on
+ * Womb 1, players who have 1 soul heart remaining would die in 1 hit to anything, even though this
+ * function would report that they have 2 hits remaining.)
+ */
+export function getPlayerNumHitsRemaining(player) {
+    const hearts = player.GetHearts();
+    const soulHearts = player.GetSoulHearts();
+    const boneHearts = player.GetBoneHearts();
+    const eternalHearts = player.GetEternalHearts();
+    const rottenHearts = player.GetRottenHearts();
+    return hearts + soulHearts + boneHearts + eternalHearts - rottenHearts;
+}
+/**
+ * Returns the number of soul hearts that the player has, excluding any black hearts. For example,
+ * if the player has one full black heart, one full soul heart, and one half black heart, this
+ * function returns 2.
+ *
+ * This is different from the `EntityPlayer.GetSoulHearts` method, since that returns the combined
+ * number of soul hearts and black hearts.
+ */
+export function getPlayerSoulHearts(player) {
+    const soulHearts = player.GetSoulHearts();
+    const blackHearts = getPlayerBlackHearts(player);
+    return soulHearts - blackHearts;
+}
+/**
+ * Helper function to get all of the players that are a certain character.
+ *
+ * This function is variadic, meaning that you can supply as many characters as you want to check
+ * for. Returns true if any of the characters supplied are present.
+ */
+export function getPlayersOfType(...characters) {
+    const charactersSet = new Set(characters);
+    const players = getPlayers();
+    return players.filter((player) => {
+        const character = player.GetPlayerType();
+        return charactersSet.has(character);
+    });
+}
+/**
+ * Helper function to get only the players that have a certain collectible.
+ *
+ * This function is variadic, meaning that you can supply as many collectible types as you want to
+ * check for. It only returns the players that have all of the collectibles.
+ */
+export function getPlayersWithCollectible(...collectibleTypes) {
+    const players = getPlayers();
+    return players.filter((player) => collectibleTypes.every((collectibleType) => player.HasCollectible(collectibleType)));
+}
+/**
+ * Helper function to get only the players that have a certain trinket.
+ *
+ * This function is variadic, meaning that you can supply as many trinket types as you want to check
+ * for. It only returns the players that have all of the trinkets.
+ */
+export function getPlayersWithTrinket(...trinketTypes) {
+    const players = getPlayers();
+    return players.filter((player) => trinketTypes.every((trinketType) => player.HasTrinket(trinketType)));
+}
+/**
+ * Helper function to determine how many heart containers that Tainted Magdalene has that will not
+ * be automatically depleted over time. By default, this is 2, but this function will return 4 so
+ * that it is consistent with the `player.GetHearts` and `player.GetMaxHearts` methods.
+ *
+ * If Tainted Magdalene has Birthright, she will gained an additional non-temporary heart container.
+ *
+ * This function does not validate whether or not the provided player is Tainted Magdalene; that
+ * should be accomplished before invoking this function.
+ */
+export function getTaintedMagdaleneNonTemporaryMaxHearts(player) {
+    const maxHearts = player.GetMaxHearts();
+    const hasBirthright = player.HasCollectible(CollectibleType.BIRTHRIGHT);
+    const maxNonTemporaryMaxHearts = hasBirthright ? 6 : 4;
+    return Math.min(maxHearts, maxNonTemporaryMaxHearts);
+}
+/**
+ * Returns the total number of collectibles amongst all players. For example, if player 1 has 1 Sad
+ * Onion and player 2 has 2 Sad Onions, then this function would return 3.
+ */
+export function getTotalPlayerCollectibles(collectibleType) {
+    const players = getPlayers();
+    const numCollectiblesArray = players.map((player) => player.GetCollectibleNum(collectibleType));
+    return sumArray(numCollectiblesArray);
+}
+/** After touching a white fire, a player will turn into The Lost until they clear a room. */
+export function hasLostCurse(player) {
+    const effects = player.GetEffects();
+    return effects.HasNullEffect(NullItemID.LOST_CURSE);
+}
+/**
+ * Returns whether or not the player can hold an additional active item, beyond what they are
+ * currently carrying. This takes the Schoolbag into account.
+ *
+ * If the player is the Tainted Soul, this always returns false, since that character cannot pick up
+ * items. (Only Tainted Forgotten can pick up items.)
+ */
+export function hasOpenActiveItemSlot(player) {
+    if (isCharacter(player, PlayerType.THE_SOUL_B)) {
+        return false;
+    }
+    const activeItemPrimary = player.GetActiveItem(ActiveSlot.PRIMARY);
+    const activeItemSecondary = player.GetActiveItem(ActiveSlot.SECONDARY);
+    const hasSchoolbag = player.HasCollectible(CollectibleType.SCHOOLBAG);
+    if (hasSchoolbag) {
+        return (activeItemPrimary === CollectibleType.NULL ||
+            activeItemSecondary === CollectibleType.NULL);
+    }
+    return activeItemPrimary === CollectibleType.NULL;
+}
+export function isActiveSlotEmpty(player, activeSlot) {
+    const activeCollectibleType = player.GetActiveItem(activeSlot);
+    return activeCollectibleType === CollectibleType.NULL;
+}
+/**
+ * Helper function for detecting when a player is Bethany or Tainted Bethany. This is useful if you
+ * need to adjust UI elements to account for Bethany's soul charges or Tainted Bethany's blood
+ * charges.
+ */
+export function isBethany(player) {
+    const character = player.GetPlayerType();
+    return character === PlayerType.BETHANY || character === PlayerType.BETHANY_B;
+}
+/**
+ * Helper function to check if a player is a specific character (i.e. `PlayerType`).
+ *
+ * This function is variadic, meaning that you can supply as many characters as you want to check
+ * for. Returns true if the player is any of the supplied characters.
+ */
+export function isCharacter(player, ...characters) {
+    const characterSet = new Set(characters);
+    const character = player.GetPlayerType();
+    return characterSet.has(character);
+}
+/**
+ * Helper function to see if a damage source is from a player. Use this instead of comparing to the
+ * entity directly because it takes familiars into account.
+ */
+export function isDamageFromPlayer(damageSource) {
+    const player = damageSource.ToPlayer();
+    if (player !== undefined) {
+        return true;
+    }
+    const indirectPlayer = getPlayerFromTear(damageSource);
+    return indirectPlayer !== undefined;
+}
+/**
+ * Helper function for detecting when a player is Eden or Tainted Eden. Useful for situations where
+ * you want to know if the starting stats were randomized, for example.
+ */
+export function isEden(player) {
+    const character = player.GetPlayerType();
+    return character === PlayerType.EDEN || character === PlayerType.EDEN_B;
+}
+export function isFirstPlayer(player) {
+    return getPlayerIndexVanilla(player) === 0;
+}
+/**
+ * Helper function for detecting when a player is Jacob or Esau. This will only match the
+ * non-tainted versions of these characters.
+ */
+export function isJacobOrEsau(player) {
+    const character = player.GetPlayerType();
+    return character === PlayerType.JACOB || character === PlayerType.ESAU;
+}
+/**
+ * Helper function for detecting when a player is Keeper or Tainted Keeper. Useful for situations
+ * where you want to know if the health is coin hearts, for example.
+ */
+export function isKeeper(player) {
+    const character = player.GetPlayerType();
+    return character === PlayerType.KEEPER || character === PlayerType.KEEPER_B;
+}
+/** Helper function for detecting when a player is The Lost or Tainted Lost. */
+export function isLost(player) {
+    const character = player.GetPlayerType();
+    return (character === PlayerType.THE_LOST || character === PlayerType.THE_LOST_B);
+}
+export function isModdedPlayer(player) {
+    return !isVanillaPlayer(player);
+}
+/** Helper function for detecting if a player is one of the Tainted characters. */
+export function isTainted(player) {
+    const character = player.GetPlayerType();
+    return isVanillaPlayer(player)
+        ? character >= PlayerType.ISAAC_B
+        : isTaintedModded(player);
+}
+function isTaintedModded(player) {
+    // This algorithm only works for modded characters because the `Isaac.GetPlayerTypeByName` method
+    // is bugged.
+    // https://github.com/Meowlala/RepentanceAPIIssueTracker/issues/117
+    const character = player.GetPlayerType();
+    const name = player.GetName();
+    const taintedCharacter = Isaac.GetPlayerTypeByName(name, true);
+    return character === taintedCharacter;
+}
+/** Helper function for detecting when a player is Tainted Lazarus or Dead Tainted Lazarus. */
+export function isTaintedLazarus(player) {
+    const character = player.GetPlayerType();
+    return (character === PlayerType.LAZARUS_B || character === PlayerType.LAZARUS_2_B);
+}
+export function isVanillaPlayer(player) {
+    const character = player.GetPlayerType();
+    return isVanillaCharacter(character);
+}
+/**
+ * Helper function to add one or more collectibles to a player.
+ *
+ * This function is variadic, meaning that you can supply as many collectible types as you want to
+ * add.
+ */
+export function playerAddCollectible(player, ...collectibleTypes) {
+    for (const collectibleType of collectibleTypes) {
+        player.AddCollectible(collectibleType);
+    }
+}
+/**
+ * Helper function to check to see if a player has one or more collectibles.
+ *
+ * This function is variadic, meaning that you can supply as many collectible types as you want to
+ * check for. Returns true if the player has any of the supplied collectible types.
+ */
+export function playerHasCollectible(player, ...collectibleTypes) {
+    return collectibleTypes.some((collectibleType) => player.HasCollectible(collectibleType));
+}
+/**
+ * Helper function to remove a collectible costume from a player. Use this helper function to avoid
+ * having to request the collectible from the item config.
+ */
+export function removeCollectibleCostume(player, collectibleType) {
+    const itemConfigItem = itemConfig.GetCollectible(collectibleType);
+    if (itemConfigItem === undefined) {
+        return;
+    }
+    player.RemoveCostume(itemConfigItem);
+}
+/**
+ * Helper function to remove the Dead Eye multiplier from a player.
+ *
+ * Note that each time the `EntityPlayer.ClearDeadEyeCharge` method is called, it only has a chance
+ * of working, so this function calls it 100 times to be safe.
+ */
+export function removeDeadEyeMultiplier(player) {
+    repeat(100, () => {
+        player.ClearDeadEyeCharge();
+    });
+}
+/**
+ * Helper function to remove a trinket costume from a player. Use this helper function to avoid
+ * having to request the trinket from the item config.
+ */
+export function removeTrinketCostume(player, trinketType) {
+    const itemConfigTrinket = itemConfig.GetTrinket(trinketType);
+    if (itemConfigTrinket === undefined) {
+        return;
+    }
+    player.RemoveCostume(itemConfigTrinket);
+}
+/**
+ * Helper function to set an active collectible to a particular slot. This has different behavior
+ * than calling the `player.AddCollectible` method with the `activeSlot` argument, because this
+ * function will not shift existing items into the Schoolbag and it handles
+ * `ActiveSlot.SLOT_POCKET2`.
+ *
+ * Note that if an item is set to `ActiveSlot.SLOT_POCKET2`, it will disappear after being used and
+ * will be automatically removed upon entering a new room.
+ *
+ * @param player The player to give the item to.
+ * @param collectibleType The collectible type of the item to give.
+ * @param activeSlot The slot to set.
+ * @param charge Optional. The argument of charges to set. If not specified, the item will be set
+ *               with maximum charges.
+ * @param keepInPools Optional. Whether or not to remove the item from pools. Default is false.
+ */
+export function setActiveItem(player, collectibleType, activeSlot, charge, keepInPools = false) {
+    const itemPool = game.GetItemPool();
+    const primaryCollectibleType = player.GetActiveItem(ActiveSlot.PRIMARY);
+    const primaryCharge = player.GetActiveCharge(ActiveSlot.PRIMARY);
+    const secondaryCollectibleType = player.GetActiveItem(ActiveSlot.SECONDARY);
+    if (charge === undefined) {
+        charge = getCollectibleMaxCharges(collectibleType);
+    }
+    if (!keepInPools) {
+        itemPool.RemoveCollectible(collectibleType);
+    }
+    switch (activeSlot) {
+        case ActiveSlot.PRIMARY: {
+            // If there is a Schoolbag item, removing the primary item will shift the Schoolbag item to
+            // the primary slot.
+            if (primaryCollectibleType !== CollectibleType.NULL) {
+                player.RemoveCollectible(primaryCollectibleType);
+            }
+            // If there was a Schoolbag item, adding a new primary item will shift it back into the
+            // secondary slot.
+            player.AddCollectible(collectibleType, charge, false);
+            break;
+        }
+        case ActiveSlot.SECONDARY: {
+            if (primaryCollectibleType !== CollectibleType.NULL) {
+                player.RemoveCollectible(primaryCollectibleType);
+            }
+            if (secondaryCollectibleType !== CollectibleType.NULL) {
+                player.RemoveCollectible(secondaryCollectibleType);
+            }
+            // Add the new item, which will go to the primary slot.
+            player.AddCollectible(secondaryCollectibleType, charge, false);
+            // Add back the original primary item, if any.
+            if (primaryCollectibleType !== CollectibleType.NULL) {
+                player.AddCollectible(primaryCollectibleType, primaryCharge, false);
+            }
+            break;
+        }
+        case ActiveSlot.POCKET: {
+            player.SetPocketActiveItem(collectibleType, activeSlot, keepInPools);
+            player.SetActiveCharge(charge, activeSlot);
+            break;
+        }
+        case ActiveSlot.POCKET_SINGLE_USE: {
+            player.SetPocketActiveItem(collectibleType, activeSlot, keepInPools);
+            break;
+        }
+    }
+}
+/**
+ * Helper function to blindfold the player by using a hack with the challenge variable.
+ *
+ * The method used in this function was discovered by im_tem.
+ *
+ * @param player The player to apply or remove the blindfold state from.
+ * @param enabled Whether or not to apply or remove the blindfold.
+ * @param modifyCostume Optional. Whether to add or remove the blindfold costume. Default is true.
+ */
+export function setBlindfold(player, enabled, modifyCostume = true) {
+    const character = player.GetPlayerType();
+    const challenge = Isaac.GetChallenge();
+    if (enabled) {
+        game.Challenge = Challenge.SOLAR_SYSTEM; // This challenge has a blindfold
+        player.ChangePlayerType(character);
+        game.Challenge = challenge;
+        // The costume is applied automatically.
+        if (!modifyCostume) {
+            player.TryRemoveNullCostume(NullItemID.BLINDFOLD);
+        }
+    }
+    else {
+        game.Challenge = Challenge.NULL;
+        player.ChangePlayerType(character);
+        game.Challenge = challenge;
+        if (modifyCostume) {
+            player.TryRemoveNullCostume(NullItemID.BLINDFOLD);
+        }
+    }
+}
+/**
+ * Helper function to use an active item without showing an animation, keeping the item, or adding
+ * any costumes.
+ */
+export function useActiveItemTemp(player, collectibleType) {
+    player.UseActiveItem(collectibleType, false, false, true, false, -1);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/functions/player.ts"],"names":[],"mappings":"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"}