isaacscript-common 6.6.1-dev.1 → 6.6.1-dev.2

package/functions/string.js

@@ -0,0 +1,37 @@
+export function capitalizeFirstLetter(string) {
+    const firstCharacter = string.charAt(0);
+    const capitalizedFirstLetter = firstCharacter.toUpperCase();
+    const restOfString = string.slice(1);
+    return `${capitalizedFirstLetter}${restOfString}`;
+}
+export function removeAllCharacters(string, character) {
+    return string.replaceAll(character, "");
+}
+/**
+ * Helper function to remove one or more substrings from a string, if they exist. Returns the
+ * modified string.
+ *
+ * This function is variadic, meaning that you can pass as many substrings as you want to remove.
+ */
+export function removeSubstring(string, ...substrings) {
+    for (const substring of substrings) {
+        string = string.replaceAll(substring, "");
+    }
+    return string;
+}
+/** Helper function to trim a prefix from a string, if it exists. Returns the trimmed string. */
+export function trimPrefix(string, prefix) {
+    if (!string.startsWith(prefix)) {
+        return string;
+    }
+    return string.slice(prefix.length);
+}
+/** Helper function to trim a suffix from a string, if it exists. Returns the trimmed string. */
+export function trimSuffix(string, prefix) {
+    if (!string.endsWith(prefix)) {
+        return string;
+    }
+    const endCharacter = string.length - prefix.length;
+    return string.slice(0, endCharacter);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mdW5jdGlvbnMvc3RyaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxxQkFBcUIsQ0FBQyxNQUFjO0lBQ2xELE1BQU0sY0FBYyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDeEMsTUFBTSxzQkFBc0IsR0FBRyxjQUFjLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDNUQsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUVyQyxPQUFPLEdBQUcsc0JBQXNCLEdBQUcsWUFBWSxFQUFFLENBQUM7QUFDcEQsQ0FBQztBQUVELE1BQU0sVUFBVSxtQkFBbUIsQ0FBQyxNQUFjLEVBQUUsU0FBaUI7SUFDbkUsT0FBTyxNQUFNLENBQUMsVUFBVSxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztBQUMxQyxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUM3QixNQUFjLEVBQ2QsR0FBRyxVQUFvQjtJQUV2QixLQUFLLE1BQU0sU0FBUyxJQUFJLFVBQVUsRUFBRTtRQUNsQyxNQUFNLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsRUFBRSxDQUFDLENBQUM7S0FDM0M7SUFFRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBRUQsZ0dBQWdHO0FBQ2hHLE1BQU0sVUFBVSxVQUFVLENBQUMsTUFBYyxFQUFFLE1BQWM7SUFDdkQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLEVBQUU7UUFDOUIsT0FBTyxNQUFNLENBQUM7S0FDZjtJQUVELE9BQU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDckMsQ0FBQztBQUVELGdHQUFnRztBQUNoRyxNQUFNLFVBQVUsVUFBVSxDQUFDLE1BQWMsRUFBRSxNQUFjO0lBQ3ZELElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1FBQzVCLE9BQU8sTUFBTSxDQUFDO0tBQ2Y7SUFFRCxNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDbkQsT0FBTyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxZQUFZLENBQUMsQ0FBQztBQUN2QyxDQUFDIn0=

package/functions/table.js

@@ -0,0 +1,143 @@
+import { isBoolean, isNumber, isString } from "./types";
+/**
+ * In a Map, you can use the `clear` method to delete every element. However, in a LuaTable, the
+ * `clear` method does not exist. Use this helper function as a drop-in replacement for this.
+ */
+export function clearTable(luaTable) {
+    for (const [key] of pairs(luaTable)) {
+        luaTable.delete(key);
+    }
+}
+/** Helper function to copy specific values from a object to a table. */
+export function copyValuesToTable(object, keys, luaTable) {
+    const otherTable = object;
+    for (const key of keys) {
+        const value = otherTable.get(key);
+        luaTable.set(key, value);
+    }
+}
+/**
+ * Helper function to safely get boolean values from a Lua table. Will throw an error if the
+ * specific value does not exist on the table.
+ *
+ * This function is variadic, meaning that you can specify N arguments to get N values.
+ */
+export function getBooleansFromTable(luaTable, objectName, ...keys) {
+    const booleans = [];
+    for (const key of keys) {
+        const value = luaTable.get(key);
+        if (value === undefined) {
+            error(`Failed to find a value for "${key}" in a table representing a "${objectName}" object.`);
+        }
+        if (isBoolean(value)) {
+            booleans.push(value);
+        }
+        else {
+            error(`Failed to get the boolean for the "${key}" value of a table representing a "${objectName}" object because the type was: ${typeof value}`);
+        }
+    }
+    return booleans;
+}
+/**
+ * Helper function to safely get number values from a Lua table. Will throw an error if the specific
+ * value does not exist on the table or if it cannot be converted to a number.
+ *
+ * This function is variadic, meaning that you can specify N arguments to get N values.
+ */
+export function getNumbersFromTable(luaTable, objectName, ...keys) {
+    const numbers = [];
+    for (const key of keys) {
+        const value = luaTable.get(key);
+        if (value === undefined) {
+            error(`Failed to find a value for "${key}" in a table representing a "${objectName}" object.`);
+        }
+        if (isNumber(value)) {
+            numbers.push(value);
+        }
+        else if (isString(value)) {
+            const number = tonumber(value);
+            if (number === undefined) {
+                error(`Failed to convert the "${key}" value of a table representing a "${objectName}" object to a number: ${value}`);
+            }
+            numbers.push(number);
+        }
+        else {
+            error(`Failed to get the number for the "${key}" value of a table representing a "${objectName}" object because the type was: ${typeof value}`);
+        }
+    }
+    return numbers;
+}
+/**
+ * Helper function to safely get string values from a Lua table. Will throw an error if the specific
+ * value does not exist on the table.
+ *
+ * This function is variadic, meaning that you can specify N arguments to get N values.
+ */
+export function getStringsFromTable(luaTable, objectName, ...keys) {
+    const strings = [];
+    for (const key of keys) {
+        const value = luaTable.get(key);
+        if (value === undefined) {
+            error(`Failed to find a value for "${key}" in a table representing a "${objectName}" object.`);
+        }
+        if (isString(value)) {
+            strings.push(value);
+        }
+        else {
+            const string = tostring(value);
+            strings.push(string);
+        }
+    }
+    return strings;
+}
+/**
+ * Helper function to iterate over a table deterministically. This is useful because by default, the
+ * `pairs` function will return the keys of a Lua table in a random order.
+ *
+ * This function will sort the table entries based on the value of the key.
+ *
+ * This function will only work on tables that have number keys or string keys. It will throw a
+ * runtime error if it encounters a key of another type.
+ *
+ * @param luaTable The table to iterate over.
+ * @param func The function to run for each iteration.
+ * @param inOrder Optional. Whether to iterate in order. True by default. You can dynamically set to
+ *                false in situations where iterating randomly would not matter and you need the
+ *                extra performance.
+ */
+export function iterateTableInOrder(luaTable, func, inOrder = true) {
+    // First, handle the trivial case of a non-deterministic iteration.
+    if (!inOrder) {
+        for (const [key, value] of pairs(luaTable)) {
+            func(key, value);
+        }
+        return;
+    }
+    const keys = Object.keys(luaTable);
+    const hasAllNumberKeys = keys.every((key) => isNumber(key));
+    const hasAllStringKeys = keys.every((key) => isString(key));
+    if (!hasAllNumberKeys && !hasAllStringKeys) {
+        // Since the table has non-homogenous keys, we won't be able to sort it. Revert to
+        // non-deterministic iteration in this case.
+        for (const [key, value] of pairs(luaTable)) {
+            func(key, value);
+        }
+        return;
+    }
+    keys.sort();
+    for (const key of keys) {
+        const keyIndex = key;
+        const value = luaTable.get(keyIndex);
+        func(keyIndex, value);
+    }
+}
+/**
+ * Helper function to check if a Lua table has all of the provided keys.
+ *
+ * This function is variadic, meaning that you can specify as many arguments as you want to check
+ * for.
+ */
+export function tableHasKeys(luaTable, ...keys) {
+    return keys.every((key) => luaTable.has(key));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/tears.js

@@ -0,0 +1,31 @@
+/**
+ * - Converts the specified amount of tears stat into MaxFireDelay and adds it to the player.
+ * - This function should only be used inside the EvaluateCache callback.
+ * - In this context, the "tears stat" represents what is shown on the in-game stat UI.
+ */
+export function addTearsStat(player, tearsStat) {
+    const existingTearsStat = getTearsStat(player.MaxFireDelay);
+    const newTearsStat = existingTearsStat + tearsStat;
+    const newMaxFireDelay = getFireDelay(newTearsStat);
+    player.MaxFireDelay = newMaxFireDelay;
+}
+/**
+ * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` attribute. This is
+ *   equivalent to how many tears the player can shoot per frame.
+ * - If you already have a "tears" stat and you want to convert it back to MaxFireDelay, then use
+ *   this function.
+ * - In this context, the "tears stat" represents what is shown on the in-game stat UI.
+ */
+export function getFireDelay(tearsStat) {
+    return math.max(30 / tearsStat - 1, -0.9999);
+}
+/**
+ * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` attribute. This is
+ *   equivalent to how many tears the player can shoot per frame.
+ * - If you want to convert this to the "tears" stat that is shown on the in-game stat UI, then use
+ *   this function.
+ */
+export function getTearsStat(fireDelay) {
+    return 30 / (fireDelay + 1);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVhcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2Z1bmN0aW9ucy90ZWFycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxNQUFvQixFQUFFLFNBQWdCO0lBQ2pFLE1BQU0saUJBQWlCLEdBQUcsWUFBWSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUM1RCxNQUFNLFlBQVksR0FBRyxpQkFBaUIsR0FBRyxTQUFTLENBQUM7SUFDbkQsTUFBTSxlQUFlLEdBQUcsWUFBWSxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ25ELE1BQU0sQ0FBQyxZQUFZLEdBQUcsZUFBZSxDQUFDO0FBQ3hDLENBQUM7QUFFRDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFDLFNBQWdCO0lBQzNDLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEdBQUcsU0FBUyxHQUFHLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQy9DLENBQUM7QUFFRDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQUMsU0FBZ0I7SUFDM0MsT0FBTyxFQUFFLEdBQUcsQ0FBQyxTQUFTLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFDOUIsQ0FBQyJ9

package/functions/transformations.js

@@ -0,0 +1,101 @@
+import { ItemConfigTag, PlayerForm, } from "isaac-typescript-definitions";
+import { TRANSFORMATION_NAMES } from "../objects/transformationNames";
+import { getCollectibleTags } from "./collectibles";
+import { getCollectibleTypesWithTag } from "./collectibleTag";
+import { getEnumValues } from "./enums";
+import { hasFlag } from "./flag";
+import { getPlayerCollectibleCount } from "./player";
+const TRANSFORMATION_TO_TAG_MAP = new Map([
+    [PlayerForm.GUPPY, ItemConfigTag.GUPPY],
+    [PlayerForm.BEELZEBUB, ItemConfigTag.FLY],
+    [PlayerForm.FUN_GUY, ItemConfigTag.MUSHROOM],
+    [PlayerForm.SERAPHIM, ItemConfigTag.ANGEL],
+    [PlayerForm.BOB, ItemConfigTag.BOB],
+    [PlayerForm.SPUN, ItemConfigTag.SYRINGE],
+    [PlayerForm.YES_MOTHER, ItemConfigTag.MOM],
+    [PlayerForm.CONJOINED, ItemConfigTag.BABY],
+    [PlayerForm.LEVIATHAN, ItemConfigTag.DEVIL],
+    [PlayerForm.OH_CRAP, ItemConfigTag.POOP],
+    [PlayerForm.BOOKWORM, ItemConfigTag.BOOK],
+    // PlayerForm.ADULTHOOD (11) is based on pill usage.
+    [PlayerForm.SPIDER_BABY, ItemConfigTag.SPIDER], // 12
+    // PlayerForm.STOMPY (13) is based on size.
+]);
+const TRANSFORMATIONS_THAT_GRANT_FLYING = new Set([
+    PlayerForm.GUPPY,
+    PlayerForm.BEELZEBUB,
+    PlayerForm.SERAPHIM,
+    PlayerForm.LEVIATHAN, // 8
+]);
+/**
+ * Helper function to get all of the collectible types in the game that count towards a particular
+ * transformation.
+ *
+ * For example, to get all of the collectible types that count towards Guppy:
+ *
+ * ```ts
+ * const guppyCollectibleTypes = getCollectibleTypesForTransformation(PlayerForm.GUPPY);
+ * ```
+ */
+export function getCollectibleTypesForTransformation(playerForm) {
+    const itemConfigTag = TRANSFORMATION_TO_TAG_MAP.get(playerForm);
+    if (itemConfigTag === undefined) {
+        error(`Failed to get the collectible types for the transformation of ${playerForm} because that transformation is not based on collectibles.`);
+    }
+    return getCollectibleTypesWithTag(itemConfigTag);
+}
+/** Returns the number of items that a player has towards a particular transformation. */
+export function getPlayerNumCollectiblesForTransformation(player, playerForm) {
+    const collectibleTypes = getCollectibleTypesForTransformation(playerForm);
+    return getPlayerCollectibleCount(player, ...collectibleTypes.values());
+}
+/** Returns a set of the player's current transformations. */
+export function getPlayerTransformations(player) {
+    const transformations = new Set();
+    for (const playerForm of getEnumValues(PlayerForm)) {
+        if (player.HasPlayerForm(playerForm)) {
+            transformations.add(playerForm);
+        }
+    }
+    return transformations;
+}
+/**
+ * Helper function to get a transformation name from a PlayerForm enum.
+ *
+ * For example:
+ *
+ * ```ts
+ * const transformationName = getTransformationName(PlayerForm.LORD_OF_THE_FLIES);
+ * // transformationName is "Beelzebub"
+ * ```
+ */
+export function getTransformationName(playerForm) {
+    return TRANSFORMATION_NAMES[playerForm];
+}
+export function getTransformationsForCollectibleType(collectibleType) {
+    const itemConfigTags = getCollectibleTags(collectibleType);
+    const playerForms = getEnumValues(PlayerForm);
+    const transformationSet = new Set();
+    for (const playerForm of playerForms) {
+        const itemConfigTag = TRANSFORMATION_TO_TAG_MAP.get(playerForm);
+        if (itemConfigTag === undefined) {
+            continue;
+        }
+        if (hasFlag(itemConfigTags, itemConfigTag)) {
+            transformationSet.add(playerForm);
+        }
+    }
+    return transformationSet;
+}
+export function hasFlyingTransformation(player) {
+    for (const playerForm of TRANSFORMATIONS_THAT_GRANT_FLYING.values()) {
+        if (player.HasPlayerForm(playerForm)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isTransformationFlying(playerForm) {
+    return TRANSFORMATIONS_THAT_GRANT_FLYING.has(playerForm);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/trinketCacheFlag.js

@@ -0,0 +1,46 @@
+import { CacheFlag } from "isaac-typescript-definitions";
+import { getEnumValues } from "./enums";
+import { copySet } from "./set";
+import { getTrinketTypes, trinketHasCacheFlag } from "./trinkets";
+const CACHE_FLAG_TO_TRINKETS_MAP = new Map();
+function initCacheFlagMap() {
+    for (const cacheFlag of getEnumValues(CacheFlag)) {
+        const trinketsSet = new Set();
+        for (const trinketType of getTrinketTypes()) {
+            if (trinketHasCacheFlag(trinketType, cacheFlag)) {
+                trinketsSet.add(trinketType);
+            }
+        }
+        CACHE_FLAG_TO_TRINKETS_MAP.set(cacheFlag, trinketsSet);
+    }
+}
+/**
+ * Returns a map containing every trinket type that the player has that matches the provided
+ * CacheFlag. The values of the map correspond to the multiplier for that trinket.
+ */
+export function getPlayerTrinketsForCacheFlag(player, cacheFlag) {
+    const trinketsForCacheFlag = getTrinketsForCacheFlag(cacheFlag);
+    const playerTrinkets = new Map();
+    for (const trinketType of trinketsForCacheFlag.values()) {
+        const trinketMultiplier = player.GetTrinketMultiplier(trinketType);
+        if (trinketMultiplier > 0) {
+            playerTrinkets.set(trinketType, trinketMultiplier);
+        }
+    }
+    return playerTrinkets;
+}
+/**
+ * Returns a set containing every trinket type with the given cache flag, including modded trinkets.
+ */
+export function getTrinketsForCacheFlag(cacheFlag) {
+    // Lazy initialize the map.
+    if (CACHE_FLAG_TO_TRINKETS_MAP.size === 0) {
+        initCacheFlagMap();
+    }
+    const trinketsSet = CACHE_FLAG_TO_TRINKETS_MAP.get(cacheFlag);
+    if (trinketsSet === undefined) {
+        return new Set();
+    }
+    return copySet(trinketsSet);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJpbmtldENhY2hlRmxhZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL3RyaW5rZXRDYWNoZUZsYWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBZSxNQUFNLDhCQUE4QixDQUFDO0FBQ3RFLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDeEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLE9BQU8sQ0FBQztBQUNoQyxPQUFPLEVBQUUsZUFBZSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRWxFLE1BQU0sMEJBQTBCLEdBQUcsSUFBSSxHQUFHLEVBQStCLENBQUM7QUFFMUUsU0FBUyxnQkFBZ0I7SUFDdkIsS0FBSyxNQUFNLFNBQVMsSUFBSSxhQUFhLENBQUMsU0FBUyxDQUFDLEVBQUU7UUFDaEQsTUFBTSxXQUFXLEdBQUcsSUFBSSxHQUFHLEVBQWUsQ0FBQztRQUUzQyxLQUFLLE1BQU0sV0FBVyxJQUFJLGVBQWUsRUFBRSxFQUFFO1lBQzNDLElBQUksbUJBQW1CLENBQUMsV0FBVyxFQUFFLFNBQVMsQ0FBQyxFQUFFO2dCQUMvQyxXQUFXLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxDQUFDO2FBQzlCO1NBQ0Y7UUFFRCwwQkFBMEIsQ0FBQyxHQUFHLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0tBQ3hEO0FBQ0gsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sVUFBVSw2QkFBNkIsQ0FDM0MsTUFBb0IsRUFDcEIsU0FBb0I7SUFFcEIsTUFBTSxvQkFBb0IsR0FBRyx1QkFBdUIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUVoRSxNQUFNLGNBQWMsR0FBRyxJQUFJLEdBQUcsRUFBb0IsQ0FBQztJQUNuRCxLQUFLLE1BQU0sV0FBVyxJQUFJLG9CQUFvQixDQUFDLE1BQU0sRUFBRSxFQUFFO1FBQ3ZELE1BQU0saUJBQWlCLEdBQUcsTUFBTSxDQUFDLG9CQUFvQixDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ25FLElBQUksaUJBQWlCLEdBQUcsQ0FBQyxFQUFFO1lBQ3pCLGNBQWMsQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLGlCQUFpQixDQUFDLENBQUM7U0FDcEQ7S0FDRjtJQUVELE9BQU8sY0FBYyxDQUFDO0FBQ3hCLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSx1QkFBdUIsQ0FDckMsU0FBb0I7SUFFcEIsMkJBQTJCO0lBQzNCLElBQUksMEJBQTBCLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBRTtRQUN6QyxnQkFBZ0IsRUFBRSxDQUFDO0tBQ3BCO0lBRUQsTUFBTSxXQUFXLEdBQUcsMEJBQTBCLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQzlELElBQUksV0FBVyxLQUFLLFNBQVMsRUFBRTtRQUM3QixPQUFPLElBQUksR0FBRyxFQUFFLENBQUM7S0FDbEI7SUFFRCxPQUFPLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztBQUM5QixDQUFDIn0=

package/functions/trinketGive.js

@@ -0,0 +1,121 @@
+import { CollectibleType, TrinketSlot, TrinketType, } from "isaac-typescript-definitions";
+import { useActiveItemTemp } from "./player";
+import { getGoldenTrinketType } from "./trinkets";
+import { repeat } from "./utils";
+/**
+ * Helper function to restore the player's trinkets back to the way they were before the
+ * `temporarilyRemoveTrinket` function was used. It will re-smelt any smelted trinkets that were
+ * removed.
+ */
+export function giveTrinketsBack(player, trinketSituation) {
+    // A trinket situation of undefined signifies that we did not have to remove the trinket. If this
+    // is the case, we do not have to give anything back.
+    if (trinketSituation === undefined) {
+        return;
+    }
+    const trinketType1 = player.GetTrinket(TrinketSlot.SLOT_1);
+    const trinketType2 = player.GetTrinket(TrinketSlot.SLOT_2);
+    // Remove any existing trinkets.
+    if (trinketType1 !== TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType1);
+    }
+    if (trinketType2 !== TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType2);
+    }
+    // First, add the smelted trinkets back.
+    repeat(trinketSituation.numSmeltedTrinkets, () => {
+        player.AddTrinket(trinketSituation.trinketTypeRemoved, false);
+        useActiveItemTemp(player, CollectibleType.SMELTER);
+    });
+    // Second, add back the stored trinkets.
+    if (trinketSituation.trinketType1 !== TrinketType.NULL) {
+        player.AddTrinket(trinketSituation.trinketType1, false);
+    }
+    if (trinketSituation.trinketType2 !== TrinketType.NULL) {
+        player.AddTrinket(trinketSituation.trinketType2, false);
+    }
+}
+/**
+ * Helper function to smelt a trinket. Before smelting, this function will automatically remove the
+ * trinkets that the player is holding, if any, and then give them back after the new trinket is
+ * smelted.
+ *
+ * @param player The player to smelt the trinkets to.
+ * @param trinketType The trinket type to smelt.
+ * @param numTrinkets Optional. If specified, will smelt the given number of trinkets. Use this to
+ *                    avoid calling this function multiple times. Default is 1.
+ */
+export function smeltTrinket(player, trinketType, numTrinkets = 1) {
+    const trinketSituation = temporarilyRemoveTrinkets(player);
+    repeat(numTrinkets, () => {
+        player.AddTrinket(trinketType);
+        useActiveItemTemp(player, CollectibleType.SMELTER);
+    });
+    giveTrinketsBack(player, trinketSituation);
+}
+/**
+ * Helper function to temporarily remove a specific kind of trinket from the player. Use this in
+ * combination with the `giveTrinketsBack` function to take away and give back a trinket on the same
+ * frame. This function correctly handles multiple trinket slots and ensures that all copies of the
+ * trinket are removed, including smelted trinkets.
+ *
+ * Note that one smelted golden trinket is the same as two smelted normal trinkets.
+ *
+ * @returns Undefined if the player does not have the trinket, or TrinketSituation if they do.
+ */
+export function temporarilyRemoveTrinket(player, trinketType) {
+    if (!player.HasTrinket(trinketType)) {
+        return undefined;
+    }
+    const trinketType1 = player.GetTrinket(TrinketSlot.SLOT_1);
+    const trinketType2 = player.GetTrinket(TrinketSlot.SLOT_2);
+    let numTrinkets = 0;
+    while (player.HasTrinket(trinketType)) {
+        player.TryRemoveTrinket(trinketType);
+        numTrinkets += 1;
+    }
+    let numSmeltedTrinkets = numTrinkets;
+    const trinketWasInSlot1 = trinketType1 === trinketType ||
+        trinketType1 === getGoldenTrinketType(trinketType);
+    if (trinketWasInSlot1) {
+        numSmeltedTrinkets -= 1;
+    }
+    const trinketWasInSlot2 = trinketType2 === trinketType ||
+        trinketType2 === getGoldenTrinketType(trinketType);
+    if (trinketWasInSlot2) {
+        numSmeltedTrinkets -= 1;
+    }
+    return {
+        trinketTypeRemoved: trinketType,
+        trinketType1,
+        trinketType2,
+        numSmeltedTrinkets,
+    };
+}
+/**
+ * Helper function to temporarily removes a player's held trinkets, if any. This will not remove any
+ * smelted trinkets. Use this in combination with the `giveTrinketsBack` function to take away and
+ * give back trinkets on the same frame.
+ *
+ * @returns Undefined if the player does not have any trinkets, or TrinketSituation if they do.
+ */
+export function temporarilyRemoveTrinkets(player) {
+    const trinketType1 = player.GetTrinket(TrinketSlot.SLOT_1);
+    const trinketType2 = player.GetTrinket(TrinketSlot.SLOT_2);
+    if (trinketType1 === TrinketType.NULL && trinketType2 === TrinketType.NULL) {
+        return undefined;
+    }
+    if (trinketType1 !== TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType1);
+    }
+    if (trinketType2 !== TrinketType.NULL) {
+        player.TryRemoveTrinket(trinketType2);
+    }
+    return {
+        trinketTypeRemoved: TrinketType.NULL,
+        trinketType1,
+        trinketType2,
+        numSmeltedTrinkets: 0,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJpbmtldEdpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2Z1bmN0aW9ucy90cmlua2V0R2l2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUNmLFdBQVcsRUFDWCxXQUFXLEdBQ1osTUFBTSw4QkFBOEIsQ0FBQztBQUV0QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDN0MsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQ2xELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFakM7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FDOUIsTUFBb0IsRUFDcEIsZ0JBQThDO0lBRTlDLGlHQUFpRztJQUNqRyxxREFBcUQ7SUFDckQsSUFBSSxnQkFBZ0IsS0FBSyxTQUFTLEVBQUU7UUFDbEMsT0FBTztLQUNSO0lBRUQsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDM0QsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFM0QsZ0NBQWdDO0lBQ2hDLElBQUksWUFBWSxLQUFLLFdBQVcsQ0FBQyxJQUFJLEVBQUU7UUFDckMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLFlBQVksQ0FBQyxDQUFDO0tBQ3ZDO0lBQ0QsSUFBSSxZQUFZLEtBQUssV0FBVyxDQUFDLElBQUksRUFBRTtRQUNyQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsWUFBWSxDQUFDLENBQUM7S0FDdkM7SUFFRCx3Q0FBd0M7SUFDeEMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLGtCQUFrQixFQUFFLEdBQUcsRUFBRTtRQUMvQyxNQUFNLENBQUMsVUFBVSxDQUFDLGdCQUFnQixDQUFDLGtCQUFrQixFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQzlELGlCQUFpQixDQUFDLE1BQU0sRUFBRSxlQUFlLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckQsQ0FBQyxDQUFDLENBQUM7SUFFSCx3Q0FBd0M7SUFDeEMsSUFBSSxnQkFBZ0IsQ0FBQyxZQUFZLEtBQUssV0FBVyxDQUFDLElBQUksRUFBRTtRQUN0RCxNQUFNLENBQUMsVUFBVSxDQUFDLGdCQUFnQixDQUFDLFlBQVksRUFBRSxLQUFLLENBQUMsQ0FBQztLQUN6RDtJQUNELElBQUksZ0JBQWdCLENBQUMsWUFBWSxLQUFLLFdBQVcsQ0FBQyxJQUFJLEVBQUU7UUFDdEQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZLEVBQUUsS0FBSyxDQUFDLENBQUM7S0FDekQ7QUFDSCxDQUFDO0FBRUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FDMUIsTUFBb0IsRUFDcEIsV0FBd0IsRUFDeEIsV0FBVyxHQUFHLENBQUM7SUFFZixNQUFNLGdCQUFnQixHQUFHLHlCQUF5QixDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRTNELE1BQU0sQ0FBQyxXQUFXLEVBQUUsR0FBRyxFQUFFO1FBQ3ZCLE1BQU0sQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDL0IsaUJBQWlCLENBQUMsTUFBTSxFQUFFLGVBQWUsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNyRCxDQUFDLENBQUMsQ0FBQztJQUVILGdCQUFnQixDQUFDLE1BQU0sRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO0FBQzdDLENBQUM7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLFVBQVUsd0JBQXdCLENBQ3RDLE1BQW9CLEVBQ3BCLFdBQXdCO0lBRXhCLElBQUksQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxFQUFFO1FBQ25DLE9BQU8sU0FBUyxDQUFDO0tBQ2xCO0lBRUQsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDM0QsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFM0QsSUFBSSxXQUFXLEdBQUcsQ0FBQyxDQUFDO0lBQ3BCLE9BQU8sTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsRUFBRTtRQUNyQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDckMsV0FBVyxJQUFJLENBQUMsQ0FBQztLQUNsQjtJQUVELElBQUksa0JBQWtCLEdBQUcsV0FBVyxDQUFDO0lBQ3JDLE1BQU0saUJBQWlCLEdBQ3JCLFlBQVksS0FBSyxXQUFXO1FBQzVCLFlBQVksS0FBSyxvQkFBb0IsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNyRCxJQUFJLGlCQUFpQixFQUFFO1FBQ3JCLGtCQUFrQixJQUFJLENBQUMsQ0FBQztLQUN6QjtJQUNELE1BQU0saUJBQWlCLEdBQ3JCLFlBQVksS0FBSyxXQUFXO1FBQzVCLFlBQVksS0FBSyxvQkFBb0IsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNyRCxJQUFJLGlCQUFpQixFQUFFO1FBQ3JCLGtCQUFrQixJQUFJLENBQUMsQ0FBQztLQUN6QjtJQUVELE9BQU87UUFDTCxrQkFBa0IsRUFBRSxXQUFXO1FBQy9CLFlBQVk7UUFDWixZQUFZO1FBQ1osa0JBQWtCO0tBQ25CLENBQUM7QUFDSixDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLHlCQUF5QixDQUN2QyxNQUFvQjtJQUVwQixNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMzRCxNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUUzRCxJQUFJLFlBQVksS0FBSyxXQUFXLENBQUMsSUFBSSxJQUFJLFlBQVksS0FBSyxXQUFXLENBQUMsSUFBSSxFQUFFO1FBQzFFLE9BQU8sU0FBUyxDQUFDO0tBQ2xCO0lBRUQsSUFBSSxZQUFZLEtBQUssV0FBVyxDQUFDLElBQUksRUFBRTtRQUNyQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsWUFBWSxDQUFDLENBQUM7S0FDdkM7SUFFRCxJQUFJLFlBQVksS0FBSyxXQUFXLENBQUMsSUFBSSxFQUFFO1FBQ3JDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZLENBQUMsQ0FBQztLQUN2QztJQUVELE9BQU87UUFDTCxrQkFBa0IsRUFBRSxXQUFXLENBQUMsSUFBSTtRQUNwQyxZQUFZO1FBQ1osWUFBWTtRQUNaLGtCQUFrQixFQUFFLENBQUM7S0FDdEIsQ0FBQztBQUNKLENBQUMifQ==