isaacscript-common 84.0.0 → 84.1.0

package/dist/functions/storyBosses.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStoryBossID = exports.isStoryBoss = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const ReadonlySet_1 = require("../types/ReadonlySet");
+const STORY_BOSS_IDS = [
+    isaac_typescript_definitions_1.BossID.MOM,
+    isaac_typescript_definitions_1.BossID.MOMS_HEART,
+    isaac_typescript_definitions_1.BossID.SATAN,
+    isaac_typescript_definitions_1.BossID.IT_LIVES,
+    isaac_typescript_definitions_1.BossID.ISAAC,
+    isaac_typescript_definitions_1.BossID.BLUE_BABY,
+    isaac_typescript_definitions_1.BossID.LAMB,
+    isaac_typescript_definitions_1.BossID.MEGA_SATAN,
+    isaac_typescript_definitions_1.BossID.ULTRA_GREED,
+    isaac_typescript_definitions_1.BossID.HUSH,
+    isaac_typescript_definitions_1.BossID.DELIRIUM,
+    isaac_typescript_definitions_1.BossID.ULTRA_GREEDIER,
+    isaac_typescript_definitions_1.BossID.MOTHER,
+    isaac_typescript_definitions_1.BossID.MAUSOLEUM_MOM,
+    isaac_typescript_definitions_1.BossID.MAUSOLEUM_MOMS_HEART,
+    isaac_typescript_definitions_1.BossID.DOGMA,
+    isaac_typescript_definitions_1.BossID.BEAST, // 100
+];
+const STORY_BOSS_ENTITY_TYPES_SET = new ReadonlySet_1.ReadonlySet([
+    isaac_typescript_definitions_1.EntityType.MOM,
+    isaac_typescript_definitions_1.EntityType.MOMS_HEART,
+    isaac_typescript_definitions_1.EntityType.SATAN,
+    // - It Lives is a variant of Mom's Heart.
+    isaac_typescript_definitions_1.EntityType.ISAAC,
+    // - Blue Baby is a variant of Isaac.
+    isaac_typescript_definitions_1.EntityType.LAMB,
+    isaac_typescript_definitions_1.EntityType.MEGA_SATAN,
+    isaac_typescript_definitions_1.EntityType.MEGA_SATAN_2,
+    isaac_typescript_definitions_1.EntityType.ULTRA_GREED,
+    isaac_typescript_definitions_1.EntityType.HUSH,
+    isaac_typescript_definitions_1.EntityType.DELIRIUM,
+    // - Ultra Greedier is a variant of Ultra Greed.
+    isaac_typescript_definitions_1.EntityType.MOTHER,
+    // - Mausoleum Mom is a sub-type of Mom.
+    // - Mausoleum Mom's Heart is a sub-type of Mom's Heart.
+    isaac_typescript_definitions_1.EntityType.DOGMA,
+    isaac_typescript_definitions_1.EntityType.BEAST, // 951
+]);
+const STORY_BOSS_IDS_SET = new ReadonlySet_1.ReadonlySet(STORY_BOSS_IDS);
+/**
+ * Helper function to determine if the specified entity type is an end-game story boss, like Isaac,
+ * Blue Baby, Mega Satan, The Beast, and so on. This is useful because certain effects should only
+ * apply to non-story bosses, like Vanishing Twin.
+ */
+function isStoryBoss(entityType) {
+    return STORY_BOSS_ENTITY_TYPES_SET.has(entityType);
+}
+exports.isStoryBoss = isStoryBoss;
+/**
+ * Helper function to determine if the specified boss ID is an end-game story boss, like Isaac, Blue
+ * Baby, Mega Satan, The Beast, and so on. This is useful because certain effects should only apply
+ * to non-story bosses, like Vanishing Twin.
+ */
+function isStoryBossID(bossID) {
+    return STORY_BOSS_IDS_SET.has(bossID);
+}
+exports.isStoryBossID = isStoryBossID;

