isaacscript-common 6.6.0 → 6.6.1-dev.2

package/functions/enums.js

@@ -0,0 +1,151 @@
+import { getRandomArrayElement } from "./array";
+import { getRandomSeed } from "./rng";
+import { isString } from "./types";
+import { irange } from "./utils";
+/**
+ * TypeScriptToLua will transpile TypeScript enums to Lua tables that have a double mapping. Thus,
+ * when you iterate over them, you will get both the names of the enums and the values of the enums,
+ * in a random order. Use this helper function to get the entries of the enum with the reverse
+ * mappings filtered out.
+ *
+ * This function will return the enum values in a sorted order, which may not necessarily be the
+ * same order as which they were declared in.
+ *
+ * This function will work properly for both number enums and string enums. (Reverse mappings are
+ * not created for string enums.)
+ *
+ * Also see the `getEnumKeys` and `getEnumValues` helper functions.
+ *
+ * For a more in depth explanation, see:
+ * https://isaacscript.github.io/gotchas#iterating-over-enums
+ */
+export function getEnumEntries(transpiledEnum) {
+    // The values cannot simply be type `T` due to the special construction of bit flag enums.
+    const enumEntries = [];
+    for (const [key, value] of pairs(transpiledEnum)) {
+        // Ignore the reverse mappings created by TypeScriptToLua. Note that reverse mappings are not
+        // created for string enums.
+        if (isString(key)) {
+            enumEntries.push([key, value]);
+        }
+    }
+    // The enums will be in a random order (because of "pairs"), so sort them based on the values.
+    // https://stackoverflow.com/questions/5199901/how-to-sort-an-associative-array-by-its-values-in-javascript
+    enumEntries.sort(([_key1, value1], [_key2, value2]) => value1 < value2 ? -1 : value1 > value2 ? 1 : 0);
+    return enumEntries;
+}
+/**
+ * TypeScriptToLua will transpile TypeScript enums to Lua tables that have a double mapping. Thus,
+ * when you iterate over them, you will get both the names of the enums and the values of the enums,
+ * in a random order. If all you need are the keys of an enum, use this helper function.
+ *
+ * This function will return the enum keys in a sorted order, which may not necessarily be the same
+ * order as which they were declared in.
+ *
+ * This function will work properly for both number enums and string enums. (Reverse mappings are
+ * not created for string enums.)
+ *
+ * Also see the `getEnumEntries` and `getEnumValues` helper functions.
+ *
+ * For a more in depth explanation, see:
+ * https://isaacscript.github.io/gotchas#iterating-over-enums
+ */
+export function getEnumKeys(transpiledEnum) {
+    const enumEntries = getEnumEntries(transpiledEnum);
+    return enumEntries.map(([key, _value]) => key);
+}
+/** Helper function to get the amount of entries inside of an enum. */
+export function getEnumLength(transpiledEnum) {
+    const enumEntries = getEnumEntries(transpiledEnum);
+    return enumEntries.length;
+}
+/**
+ * TypeScriptToLua will transpile TypeScript enums to Lua tables that have a double mapping. Thus,
+ * when you iterate over them, you will get both the names of the enums and the values of the enums,
+ * in a random order. If all you need are the values of an enum, use this helper function.
+ *
+ * This function will return the enum values in a sorted order, which may not necessarily be the
+ * same order as which they were declared in.
+ *
+ * This function will work properly for both number enums and string enums. (Reverse mappings are
+ * not created for string enums.)
+ *
+ * Also see the `getEnumEntries` and `getEnumKeys` helper functions.
+ *
+ * For a more in depth explanation, see:
+ * https://isaacscript.github.io/gotchas#iterating-over-enums
+ */
+export function getEnumValues(transpiledEnum) {
+    const enumEntries = getEnumEntries(transpiledEnum);
+    return enumEntries.map(([_key, value]) => value);
+}
+/**
+ * Helper function to get the enum value with the highest value.
+ *
+ * Note that this is not necessarily the enum value that is declared last, since there is no way to
+ * infer that at run-time.
+ */
+export function getLastEnumValue(transpiledEnum) {
+    const enumValues = getEnumValues(transpiledEnum);
+    const lastElement = enumValues[enumValues.length - 1];
+    if (lastElement === undefined) {
+        error("Failed to get the last value from an enum since the enum was empty.");
+    }
+    return lastElement;
+}
+/**
+ * Helper function to get a random value from the provided enum.
+ *
+ * @param transpiledEnum The enum to get the value from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export function getRandomEnumValue(transpiledEnum, seedOrRNG = getRandomSeed(), exceptions = []) {
+    const enumValues = getEnumValues(transpiledEnum);
+    return getRandomArrayElement(enumValues, seedOrRNG, exceptions);
+}
+/**
+ * Helper function to check every value of a custom enum for -1. Will throw an run-time error if any
+ * -1 values are found. This is helpful because many methods of the Isaac class return -1 if they
+ * fail.
+ *
+ * For example:
+ *
+ * ```ts
+ * enum EntityTypeCustom {
+ *   FOO = Isaac.GetEntityTypeByName("Foo"),
+ * }
+ *
+ * validateCustomEnum("EntityTypeCustom", EntityTypeCustom);
+ * ```
+ */
+export function validateCustomEnum(transpiledEnumName, transpiledEnum) {
+    for (const [key, value] of getEnumEntries(transpiledEnum)) {
+        if (value === -1) {
+            error(`Failed to find the custom enum value: ${transpiledEnumName}.${key}`);
+        }
+    }
+}
+/**
+ * Helper function to validate if every value in an enum is contiguous, starting at 0.
+ *
+ * This is useful to automate checking large enums for typos.
+ */
+export function validateEnumContiguous(transpiledEnumName, transpiledEnum) {
+    const values = getEnumValues(transpiledEnum);
+    const valuesSet = new Set(values);
+    const lastValue = values[values.length - 1];
+    if (lastValue === undefined) {
+        error("Failed to validate that an enum was contiguous, since the last value was undefined.");
+    }
+    if (typeof lastValue !== "number") {
+        error("Failed to validate that an enum was contiguous, since the last value was not a number.");
+    }
+    for (const value of irange(lastValue)) {
+        if (!valuesSet.has(value)) {
+            error(`Failed to find a custom enum value of ${value} for: ${transpiledEnumName}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/enums.lua

@@ -175,3 +175,5 @@ function ____exports.validateEnumContiguous(self, transpiledEnumName, transpiled
     end
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL2VudW1zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLGtCQUFzQztBQUE3QjtBQUNULGdCQUE4QjtBQUFyQjtBQUNULGtCQUF5QjtBQUFoQjtBQUNULGtCQUF1QjtBQUFkOzs7Ozs7Ozs7Ozs7Ozs7O0FBbUJULDBDQUNFO0FBR00sd0JBQXVEO0FBQzdELFFBQVksS0FBSyxTQUFVLE1BQU07V0FHM0IsY0FBUztBQUNYLDRDQUFpQixDQUFDLEtBQUs7OztJQU0zQjtRQUFBO1FBQ0U7a0JBQVM7a0JBQVA7WUFBTztrQkFBaUI7a0JBQVA7WUFBTztBQUN4Qiw0QkFBUyxZQUFVLEtBQUksVUFBUyxXQUFTLEtBQUk7UUFEL0M7O0FBSUYsV0FBTztBQXBCVDs7Ozs7Ozs7Ozs7Ozs7O0FBdUNBLHVDQUErQjtBQUN2Qix3QkFBYyxnQ0FBZTtBQUNuQyxXQUFPO1FBQUE7UUFBZ0I7a0JBQUU7WUFBQTtrQkFBSztBQUFZO1FBQW5COztBQUZ6Qjs7QUFNQSx5Q0FBaUM7QUFDekIsd0JBQWMsZ0NBQWU7QUFDbkMsV0FBTztBQUZUOzs7Ozs7Ozs7Ozs7Ozs7QUFxQkEseUNBQWlDO0FBQ3pCLHdCQUFjLGdDQUFlO0FBQ25DLFdBQU87UUFBQTtRQUFnQjtrQkFBUTtrQkFBTjtZQUFNO0FBQVc7UUFBbkI7O0FBRnpCOzs7OztBQVdBLDRDQUFvQztBQUM1Qix1QkFBYSwrQkFBYztBQUUzQix3QkFBYyxXQUFXO09BQzNCO1FBQ0YsTUFDRTs7QUFJSixXQUFPO0FBVlQ7Ozs7Ozs7QUFxQkEsOENBQ0UsZ0JBQ0EsV0FDQTtPQURBO1FBQUEsWUFBd0I7O09BQ3hCO1FBQUEsYUFBNEQ7O0FBRXRELHVCQUFhLCtCQUFjO0FBQ2pDLFdBQU8sMkJBQXNCLFlBQVksV0FBVztBQU50RDs7Ozs7Ozs7Ozs7Ozs7QUF3QkEsOENBQ0Usb0JBQ0E7QUFFQSxrQ0FBMkIsZ0NBQWU7Y0FBOUI7Y0FBSztXQUNYLFVBQVc7WUFDYixRQUNFLDRDQUF5Qyx1QkFBa0IsUUFBSTs7O0FBUHZFOzs7O0FBa0JBLGtEQUNFLG9CQUNBO0FBRU0sbUJBQVMsK0JBQWM7QUFDdkIsc0JBQVksVUFBSSxLQUFJO0FBQ3BCLHNCQUFZLE9BQU87T0FDckI7UUFDRixNQUNFOztPQUdBLEtBQU8sY0FBYztRQUN2QixNQUNFOztBQUdKLGNBQVcsZ0JBQVMsWUFBTztlQUNwQixVQUFVLElBQUk7WUFDakIsUUFDRSxxREFBeUMsV0FBSyxhQUFTOzs7QUFwQi9EIiwiZmlsZSI6ImVudW1zLmx1YSIsInNvdXJjZVJvb3QiOiIifQ==

package/functions/familiars.js

@@ -0,0 +1,85 @@
+import { itemConfig } from "../cachedClasses";
+import { FAMILIARS_THAT_SHOOT_PLAYER_TEARS_SET } from "../sets/familiarsThatShootPlayerTearsSet";
+import { getFamiliars } from "./entitySpecific";
+/**
+ * Helper function to add and remove familiars based on a target amount that you specify.
+ *
+ * This is a convenience wrapper around the `EntityPlayer.CheckFamiliar` method. Use this helper
+ * function instead so that you do not have to retrieve the `ItemConfigItem` and so that you do not
+ * specify an incorrect RNG object. (The vanilla method is bugged in that it does not increment the
+ * RNG object; see the documentation of the method for more details.)
+ *
+ * This function is meant to be called in the EvaluateCache callback (when the cache flag is equal
+ * to `CacheFlag.FAMILIARS`).
+ *
+ * Note that this function is only meant to be used in special circumstances where the familiar
+ * count is completely custom and does not correspond to the amount of collectibles. For the general
+ * case, use the `checkFamiliarFromCollectibles` helper function instead.
+ *
+ * Note that this will spawn familiars with a completely random `InitSeed`. When calculating random
+ * events for this familiar, you should use a data structure that maps familiar `InitSeed` to RNG
+ * objects that are initialized based on the seed from
+ * `EntityPlayer.GetCollectibleRNG(collectibleType)`.
+ *
+ * @param player The player that owns the familiars.
+ * @param collectibleType The collectible type of the collectible associated with this familiar.
+ * @param targetCount The number of familiars that should exist. This function will add or remove
+ *                    familiars until it matches the target count.
+ * @param familiarVariant The variant of the familiar to spawn or remove.
+ * @param familiarSubType Optional. The sub-type of the familiar to spawn or remove. If not
+ *                        specified, it will search for existing familiars of all sub-types, and
+ *                        spawn new familiars with a sub-type of 0.
+ */
+export function checkFamiliar(player, collectibleType, targetCount, familiarVariant, familiarSubType) {
+    const itemConfigItem = itemConfig.GetCollectible(collectibleType);
+    player.CheckFamiliar(familiarVariant, targetCount, RNG(), itemConfigItem, familiarSubType);
+}
+/**
+ * Helper function to add and remove familiars based on the amount of associated collectibles that a
+ * player has.
+ *
+ * Use this helper function instead of invoking the `EntityPlayer.CheckFamiliar` method directly so
+ * that the target count is handled automatically.
+ *
+ * This function is meant to be called in the EvaluateCache callback (when the cache flag is equal
+ * to `CacheFlag.FAMILIARS`).
+ *
+ * Use this function when the amount of familiars should be equal to the amount of associated
+ * collectibles that the player has (plus any extras from having used Box of Friends or Monster
+ * Manual). If you instead need to have a custom amount of familiars, use the `checkFamiliars`
+ * function instead.
+ *
+ * Note that this will spawn familiars with a completely random `InitSeed`. When calculating random
+ * events for this familiar, you should use a data structure that maps familiar `InitSeed` to RNG
+ * objects that are initialized based on the seed from
+ * `EntityPlayer.GetCollectibleRNG(collectibleType)`.
+ *
+ * @param player The player that owns the familiars and collectibles.
+ * @param collectibleType The collectible type of the collectible associated with this familiar.
+ * @param familiarVariant The variant of the familiar to spawn or remove.
+ * @param familiarSubType Optional. The sub-type of the familiar to spawn or remove. If not
+ *                        specified, it will search for existing familiars of all sub-types, and
+ *                        spawn new familiars with a sub-type of 0.
+ */
+export function checkFamiliarFromCollectibles(player, collectibleType, familiarVariant, familiarSubType) {
+    const numCollectibles = player.GetCollectibleNum(collectibleType);
+    const effects = player.GetEffects();
+    // Whenever Box of Friends or Monster Manual is used, it will automatically increment the number
+    // of collectible effects for this familiar.
+    const numCollectibleEffects = effects.GetCollectibleEffectNum(collectibleType);
+    const targetCount = numCollectibles + numCollectibleEffects;
+    checkFamiliar(player, collectibleType, targetCount, familiarVariant, familiarSubType);
+}
+/** Helper function to get only the familiars that belong to a specific player. */
+export function getPlayerFamiliars(player) {
+    const playerPtrHash = GetPtrHash(player);
+    const familiars = getFamiliars();
+    return familiars.filter((familiar) => {
+        const familiarPlayerPtrHash = GetPtrHash(familiar.Player);
+        return familiarPlayerPtrHash === playerPtrHash;
+    });
+}
+export function isFamiliarThatShootsPlayerTears(familiar) {
+    return FAMILIARS_THAT_SHOOT_PLAYER_TEARS_SET.has(familiar.Variant);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFtaWxpYXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mdW5jdGlvbnMvZmFtaWxpYXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM5QyxPQUFPLEVBQUUscUNBQXFDLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQztBQUNqRyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0E0Qkc7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUMzQixNQUFvQixFQUNwQixlQUFnQyxFQUNoQyxXQUFnQixFQUNoQixlQUFnQyxFQUNoQyxlQUFxQjtJQUVyQixNQUFNLGNBQWMsR0FBRyxVQUFVLENBQUMsY0FBYyxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQ2xFLE1BQU0sQ0FBQyxhQUFhLENBQ2xCLGVBQWUsRUFDZixXQUFXLEVBQ1gsR0FBRyxFQUFFLEVBQ0wsY0FBYyxFQUNkLGVBQWUsQ0FDaEIsQ0FBQztBQUNKLENBQUM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0EwQkc7QUFDSCxNQUFNLFVBQVUsNkJBQTZCLENBQzNDLE1BQW9CLEVBQ3BCLGVBQWdDLEVBQ2hDLGVBQWdDLEVBQ2hDLGVBQXFCO0lBRXJCLE1BQU0sZUFBZSxHQUFHLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUNsRSxNQUFNLE9BQU8sR0FBRyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUM7SUFFcEMsZ0dBQWdHO0lBQ2hHLDRDQUE0QztJQUM1QyxNQUFNLHFCQUFxQixHQUN6QixPQUFPLENBQUMsdUJBQXVCLENBQUMsZUFBZSxDQUFDLENBQUM7SUFDbkQsTUFBTSxXQUFXLEdBQUcsZUFBZSxHQUFHLHFCQUFxQixDQUFDO0lBRTVELGFBQWEsQ0FDWCxNQUFNLEVBQ04sZUFBZSxFQUNmLFdBQVcsRUFDWCxlQUFlLEVBQ2YsZUFBZSxDQUNoQixDQUFDO0FBQ0osQ0FBQztBQUVELGtGQUFrRjtBQUNsRixNQUFNLFVBQVUsa0JBQWtCLENBQUMsTUFBb0I7SUFDckQsTUFBTSxhQUFhLEdBQUcsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3pDLE1BQU0sU0FBUyxHQUFHLFlBQVksRUFBRSxDQUFDO0lBQ2pDLE9BQU8sU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFO1FBQ25DLE1BQU0scUJBQXFCLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUMxRCxPQUFPLHFCQUFxQixLQUFLLGFBQWEsQ0FBQztJQUNqRCxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUM7QUFFRCxNQUFNLFVBQVUsK0JBQStCLENBQzdDLFFBQXdCO0lBRXhCLE9BQU8scUNBQXFDLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUNyRSxDQUFDIn0=

package/functions/familiars.lua

@@ -99,3 +99,5 @@ function ____exports.isFamiliarThatShootsPlayerTears(self, familiar)
     return FAMILIARS_THAT_SHOOT_PLAYER_TEARS_SET:has(familiar.Variant)
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL2ZhbWlsaWFycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSwwQkFBMkI7QUFBbEI7QUFDVCw2Q0FBc0Q7QUFBN0M7QUFDVCwyQkFBNkI7QUFBcEI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUErQlQseUNBQ0UsUUFDQSxpQkFDQSxhQUNBLGlCQUNBO0FBRU0sMkJBQWlCLFdBQVcsZUFBZTtJQUNqRCxPQUFPO1FBQ0w7UUFDQTtRQUNBO1FBQ0E7UUFDQTs7QUFiSjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUE0Q0EseURBQ0UsUUFDQSxpQkFDQSxpQkFDQTtBQUVNLDRCQUFrQixPQUFPLGtCQUFrQjtBQUMzQyxvQkFBVSxPQUFPO0FBSWpCLGtDQUNKLFFBQVEsd0JBQXdCO0FBQzVCLHdCQUFjLGtCQUFrQjtJQUV0Qzs7UUFDRTtRQUNBO1FBQ0E7UUFDQTtRQUNBOztBQXBCSjs7QUF5QkEsOENBQW1DO0FBQzNCLDBCQUFnQixXQUFXO0FBQzNCLHNCQUFZO0FBQ2xCLFdBQU87UUFBQTtRQUFpQixlQUFDO0FBQ2pCLDBDQUF3QixXQUFXO0FBQ3pDLG1CQUFPLHlCQUEwQjtRQUZYOztBQUgxQjtBQVNBLDJEQUNFO0FBRUEsV0FBTyxzQ0FBc0MsSUFBSTtBQUhuRCIsImZpbGUiOiJmYW1pbGlhcnMubHVhIiwic291cmNlUm9vdCI6IiJ9

package/functions/flag.js

@@ -0,0 +1,137 @@
+import { DamageFlag } from "isaac-typescript-definitions";
+/**
+ * Helper function to add a bit flag to an existing set of bit flags.
+ *
+ * This is a variadic function, so pass as many flags as you want to add.
+ *
+ * Example 1:
+ *
+ * ```ts
+ * // Give the player spectral tears
+ * const player = Isaac.GetPlayer();
+ * player.TearFlags = addFlag(player.TearFlags, TearFlags.TEAR_SPECTRAL);
+ * ```
+ *
+ * Example 2:
+ *
+ * ```ts
+ * // Give the player spectral and homing tears
+ * const player = Isaac.GetPlayer();
+ * player.TearFlags = addFlag(player.TearFlags, TearFlags.TEAR_SPECTRAL, TearFlags.TEAR_HOMING);
+ * ```
+ *
+ * @param flags The existing set of bit flags.
+ * @param flagsToAdd One or more bit flags to add, each as a separate argument.
+ * @returns The combined bit flags.
+ */
+export function addFlag(flags, ...flagsToAdd) {
+    let flagsAsInt = flags;
+    for (const flagToAdd of flagsToAdd) {
+        flagsAsInt |= flagToAdd;
+    }
+    return flagsAsInt;
+}
+/**
+ * Helper function for casting a flag enum value to a `BitFlags` object.
+ *
+ * This is useful because the compiler will prevent you from assigning a specific flag to a
+ * `BitFlags` property. (It does this to ensure type safety, since `BitFlags` can represent a zero
+ * value or a composition of N flags.)
+ *
+ * For example:
+ *
+ * ```ts
+ * player.TearFlags = bitFlags(TearFlag.SPECTRAL);
+ * ```
+ */
+export function bitFlags(flag) {
+    return flag;
+}
+/**
+ * Helper function to get the key associated with a particular flag.
+ *
+ * (Since bit flags are represented by custom objects instead of normal TypeScript enums, you cannot
+ * use the reverse mapping to find the associated key of a given enum value. Use this helper
+ * function instead of indexing the enum directly.)
+ */
+export function getFlagName(flag, flagEnum) {
+    for (const [key, value] of pairs(flagEnum)) {
+        if (value === flag) {
+            return key;
+        }
+    }
+    return undefined;
+}
+/**
+ * Helper function to determine if a particular bit flag is set to true.
+ *
+ * This is a variadic function, so pass as many flags as you want to check for. If passed multiple
+ * flags, it will only return true if all of the flags are set.
+ *
+ * For example:
+ *
+ * ```ts
+ * const player = Isaac.GetPlayer();
+ * if (hasFlag(player.TearFlags, TearFlags.TEAR_SPECTRAL) {
+ *   // The player currently has spectral tears
+ * }
+ * ```
+ *
+ * @param flags The existing set of bit flags.
+ * @param flagsToCheck One or more bit flags to check for, each as a separate argument.
+ */
+export function hasFlag(flags, ...flagsToCheck) {
+    const flagsAsInt = flags;
+    for (const flagToCheck of flagsToCheck) {
+        if (!((flagsAsInt & flagToCheck) === flagToCheck)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Helper function to check if every bit in the flag is turned off.
+ *
+ * (This is equivalent to checking if the flag is equal to 0, but this is not possible without
+ * casting the flag to a number.)
+ */
+export function isEmptyFlag(flag) {
+    return flag === 0;
+}
+/**
+ * Helper function to determine whether damage to a player in the EntityTakeDmg callback was
+ * self-inflicted. For example, damage from a Curse Room door, a Razor, or a Blood Donation Machine
+ * would count as self-inflicted damage.
+ */
+export function isSelfDamage(damageFlags) {
+    return (
+    // Exclude self-damage from e.g. Curse Room door spikes.
+    hasFlag(damageFlags, DamageFlag.NO_PENALTIES) ||
+        // Exclude self-damage from e.g. Razor.
+        hasFlag(damageFlags, DamageFlag.RED_HEARTS));
+}
+/**
+ * Helper function to remove a bit flag from an existing set of bit flags.
+ *
+ * This is a variadic function, so pass as many flags as you want to remove.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Remove spectral tears from the player, if present
+ * const player = Isaac.GetPlayer();
+ * player.TearFlags = removeFlag(player.TearFlags, TearFlags.TEAR_SPECTRAL);
+ * ```
+ *
+ * @param flags The existing set of bit flags.
+ * @param flagsToRemove One or more bit flags to remove, each as a separate argument.
+ * @returns The combined bit flags.
+ */
+export function removeFlag(flags, ...flagsToRemove) {
+    let flagsAsInt = flags;
+    for (const flagToRemove of flagsToRemove) {
+        flagsAsInt &= ~flagToRemove;
+    }
+    return flagsAsInt;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxhZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL2ZsYWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRTFEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F3Qkc7QUFDSCxNQUFNLFVBQVUsT0FBTyxDQUNyQixLQUFzQixFQUN0QixHQUFHLFVBQWU7SUFFbEIsSUFBSSxVQUFVLEdBQUcsS0FBWSxDQUFDO0lBRTlCLEtBQUssTUFBTSxTQUFTLElBQUksVUFBVSxFQUFFO1FBQ2xDLFVBQVUsSUFBSSxTQUFnQixDQUFDO0tBQ2hDO0lBRUQsT0FBTyxVQUF5QixDQUFDO0FBQ25DLENBQUM7QUFFRDs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCxNQUFNLFVBQVUsUUFBUSxDQUFpQyxJQUFPO0lBQzlELE9BQU8sSUFBbUIsQ0FBQztBQUM3QixDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FDekIsSUFBYSxFQUNiLFFBQTJCO0lBRTNCLEtBQUssTUFBTSxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsUUFBUSxDQUFDLEVBQUU7UUFDMUMsSUFBSSxLQUFLLEtBQUssSUFBSSxFQUFFO1lBQ2xCLE9BQU8sR0FBRyxDQUFDO1NBQ1o7S0FDRjtJQUVELE9BQU8sU0FBUyxDQUFDO0FBQ25CLENBQUM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLFVBQVUsT0FBTyxDQUNyQixLQUFzQixFQUN0QixHQUFHLFlBQWlCO0lBRXBCLE1BQU0sVUFBVSxHQUFHLEtBQVksQ0FBQztJQUVoQyxLQUFLLE1BQU0sV0FBVyxJQUFJLFlBQVksRUFBRTtRQUN0QyxJQUFJLENBQUMsQ0FBQyxDQUFDLFVBQVUsR0FBSSxXQUFtQixDQUFDLEtBQUssV0FBVyxDQUFDLEVBQUU7WUFDMUQsT0FBTyxLQUFLLENBQUM7U0FDZDtLQUNGO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsV0FBVyxDQUFpQyxJQUFPO0lBQ2pFLE9BQU8sSUFBSSxLQUFLLENBQUMsQ0FBQztBQUNwQixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQzFCLFdBQThDO0lBRTlDLE9BQU87SUFDTCx3REFBd0Q7SUFDeEQsT0FBTyxDQUFDLFdBQVcsRUFBRSxVQUFVLENBQUMsWUFBWSxDQUFDO1FBQzdDLHVDQUF1QztRQUN2QyxPQUFPLENBQUMsV0FBVyxFQUFFLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FDNUMsQ0FBQztBQUNKLENBQUM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQ3hCLEtBQXNCLEVBQ3RCLEdBQUcsYUFBa0I7SUFFckIsSUFBSSxVQUFVLEdBQUcsS0FBWSxDQUFDO0lBRTlCLEtBQUssTUFBTSxZQUFZLElBQUksYUFBYSxFQUFFO1FBQ3hDLFVBQVUsSUFBSSxDQUFDLFlBQVksQ0FBQztLQUM3QjtJQUVELE9BQU8sVUFBeUIsQ0FBQztBQUNuQyxDQUFDIn0=

package/functions/flag.lua

@@ -122,3 +122,5 @@ function ____exports.removeFlag(self, flags, ...)
     return flagsAsInt
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL2ZsYWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDZDQUEyQjtBQUFsQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBMkJULG1DQUNFO1VBQ0c7QUFFQyx1QkFBYTtBQUVqQixjQUFXLG9CQUFhO0FBQ3RCLGtDQUFjOztBQUdoQixXQUFPO0FBVlQ7Ozs7Ozs7Ozs7OztBQTBCQSxvQ0FBeUQ7QUFDdkQsV0FBTztBQURUOzs7Ozs7QUFXQSx1Q0FDRSxNQUNBO0FBRUEsUUFBWSxLQUFLLFNBQVUsTUFBTTtXQUMzQixTQUFVO0FBQ1osbUJBQU87OztBQUlYO0FBVkY7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBK0JBLG1DQUNFO1VBQ0c7QUFFRyx1QkFBYTtBQUVuQixjQUFXLHNCQUFlO2VBQ2xCLENBQUMsYUFBYyxlQUF5QjtBQUM1QyxtQkFBTzs7O0FBSVgsV0FBTztBQVpUOzs7OztBQXFCQSx1Q0FBNEQ7QUFDMUQsV0FBTyxRQUFTO0FBRGxCOzs7O0FBU0Esd0NBQ0U7QUFFQSxXQUVFLHlCQUFRLGFBQWEsNEJBRXJCLHlCQUFRLGFBQWE7QUFQekI7Ozs7Ozs7Ozs7Ozs7Ozs7QUE0QkEsc0NBQ0U7VUFDRztBQUVDLHVCQUFhO0FBRWpCLGNBQVcsdUJBQWdCO0FBQ3pCLGtDQUFjLENBQUM7O0FBR2pCLFdBQU87QUFWVCIsImZpbGUiOiJmbGFnLmx1YSIsInNvdXJjZVJvb3QiOiIifQ==

package/functions/flying.js

@@ -0,0 +1,88 @@
+import { CacheFlag, CollectibleType, NullItemID, PlayerType, TrinketType, } from "isaac-typescript-definitions";
+import { getCollectiblesForCacheFlag } from "./collectibleCacheFlag";
+import { copySet, deleteSetsFromSet } from "./set";
+const FLYING_CHARACTERS = new Set([
+    PlayerType.AZAZEL,
+    PlayerType.THE_LOST,
+    PlayerType.THE_SOUL,
+    PlayerType.THE_LOST_B,
+    PlayerType.JACOB_2_B,
+    PlayerType.THE_SOUL_B, // 40
+]);
+const FLYING_TRINKETS = new Set([
+    TrinketType.BAT_WING,
+    TrinketType.AZAZELS_STUMP, // 162
+]);
+const FLYING_NULL_ITEMS = [
+    NullItemID.REVERSE_SUN,
+    NullItemID.SPIRIT_SHACKLES_SOUL,
+    NullItemID.LOST_CURSE, // 112
+];
+const CONDITIONAL_FLYING_COLLECTIBLE_TYPES = [
+    CollectibleType.BIBLE,
+    CollectibleType.EMPTY_VESSEL,
+    CollectibleType.ASTRAL_PROJECTION,
+    CollectibleType.RECALL,
+];
+/**
+ * Returns a set of all of the collectibles that grant flight. This is derived from collectibles
+ * that have `CacheFlag.FLYING` set in the "items.xml" file.
+ *
+ * Collectibles that only grant flight conditionally are manually pruned. Collectibles such as Empty
+ * Vessel should be checked for via the `hasFlyingTemporaryEffect` function.
+ *
+ * @param pruneConditionalItems Whether or not collectibles that only grant flight conditionally
+ *                              should be included in the set (like Empty Vessel).
+ */
+export function getFlyingCollectibles(pruneConditionalItems) {
+    // Instead of manually compiling a list of collectibles that grant flying, we can instead
+    // dynamically look for collectibles that have `CacheFlag.FLYING`.
+    const collectiblesWithFlyingCacheFlag = getCollectiblesForCacheFlag(CacheFlag.FLYING);
+    // None of the collectibles with a cache of "all" grant flying, so we can safely remove them from
+    // the list.
+    const collectiblesWithAllCacheFlag = getCollectiblesForCacheFlag(CacheFlag.ALL);
+    deleteSetsFromSet(collectiblesWithFlyingCacheFlag, collectiblesWithAllCacheFlag);
+    if (pruneConditionalItems) {
+        for (const collectibleType of CONDITIONAL_FLYING_COLLECTIBLE_TYPES) {
+            collectiblesWithFlyingCacheFlag.delete(collectibleType);
+        }
+    }
+    return collectiblesWithFlyingCacheFlag;
+}
+/**
+ * Returns a set of all of the trinkets that grant flight. (All trinkets that grant flight do so
+ * conditionally, like Bat Wing.)
+ */
+export function getFlyingTrinkets() {
+    // We use a different algorithm than the "getFlyingCollectibles" function because Azazel's Stump
+    // has a cache of "all".
+    return copySet(FLYING_TRINKETS);
+}
+export function hasFlyingTemporaryEffect(player) {
+    const effects = player.GetEffects();
+    // - Hanged Man card gives a Transcendence temporary effect.
+    // - Pinking Shears gives a Transcendence temporary effect.
+    const flyingCollectibles = getFlyingCollectibles(false);
+    for (const collectibleType of flyingCollectibles.values()) {
+        if (effects.HasCollectibleEffect(collectibleType)) {
+            return true;
+        }
+    }
+    const flyingTrinkets = getFlyingTrinkets();
+    for (const trinketType of flyingTrinkets.values()) {
+        if (effects.HasTrinketEffect(trinketType)) {
+            return true;
+        }
+    }
+    for (const nullItemID of FLYING_NULL_ITEMS) {
+        if (effects.HasNullEffect(nullItemID)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isFlyingCharacter(player) {
+    const character = player.GetPlayerType();
+    return FLYING_CHARACTERS.has(character);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/flying.lua

@@ -75,3 +75,5 @@ function ____exports.isFlyingCharacter(self, player)
     return FLYING_CHARACTERS:has(character)
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL2ZseWluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDZDQU1PO0FBTEw7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUVGLGlDQUE0QztBQUFuQztBQUNULGdCQUEyQztBQUFsQztBQUFTO0FBRVosMEJBQTZDLFVBQUksS0FBSTtJQUN6RDtJQUNBO0lBQ0E7SUFDQTtJQUNBO0lBQ0E7O0FBR0ksd0JBQTRDLFVBQUksS0FBSSxDQUN4RCxzQkFDQTtBQUdJLDBCQUEyQyxDQUMvQyx3QkFDQSxpQ0FDQTtBQUdJLDZDQUFtRSxDQUN2RSx1QkFDQSw4QkFDQSxtQ0FDQTs7Ozs7Ozs7O0FBYUYsaURBQ0U7QUFJTSw0Q0FBa0MsaUNBQ3RDO0FBS0kseUNBQStCLGlDQUNuQztJQUVGLHVCQUNFLGlDQUNBO09BR0U7QUFDRixrQkFBVywwQkFBbUI7WUFDNUIsZ0NBQWdDLE9BQU87OztBQUkzQyxXQUFPO0FBekJUOzs7QUFnQ0E7QUFHRSxXQUFPLGFBQVE7QUFIakI7QUFNQSxvREFBeUM7QUFDakMsb0JBQVUsT0FBTztBQUlqQiwrQkFBcUIsdUNBQXNCO0FBQ2pELGNBQVcsbUJBQW1CLGtDQUFtQjtXQUMzQyxRQUFRLHFCQUFxQjtBQUMvQixtQkFBTzs7O0FBSUwsMkJBQWlCO0FBQ3ZCLGNBQVcsZUFBZSw4QkFBZTtXQUNuQyxRQUFRLGlCQUFpQjtBQUMzQixtQkFBTzs7O0FBSVgsY0FBVyxxQkFBYztXQUNuQixRQUFRLGNBQWM7QUFDeEIsbUJBQU87OztBQUlYLFdBQU87QUF6QlQ7QUE0QkEsNkNBQWtDO0FBQzFCLHNCQUFZLE9BQU87QUFDekIsV0FBTyxrQkFBa0IsSUFBSTtBQUYvQiIsImZpbGUiOiJmbHlpbmcubHVhIiwic291cmNlUm9vdCI6IiJ9