isaacscript-common 84.0.0 → 84.1.0

package/dist/functions/enums.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInterfaceMatchesEnum = exports.validateEnumContiguous = exports.validateCustomEnum = exports.isEnumValue = exports.getRandomEnumValue = exports.getLowestEnumValue = exports.getHighestEnumValue = exports.getEnumValues = exports.getEnumNames = exports.getEnumLength = exports.getEnumKeys = exports.getEnumEntries = void 0;
+const ReadonlySet_1 = require("../types/ReadonlySet");
+const array_1 = require("./array");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * TypeScriptToLua will transpile TypeScript number 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. (It is impossible to get the declaration order at
+ * run-time.)
+ *
+ * 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/main/gotchas#iterating-over-enums
+ */
+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 ((0, types_1.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;
+}
+exports.getEnumEntries = getEnumEntries;
+/**
+ * TypeScriptToLua will transpile TypeScript number 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. (It is impossible to get the declaration order at
+ * run-time.)
+ *
+ * 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/main/gotchas#iterating-over-enums
+ */
+function getEnumKeys(transpiledEnum) {
+    const enumEntries = getEnumEntries(transpiledEnum);
+    return enumEntries.map(([key, _value]) => key);
+}
+exports.getEnumKeys = getEnumKeys;
+/** Helper function to get the amount of entries inside of an enum. */
+function getEnumLength(transpiledEnum) {
+    const enumEntries = getEnumEntries(transpiledEnum);
+    return enumEntries.length;
+}
+exports.getEnumLength = getEnumLength;
+/**
+ * TypeScriptToLua will transpile TypeScript number 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 names of an enum from the reverse mapping, use
+ * this helper function.
+ *
+ * This function will return the enum names in a sorted order, which may not necessarily be the same
+ * order as which they were declared in. (It is impossible to get the declaration order at
+ * run-time.)
+ *
+ * This function will work properly for both number enums and string enums. (Reverse mappings are
+ * not created for string enums, so their names would be equivalent to what would be returned by the
+ * `getEnumKeys` function.)
+ *
+ * For a more in depth explanation, see:
+ * https://isaacscript.github.io/main/gotchas#iterating-over-enums
+ */
+function getEnumNames(transpiledEnum) {
+    const enumNames = [];
+    for (const [key, _value] of pairs(transpiledEnum)) {
+        if ((0, types_1.isString)(key)) {
+            enumNames.push(key);
+        }
+    }
+    // The enum names will be in a random order (because of "pairs"), so sort them.
+    enumNames.sort();
+    return enumNames;
+}
+exports.getEnumNames = getEnumNames;
+/**
+ * TypeScriptToLua will transpile TypeScript number 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. (It is impossible to get the declaration order at
+ * run-time.)
+ *
+ * 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/main/gotchas#iterating-over-enums
+ */
+function getEnumValues(transpiledEnum) {
+    const enumEntries = getEnumEntries(transpiledEnum);
+    return enumEntries.map(([_key, value]) => value);
+}
+exports.getEnumValues = getEnumValues;
+/**
+ * Helper function to get the enum value with the highest value.
+ *
+ * Note that this is not necessarily the enum value that is declared last in the code, since there
+ * is no way to infer that at run-time.
+ *
+ * Throws an error if the provided enum is empty.
+ */
+function getHighestEnumValue(transpiledEnum) {
+    const enumValues = getEnumValues(transpiledEnum);
+    const lastElement = enumValues.at(-1);
+    (0, utils_1.assertDefined)(lastElement, "Failed to get the last value from an enum since the enum was empty.");
+    return lastElement;
+}
+exports.getHighestEnumValue = getHighestEnumValue;
+/**
+ * Helper function to get the enum value with the lowest value.
+ *
+ * Note that this is not necessarily the enum value that is declared first in the code, since there
+ * is no way to infer that at run-time.
+ *
+ * Throws an error if the provided enum is empty.
+ */
+function getLowestEnumValue(transpiledEnum) {
+    const enumValues = getEnumValues(transpiledEnum);
+    const firstElement = enumValues[0];
+    (0, utils_1.assertDefined)(firstElement, "Failed to get the first value from an enum since the enum was empty.");
+    return firstElement;
+}
+exports.getLowestEnumValue = getLowestEnumValue;
+/**
+ * Helper function to get a random value from the provided enum.
+ *
+ * If you want an unseeded value, you must explicitly pass `undefined` to the `seedOrRNG` parameter.
+ *
+ * @param transpiledEnum The enum to get the value from.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+function getRandomEnumValue(transpiledEnum, seedOrRNG, exceptions = []) {
+    const enumValues = getEnumValues(transpiledEnum);
+    return (0, array_1.getRandomArrayElement)(enumValues, seedOrRNG, exceptions);
+}
+exports.getRandomEnumValue = getRandomEnumValue;
+/** Helper function to validate that a particular value exists inside of an enum. */
+function isEnumValue(value, transpiledEnum) {
+    const enumValues = getEnumValues(transpiledEnum);
+    return enumValues.includes(value);
+}
+exports.isEnumValue = isEnumValue;
+/**
+ * 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);
+ * ```
+ */
+function validateCustomEnum(transpiledEnumName, transpiledEnum) {
+    for (const [key, value] of getEnumEntries(transpiledEnum)) {
+        if (value === -1) {
+            error(`Failed to find the custom enum value: ${transpiledEnumName}.${key}`);
+        }
+    }
+}
+exports.validateCustomEnum = validateCustomEnum;
+/**
+ * Helper function to validate if every value in a number enum is contiguous, starting at 0.
+ *
+ * This is useful to automate checking large enums for typos.
+ */
+function validateEnumContiguous(transpiledEnumName, transpiledEnum) {
+    const values = getEnumValues(transpiledEnum);
+    const lastValue = values.at(-1);
+    (0, utils_1.assertDefined)(lastValue, "Failed to validate that an enum was contiguous, since the last value was undefined.");
+    if (!(0, types_1.isNumber)(lastValue)) {
+        error("Failed to validate that an enum was contiguous, since the last value was not a number.");
+    }
+    const valuesSet = new ReadonlySet_1.ReadonlySet(values);
+    for (const value of (0, utils_1.iRange)(lastValue)) {
+        if (!valuesSet.has(value)) {
+            error(`Failed to find a custom enum value of ${value} for: ${transpiledEnumName}`);
+        }
+    }
+}
+exports.validateEnumContiguous = validateEnumContiguous;
+/**
+ * Helper function to validate that an interface contains all of the keys of an enum. You must
+ * specify both generic parameters in order for this to work properly (i.e. the interface and then
+ * the enum).
+ *
+ * For example:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ *   Value2,
+ *   Value3,
+ * }
+ *
+ * interface MyEnumToType {
+ *   [MyEnum.Value1]: boolean;
+ *   [MyEnum.Value2]: number;
+ *   [MyEnum.Value3]: string;
+ * }
+ *
+ * validateInterfaceMatchesEnum<MyEnumToType, MyEnum>();
+ * ```
+ *
+ * This function is only meant to be used with interfaces (i.e. types that will not exist at
+ * run-time). If you are generating an object that will contain all of the keys of an enum, use the
+ * `satisfies` operator with the `Record` type instead.
+ */
+function validateInterfaceMatchesEnum() { } // eslint-disable-line @typescript-eslint/no-empty-function
+exports.validateInterfaceMatchesEnum = validateInterfaceMatchesEnum;

package/dist/functions/external.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Helper functions that have to do with external programs.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebirthItemTrackerWriteToFile = exports.rebirthItemTrackerRemoveCollectible = void 0;
+const collectibles_1 = require("./collectibles");
+const REBIRTH_ITEM_TRACKER_REMOVE_COLLECTIBLE_COMMAND = "REBIRTH_ITEM_TRACKER_REMOVE_COLLECTIBLE";
+const REBIRTH_ITEM_TRACKER_WRITE_TO_FILE_COMMAND = "REBIRTH_ITEM_TRACKER_WRITE_TO_FILE";
+/**
+ * Helper function to let the Rebirth Item Tracker know that it should remove a collectible from its
+ * list.
+ *
+ * The "item tracker" in this function does not refer to the in-game item tracker, but rather to the
+ * external Python program.
+ *
+ * This function is variadic, meaning that you can pass as many collectible types as you want to
+ * remove.
+ *
+ * Note that calling this function is not normally necessary when removing collectibles from
+ * players. For example, when you remove a collectible with the `EntityPlayer.RemoveCollectible`
+ * method, a message is sent to the log file by the game and the item tracker will automatically
+ * remove it. However, in some cases, manually removing collectibles can be useful:
+ *
+ * - We may be giving the player a "fake" collectible (e.g. 1-Up for the purposes of an extra life)
+ *   and do not want the fake collectible to show up on the tracker.
+ * - We may be removing a starting active item. Since active items are never removed from the
+ *   tracker, we want to tell the item tracker that the player never had a particular active item to
+ *   begin with.
+ *
+ * @see https://github.com/Rchardon/RebirthItemTracker
+ */
+function rebirthItemTrackerRemoveCollectible(...collectibleTypes) {
+    for (const collectibleType of collectibleTypes) {
+        // This cannot use the "log" function since the prefix will prevent the Rebirth Item Tracker
+        // from recognizing the message.
+        const collectibleName = (0, collectibles_1.getCollectibleName)(collectibleType);
+        Isaac.DebugString(`${REBIRTH_ITEM_TRACKER_REMOVE_COLLECTIBLE_COMMAND} Removing collectible ${collectibleType} (${collectibleName}) on player 0 (Player)`);
+    }
+}
+exports.rebirthItemTrackerRemoveCollectible = rebirthItemTrackerRemoveCollectible;
+/**
+ * Helper function to let the Rebirth Item Tracker know that it should write the submitted text
+ * string to a file. This is useful for capturing text in programs like Open Broadcaster Software
+ * (OBS).
+ *
+ * The "item tracker" in this function does not refer to the in-game item tracker, but rather to the
+ * external Python program.
+ *
+ * @see https://github.com/Rchardon/RebirthItemTracker
+ */
+function rebirthItemTrackerWriteToFile(msg) {
+    // This cannot use the "log" function since the prefix will prevent the Rebirth Item Tracker from
+    // recognizing the message.
+    Isaac.DebugString(`${REBIRTH_ITEM_TRACKER_WRITE_TO_FILE_COMMAND} ${msg}`);
+}
+exports.rebirthItemTrackerWriteToFile = rebirthItemTrackerWriteToFile;

package/dist/functions/familiars.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFamiliarThatShootsPlayerTears = exports.isFamiliarStolenBySiren = exports.getSirenHelper = exports.getPlayerFamiliars = exports.checkFamiliarFromCollectibles = exports.checkFamiliar = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const familiarsThatShootPlayerTearsSet_1 = require("../sets/familiarsThatShootPlayerTearsSet");
+const entities_1 = require("./entities");
+const entitiesSpecific_1 = require("./entitiesSpecific");
+const rng_1 = require("./rng");
+/**
+ * Instead of generating a new RNG object every time we need to spawn a new familiar, we instead
+ * re-use the same RNG object. This makes it less likely that the `InitSeed` of the familiar will
+ * overlap, since we are "nexting" instead of doing a fresh reroll.
+ */
+const familiarGenerationRNG = (0, rng_1.newRNG)();
+/**
+ * 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 `EVALUATE_CACHE` 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.
+ */
+function checkFamiliar(player, collectibleType, targetCount, familiarVariant, familiarSubType) {
+    familiarGenerationRNG.Next();
+    const itemConfigItem = cachedClasses_1.itemConfig.GetCollectible(collectibleType);
+    player.CheckFamiliar(familiarVariant, targetCount, familiarGenerationRNG, itemConfigItem, familiarSubType);
+}
+exports.checkFamiliar = checkFamiliar;
+/**
+ * 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 `EVALUATE_CACHE` 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.
+ */
+function checkFamiliarFromCollectibles(player, collectibleType, familiarVariant, familiarSubType) {
+    // We need to include non-real collectibles (like Lilith's Incubus), so we omit the second
+    // argument.
+    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);
+}
+exports.checkFamiliarFromCollectibles = checkFamiliarFromCollectibles;
+/** Helper function to get only the familiars that belong to a specific player. */
+function getPlayerFamiliars(player) {
+    const playerPtrHash = GetPtrHash(player);
+    const familiars = (0, entitiesSpecific_1.getFamiliars)();
+    return familiars.filter((familiar) => {
+        const familiarPlayerPtrHash = GetPtrHash(familiar.Player);
+        return familiarPlayerPtrHash === playerPtrHash;
+    });
+}
+exports.getPlayerFamiliars = getPlayerFamiliars;
+/**
+ * Helper function to get the corresponding "Siren Helper" entity for a stolen familiar.
+ *
+ * When The Siren boss "steals" your familiars, a hidden "Siren Helper" entity is spawned to control
+ * each familiar stolen. (Checking for the presence of this entity seems to be the only way to
+ * detect when the Siren steals a familiar.)
+ *
+ * @param familiar The familiar to be checked.
+ * @returns Returns the hidden "Siren Helper" entity corresponding to the given familiar, if it
+ *          exists. Returns undefined otherwise.
+ */
+function getSirenHelper(familiar) {
+    const familiarPtrHash = GetPtrHash(familiar);
+    const sirenHelpers = (0, entities_1.getEntities)(isaac_typescript_definitions_1.EntityType.SIREN_HELPER);
+    return sirenHelpers.find((sirenHelper) => sirenHelper.Target !== undefined &&
+        GetPtrHash(sirenHelper.Target) === familiarPtrHash);
+}
+exports.getSirenHelper = getSirenHelper;
+/**
+ * Helper function to detect if the given familiar is "stolen" by The Siren boss.
+ *
+ * This function is useful because some familiars may need to behave differently when under The
+ * Siren's control (e.g. if they auto-target enemies).
+ */
+function isFamiliarStolenBySiren(familiar) {
+    const sirenHelper = getSirenHelper(familiar);
+    return sirenHelper !== undefined;
+}
+exports.isFamiliarStolenBySiren = isFamiliarStolenBySiren;
+/**
+ * Helper function to check if a familiar is the type that shoots tears that mimic the players
+ * tears, like Incubus, Fate's Reward, Sprinkler, and so on.
+ */
+function isFamiliarThatShootsPlayerTears(familiar) {
+    return familiarsThatShootPlayerTearsSet_1.FAMILIARS_THAT_SHOOT_PLAYER_TEARS_SET.has(familiar.Variant);
+}
+exports.isFamiliarThatShootsPlayerTears = isFamiliarThatShootsPlayerTears;