package/dist/functions/string.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uncapitalizeFirstLetter = exports.trimSuffix = exports.trimPrefix = exports.removeSubstring = exports.removeNonAlphanumericCharacters = exports.removeCharactersBefore = exports.removeAllCharacters = exports.parseSemanticVersion = exports.getPartialMatch = exports.getObjectPartialMatch = exports.getMapPartialMatch = exports.capitalizeFirstLetter = void 0;
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+function capitalizeFirstLetter(string) {
+    if (string === "") {
+        return string;
+    }
+    const firstCharacter = string.charAt(0);
+    const capitalizedFirstLetter = firstCharacter.toUpperCase();
+    const restOfString = string.slice(1);
+    return `${capitalizedFirstLetter}${restOfString}`;
+}
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+/**
+ * Helper function to get the closest key from a map based on partial search text. (It only searches
+ * through the keys, not the values.)
+ *
+ * Note that:
+ * - Spaces are automatically removed from the search text.
+ * - Both the search text and the strings to search through are converted to lowercase before
+ *   attempting to find a match.
+ *
+ * For example:
+ *
+ * ```ts
+ * const map = new <string, number>Map([
+ *   ["foo", 123],
+ *   ["bar", 456],
+ * ]);
+ * const searchText = "f";
+ * const match = getMapPartialMatch(map, searchText); // match is now equal to ["foo", 123]
+ * ```
+ *
+ * @returns If a match was found, returns a tuple of the map key and value. If a match was not
+ *          found, returns undefined.
+ */
+function getMapPartialMatch(searchText, map) {
+    const keys = [...map.keys()];
+    const matchingKey = getPartialMatch(searchText, keys);
+    if (matchingKey === undefined) {
+        return undefined;
+    }
+    const value = map.get(matchingKey);
+    (0, utils_1.assertDefined)(value, `Failed to get the map value corresponding to the partial match of: ${matchingKey}`);
+    return [matchingKey, value];
+}
+exports.getMapPartialMatch = getMapPartialMatch;
+/**
+ * Helper function to get the closest key from an object based on partial search text. (It only
+ * searches through the keys, not the values.)
+ *
+ * Note that:
+ * - Spaces are automatically removed from the search text.
+ * - Both the search text and the strings to search through are converted to lowercase before
+ *   attempting to find a match.
+ *
+ * For example:
+ *
+ * ```ts
+ * const object = {
+ *   foo: 123,
+ *   bar: 456,
+ * };
+ * const searchText = "f";
+ * const match = getObjectPartialMatch(object, searchText); // match is now equal to ["foo", 123]
+ * ```
+ *
+ * @returns If a match was found, returns a tuple of the map key and value. If a match was not
+ *          found, returns undefined.
+ */
+function getObjectPartialMatch(searchText, object) {
+    const keys = Object.keys(object);
+    const matchingKey = getPartialMatch(searchText, keys);
+    if (matchingKey === undefined) {
+        return undefined;
+    }
+    const value = object[matchingKey];
+    (0, utils_1.assertDefined)(value, `Failed to get the object value corresponding to the partial match of: ${matchingKey}`);
+    return [matchingKey, value];
+}
+exports.getObjectPartialMatch = getObjectPartialMatch;
+/**
+ * Helper function to get the closest value from an array of strings based on partial search text.
+ *
+ * Note that:
+ * - Spaces are automatically removed from the search text.
+ * - Both the search text and the strings to search through are converted to lowercase before
+ *   attempting to find a match.
+ *
+ * For example:
+ *
+ * ```ts
+ * const array = ["foo", "bar"];
+ * const searchText = "f";
+ * const match = getPartialMatch(array, searchText); // match is now equal to "foo"
+ *
+ * @returns If a match was found, returns the array element. If a match was not
+ * found, returns undefined.
+ * ```
+ */
+function getPartialMatch(searchText, array) {
+    const sortedArray = array.toSorted();
+    searchText = searchText.toLowerCase();
+    searchText = searchText.replaceAll(" ", "");
+    const matchingElements = sortedArray.filter((element) => element.toLowerCase().startsWith(searchText));
+    matchingElements.sort();
+    return matchingElements[0];
+}
+exports.getPartialMatch = getPartialMatch;
+/**
+ * Helper function to parse a Semantic Versioning string into its individual constituents. Returns
+ * undefined if the submitted string was not a proper Semantic Version string.
+ *
+ * https://semver.org/
+ */
+function parseSemanticVersion(versionString) {
+    const [majorVersionString, minorVersionString, patchVersionString] = string.match(versionString, "(%d+).(%d+).(%d+)");
+    if (majorVersionString === undefined ||
+        minorVersionString === undefined ||
+        patchVersionString === undefined) {
+        return undefined;
+    }
+    const majorVersion = (0, types_1.parseIntSafe)(majorVersionString);
+    const minorVersion = (0, types_1.parseIntSafe)(minorVersionString);
+    const patchVersion = (0, types_1.parseIntSafe)(patchVersionString);
+    if (majorVersion === undefined ||
+        minorVersion === undefined ||
+        patchVersion === undefined) {
+        return undefined;
+    }
+    return { majorVersion, minorVersion, patchVersion };
+}
+exports.parseSemanticVersion = parseSemanticVersion;
+function removeAllCharacters(string, character) {
+    return string.replaceAll(character, "");
+}
+exports.removeAllCharacters = removeAllCharacters;
+/**
+ * Helper function to remove all of the characters in a string before a given substring. Returns the
+ * modified string.
+ */
+function removeCharactersBefore(string, substring) {
+    const index = string.indexOf(substring);
+    return string.slice(index);
+}
+exports.removeCharactersBefore = removeCharactersBefore;
+/** Helper function to remove all characters from a string that are not letters or numbers. */
+function removeNonAlphanumericCharacters(str) {
+    const [returnValue, _] = string.gsub(str, "%W", "");
+    return returnValue;
+}
+exports.removeNonAlphanumericCharacters = removeNonAlphanumericCharacters;
+/**
+ * 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.
+ */
+function removeSubstring(string, ...substrings) {
+    for (const substring of substrings) {
+        string = string.replaceAll(substring, "");
+    }
+    return string;
+}
+exports.removeSubstring = removeSubstring;
+/** Helper function to trim a prefix from a string, if it exists. Returns the trimmed string. */
+function trimPrefix(string, prefix) {
+    if (!string.startsWith(prefix)) {
+        return string;
+    }
+    return string.slice(prefix.length);
+}
+exports.trimPrefix = trimPrefix;
+/** Helper function to trim a suffix from a string, if it exists. Returns the trimmed string. */
+function trimSuffix(string, prefix) {
+    if (!string.endsWith(prefix)) {
+        return string;
+    }
+    const endCharacter = string.length - prefix.length;
+    return string.slice(0, endCharacter);
+}
+exports.trimSuffix = trimSuffix;
+function uncapitalizeFirstLetter(string) {
+    if (string === "") {
+        return string;
+    }
+    const firstCharacter = string.charAt(0);
+    const uncapitalizedFirstLetter = firstCharacter.toLowerCase();
+    const restOfString = string.slice(1);
+    return `${uncapitalizedFirstLetter}${restOfString}`;
+}
+exports.uncapitalizeFirstLetter = uncapitalizeFirstLetter;

package/dist/functions/table.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableHasKeys = exports.iterateTableInOrder = exports.isTableEmpty = exports.getStringsFromTable = exports.getNumbersFromTable = exports.getBooleansFromTable = exports.copyUserdataValuesToTable = exports.clearTable = void 0;
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * In a `Map`, you can use the `clear` method to delete every element. However, in a `LuaMap`, the
+ * `clear` method does not exist. Use this helper function as a drop-in replacement for this.
+ */
+function clearTable(luaMap) {
+    for (const [key] of luaMap) {
+        luaMap.delete(key);
+    }
+}
+exports.clearTable = clearTable;
+/** Helper function to copy specific values from a userdata object (e.g. `Vector`) to a table. */
+function copyUserdataValuesToTable(object, keys, luaMap) {
+    if (!(0, types_1.isUserdata)(object)) {
+        error(`Failed to copy an object values to a table, since the object was of type: ${type(object)}`);
+    }
+    // We can access values on userdata objects similar to a normal table.
+    const userdata = object;
+    for (const key of keys) {
+        const value = userdata.get(key);
+        luaMap.set(key, value);
+    }
+}
+exports.copyUserdataValuesToTable = copyUserdataValuesToTable;
+/**
+ * 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.
+ */
+function getBooleansFromTable(luaMap, objectName, ...keys) {
+    const booleans = [];
+    for (const key of keys) {
+        const value = luaMap.get(key);
+        (0, utils_1.assertDefined)(value, `Failed to find a value for "${key}" in a table representing a "${objectName}" object.`);
+        if ((0, types_1.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;
+}
+exports.getBooleansFromTable = getBooleansFromTable;
+/**
+ * Helper function to safely get number values from specific keys on a Lua table. If the values are
+ * strings, they will be converted to numbers. 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.
+ */
+function getNumbersFromTable(luaMap, objectName, ...keys) {
+    const numbers = [];
+    for (const key of keys) {
+        const value = luaMap.get(key);
+        (0, utils_1.assertDefined)(value, `Failed to find a value for "${key}" in a table representing a "${objectName}" object.`);
+        if ((0, types_1.isNumber)(value)) {
+            numbers.push(value);
+        }
+        else if ((0, types_1.isString)(value)) {
+            const number = tonumber(value);
+            (0, utils_1.assertDefined)(number, `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;
+}
+exports.getNumbersFromTable = getNumbersFromTable;
+/**
+ * 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.
+ */
+function getStringsFromTable(luaMap, objectName, ...keys) {
+    const strings = [];
+    for (const key of keys) {
+        const value = luaMap.get(key);
+        (0, utils_1.assertDefined)(value, `Failed to find a value for "${key}" in a table representing a "${objectName}" object.`);
+        if ((0, types_1.isString)(value)) {
+            strings.push(value);
+        }
+        else {
+            const string = tostring(value);
+            strings.push(string);
+        }
+    }
+    return strings;
+}
+exports.getStringsFromTable = getStringsFromTable;
+/** Helper function to check if a Lua table has 0 keys. */
+function isTableEmpty(luaMap) {
+    // Using `next` does not seem to work properly, so we use `pairs` instead.
+    // eslint-disable-next-line no-unreachable-loop
+    for (const [_key, _value] of luaMap) {
+        return false;
+    }
+    return true;
+}
+exports.isTableEmpty = isTableEmpty;
+/**
+ * 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
+ * run-time error if it encounters a key of another type.
+ *
+ * @param luaMap 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.
+ */
+function iterateTableInOrder(luaMap, func, inOrder = true) {
+    // First, handle the trivial case of a non-deterministic iteration.
+    if (!inOrder) {
+        for (const [key, value] of luaMap) {
+            func(key, value);
+        }
+        return;
+    }
+    const keys = Object.keys(luaMap);
+    const hasAllNumberKeys = keys.every((key) => (0, types_1.isNumber)(key));
+    const hasAllStringKeys = keys.every((key) => (0, types_1.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 luaMap) {
+            func(key, value);
+        }
+        return;
+    }
+    keys.sort();
+    for (const key of keys) {
+        const keyIndex = key;
+        const value = luaMap.get(keyIndex);
+        if (value !== undefined) {
+            func(keyIndex, value);
+        }
+    }
+}
+exports.iterateTableInOrder = iterateTableInOrder;
+/**
+ * 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.
+ */
+function tableHasKeys(luaMap, ...keys) {
+    return keys.every((key) => luaMap.has(key));
+}
+exports.tableHasKeys = tableHasKeys;

package/dist/functions/tears.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTearFromPlayer = exports.isTearFromFamiliar = exports.isMissedTear = exports.getTearsStat = exports.getFireDelay = exports.addTearsStat = void 0;
+/**
+ * - Converts the specified amount of tears stat into the format of `EntityPlayer.MaxFireDelay` and
+ *   adds it to the player.
+ * - This function should only be used inside the `EVALUATE_CACHE` callback.
+ * - In this context, the "tears stat" represents what is shown on the in-game stat UI.
+ *
+ * For example:
+ *
+ * ```ts
+ * function evaluateCacheTears(player: EntityPlayer) {
+ *   const numFoo = player.GetNumCollectible(CollectibleTypeCustom.FOO);
+ *   const tearsStat = numFoo * FOO_TEARS_STAT;
+ *   addTearsStat(player, tearsStat);
+ * }
+ * ```
+ */
+function addTearsStat(player, tearsStat) {
+    const existingTearsStat = getTearsStat(player.MaxFireDelay);
+    const newTearsStat = existingTearsStat + tearsStat;
+    const newMaxFireDelay = getFireDelay(newTearsStat);
+    player.MaxFireDelay = newMaxFireDelay;
+}
+exports.addTearsStat = addTearsStat;
+/**
+ * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` field. 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.
+ */
+function getFireDelay(tearsStat) {
+    return Math.max(30 / tearsStat - 1, -0.9999);
+}
+exports.getFireDelay = getFireDelay;
+/**
+ * - The `EntityPlayer` object stores a player's tear rate in the `MaxFireDelay` field. 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.
+ */
+function getTearsStat(fireDelay) {
+    return 30 / (fireDelay + 1);
+}
+exports.getTearsStat = getTearsStat;
+/**
+ * Helper function to check if a tear hit an enemy. A tear is considered to be missed if it hit the
+ * ground, a wall, or a grid entity.
+ *
+ * Note that tears are still considered to be missed if they hit a poop or fire, so you may want to
+ * handle those separately using the `POST_GRID_ENTITY_COLLISION` and `POST_ENTITY_COLLISION`
+ * callbacks, respectively.
+ *
+ * Under the hood, this function uses the `Entity.IsDead` method. (Tears will not die if they hit an
+ * enemy, but they will die if they hit a wall or object.)
+ */
+function isMissedTear(tear) {
+    return tear.IsDead();
+}
+exports.isMissedTear = isMissedTear;
+/**
+ * Helper function to check if a given tear is from a familiar (as opposed to e.g. a player). This
+ * is determined by looking at the parent.
+ *
+ * For the special case of Incubus and Blood Babies, the parent of the tear is always the player,
+ * but the spawner entity of the tear changes. On frame 0, the spawner entity is equal to the
+ * player, and on frame 1, the spawner entity is equal to the familiar. For this reason, you can
+ * only use this function in the `POST_TEAR_INIT_VERY_LATE` callback or on frame 1+.
+ *
+ * If this function is called on frame 0, it will throw a run-time error.
+ *
+ * Note that this function does not work properly when the tear is from a Lead Pencil barrage. In
+ * this case, it will always appear as if the tear is coming from a player.
+ *
+ * @param tear The tear to inspect.
+ * @param familiarVariant Optional. Specify this to check if the tear came from a specific familiar
+ *                        variant. Default is undefined, which checks for any familiar.
+ * @param subType Optional. Specify this to check if the tear came from a specific familiar
+ *                sub-type. Default is undefined, which checks for any familiar.
+ */
+function isTearFromFamiliar(tear, familiarVariant, subType) {
+    if (tear.FrameCount === 0) {
+        error('Failed to check if the given tear was from a player since the tear\'s frame count was equal to 0. (The "isTearFromFamiliar" function must only be used in the "POST_TEAR_INIT_VERY_LATE" callback or on frame 1 and onwards.)');
+    }
+    // Normally, all tears have a spawner entity, which is either the player or the familiar.
+    if (tear.SpawnerEntity === undefined) {
+        return false;
+    }
+    // We cannot use `tear.SpawnerType` to determine this, since it is baked in to be equal to
+    // `EntityType.PLAYER` regardless of whether the tear is from a player or familiar.
+    const familiar = tear.SpawnerEntity.ToFamiliar();
+    if (familiar === undefined) {
+        return false;
+    }
+    return ((familiarVariant === undefined || familiarVariant === familiar.Variant) &&
+        (subType === undefined || subType === familiar.SubType));
+}
+exports.isTearFromFamiliar = isTearFromFamiliar;
+/**
+ * Helper function to check if a given tear is from a player (as opposed to e.g. a familiar). This
+ * is determined by looking at the `SpawnerEntity`.
+ *
+ * For the special case of Incubus and Blood Babies, the `SpawnerEntity` of the tear is always the
+ * player, but the spawner entity of the tear changes. On frame 0, the spawner entity is equal to
+ * the player, and on frame 1, the spawner entity is equal to the familiar. For this reason, you can
+ * only use this function in the `POST_TEAR_INIT_VERY_LATE` callback or on frame 1+.
+ *
+ * If this function is called on frame 0, it will throw a run-time error.
+ *
+ * Note that this function does not work properly when the tear is from a Lead Pencil barrage. In
+ * this case, it will always appear as if the tear is coming from a player.
+ */
+function isTearFromPlayer(tear) {
+    if (tear.FrameCount === 0) {
+        error('Failed to check if the given tear was from a player since the tear\'s frame count was equal to 0. (The "isTearFromPlayer" function must only be used in the "POST_TEAR_INIT_VERY_LATE" callback or on frame 1 and onwards.)');
+    }
+    // Normally, all tears have a spawner entity, which is either the player or the familiar.
+    if (tear.SpawnerEntity === undefined) {
+        return false;
+    }
+    // We cannot use `tear.SpawnerType` to determine this, since it is baked in to be equal to
+    // `EntityType.PLAYER` regardless of whether the tear is from a player or familiar.
+    const player = tear.SpawnerEntity.ToPlayer();
+    return player !== undefined;
+}
+exports.isTearFromPlayer = isTearFromPlayer;

package/dist/functions/transformations.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransformationFlying = exports.hasFlyingTransformation = exports.getTransformationsForCollectibleType = exports.getTransformationName = exports.getPlayerTransformations = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedEnumValues_1 = require("../arrays/cachedEnumValues");
+const transformationNames_1 = require("../objects/transformationNames");
+const ReadonlyMap_1 = require("../types/ReadonlyMap");
+const ReadonlySet_1 = require("../types/ReadonlySet");
+const collectibles_1 = require("./collectibles");
+const flag_1 = require("./flag");
+const TRANSFORMATION_TO_TAG_MAP = new ReadonlyMap_1.ReadonlyMap([
+    [isaac_typescript_definitions_1.PlayerForm.GUPPY, isaac_typescript_definitions_1.ItemConfigTag.GUPPY],
+    [isaac_typescript_definitions_1.PlayerForm.BEELZEBUB, isaac_typescript_definitions_1.ItemConfigTag.FLY],
+    [isaac_typescript_definitions_1.PlayerForm.FUN_GUY, isaac_typescript_definitions_1.ItemConfigTag.MUSHROOM],
+    [isaac_typescript_definitions_1.PlayerForm.SERAPHIM, isaac_typescript_definitions_1.ItemConfigTag.ANGEL],
+    [isaac_typescript_definitions_1.PlayerForm.BOB, isaac_typescript_definitions_1.ItemConfigTag.BOB],
+    [isaac_typescript_definitions_1.PlayerForm.SPUN, isaac_typescript_definitions_1.ItemConfigTag.SYRINGE],
+    [isaac_typescript_definitions_1.PlayerForm.YES_MOTHER, isaac_typescript_definitions_1.ItemConfigTag.MOM],
+    [isaac_typescript_definitions_1.PlayerForm.CONJOINED, isaac_typescript_definitions_1.ItemConfigTag.BABY],
+    [isaac_typescript_definitions_1.PlayerForm.LEVIATHAN, isaac_typescript_definitions_1.ItemConfigTag.DEVIL],
+    [isaac_typescript_definitions_1.PlayerForm.OH_CRAP, isaac_typescript_definitions_1.ItemConfigTag.POOP],
+    [isaac_typescript_definitions_1.PlayerForm.BOOKWORM, isaac_typescript_definitions_1.ItemConfigTag.BOOK],
+    // PlayerForm.ADULTHOOD (11) is based on pill usage.
+    [isaac_typescript_definitions_1.PlayerForm.SPIDER_BABY, isaac_typescript_definitions_1.ItemConfigTag.SPIDER], // 12
+    // PlayerForm.STOMPY (13) is based on size.
+]);
+const TRANSFORMATIONS_THAT_GRANT_FLYING = new ReadonlySet_1.ReadonlySet([
+    isaac_typescript_definitions_1.PlayerForm.GUPPY,
+    isaac_typescript_definitions_1.PlayerForm.BEELZEBUB,
+    isaac_typescript_definitions_1.PlayerForm.SERAPHIM,
+    isaac_typescript_definitions_1.PlayerForm.LEVIATHAN, // 8
+]);
+/** Returns a set of the player's current transformations. */
+function getPlayerTransformations(player) {
+    const transformations = new Set();
+    for (const playerForm of cachedEnumValues_1.PLAYER_FORM_VALUES) {
+        if (player.HasPlayerForm(playerForm)) {
+            transformations.add(playerForm);
+        }
+    }
+    return transformations;
+}
+exports.getPlayerTransformations = getPlayerTransformations;
+/**
+ * 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"
+ * ```
+ */
+function getTransformationName(playerForm) {
+    return transformationNames_1.TRANSFORMATION_NAMES[playerForm];
+}
+exports.getTransformationName = getTransformationName;
+/**
+ * Returns a set containing all of the transformations that the given collectible types contribute
+ * towards.
+ */
+function getTransformationsForCollectibleType(collectibleType) {
+    const itemConfigTags = (0, collectibles_1.getCollectibleTags)(collectibleType);
+    const transformationSet = new Set();
+    for (const playerForm of cachedEnumValues_1.PLAYER_FORM_VALUES) {
+        const itemConfigTag = TRANSFORMATION_TO_TAG_MAP.get(playerForm);
+        if (itemConfigTag === undefined) {
+            continue;
+        }
+        if ((0, flag_1.hasFlag)(itemConfigTags, itemConfigTag)) {
+            transformationSet.add(playerForm);
+        }
+    }
+    return transformationSet;
+}
+exports.getTransformationsForCollectibleType = getTransformationsForCollectibleType;
+function hasFlyingTransformation(player) {
+    for (const playerForm of TRANSFORMATIONS_THAT_GRANT_FLYING) {
+        if (player.HasPlayerForm(playerForm)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasFlyingTransformation = hasFlyingTransformation;
+function isTransformationFlying(playerForm) {
+    return TRANSFORMATIONS_THAT_GRANT_FLYING.has(playerForm);
+}
+exports.isTransformationFlying = isTransformationFlying;