package/dist/functions/flag.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeFlag = exports.isSelfDamage = exports.isEmptyFlag = exports.hasFlag = exports.getFlagName = exports.bitFlags = exports.addFlag = void 0;
+const isaac_typescript_definitions_1 = require("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.
+ */
+function addFlag(flags, ...flagsToAdd) {
+    let flagsAsInt = flags;
+    for (const flagToAdd of flagsToAdd) {
+        flagsAsInt |= flagToAdd;
+    }
+    return flagsAsInt;
+}
+exports.addFlag = addFlag;
+/**
+ * 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` field. (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);
+ * ```
+ */
+function bitFlags(flag) {
+    return flag;
+}
+exports.bitFlags = bitFlags;
+/**
+ * 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.)
+ */
+function getFlagName(flag, flagEnum) {
+    for (const [key, value] of Object.entries(flagEnum)) {
+        if (value === flag) {
+            return key;
+        }
+    }
+    return undefined;
+}
+exports.getFlagName = getFlagName;
+/**
+ * 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.
+ */
+function hasFlag(flags, ...flagsToCheck) {
+    const flagsAsInt = flags;
+    for (const flagToCheck of flagsToCheck) {
+        if (!((flagsAsInt & flagToCheck) === flagToCheck)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.hasFlag = hasFlag;
+/**
+ * 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.)
+ */
+function isEmptyFlag(flag) {
+    return flag === 0;
+}
+exports.isEmptyFlag = isEmptyFlag;
+/**
+ * Helper function to determine whether damage to a player in the `ENTITY_TAKE_DMG` 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.
+ */
+function isSelfDamage(damageFlags) {
+    return (
+    // Exclude self-damage from e.g. Curse Room door spikes.
+    hasFlag(damageFlags, isaac_typescript_definitions_1.DamageFlag.NO_PENALTIES) ||
+        // Exclude self-damage from e.g. Razor.
+        hasFlag(damageFlags, isaac_typescript_definitions_1.DamageFlag.RED_HEARTS));
+}
+exports.isSelfDamage = isSelfDamage;
+/**
+ * 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.
+ */
+function removeFlag(flags, ...flagsToRemove) {
+    let flagsAsInt = flags;
+    for (const flagToRemove of flagsToRemove) {
+        flagsAsInt &= ~flagToRemove;
+    }
+    return flagsAsInt;
+}
+exports.removeFlag = removeFlag;