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

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/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/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/globals.js

@@ -0,0 +1,230 @@
+import { isLuaDebugEnabled } from "./debug";
+import { log } from "./log";
+import { addSetsToSet, copySet } from "./set";
+import { twoDimensionalSort } from "./utils";
+const DEFAULT_GLOBALS = new Set([
+    "ActionTriggers",
+    "ActiveSlot",
+    "BabySubType",
+    "BackdropType",
+    "BatterySubType",
+    "BedSubType",
+    "BitSet128",
+    "BombSubType",
+    "BombVariant",
+    "ButtonAction",
+    "CacheFlag",
+    "Card",
+    "Challenge",
+    "ChampionColor",
+    "ChestSubType",
+    "CoinSubType",
+    "CollectibleType",
+    "Color",
+    "CppContainer",
+    "DamageFlag",
+    "Difficulty",
+    "Direction",
+    "DoorSlot",
+    "DoorState",
+    "DoorVariant",
+    "EffectVariant",
+    "Entity",
+    "EntityBomb",
+    "EntityCollisionClass",
+    "EntityEffect",
+    "EntityFamiliar",
+    "EntityFlag",
+    "EntityGridCollisionClass",
+    "EntityKnife",
+    "EntityLaser",
+    "EntityNPC",
+    "EntityPartition",
+    "EntityPickup",
+    "EntityPlayer",
+    "EntityProjectile",
+    "EntityPtr",
+    "EntityRef",
+    "EntityTear",
+    "EntityType",
+    "FamiliarVariant",
+    "Font",
+    "Game",
+    "GameStateFlag",
+    "GetPtrHash",
+    "GridCollisionClass",
+    "GridEntity",
+    "GridEntityDesc",
+    "GridEntityDoor",
+    "GridEntityPit",
+    "GridEntityPoop",
+    "GridEntityPressurePlate",
+    "GridEntityRock",
+    "GridEntitySpikes",
+    "GridEntityTNT",
+    "GridEntityType",
+    "GridRooms",
+    "HUD",
+    "HeartSubType",
+    "Input",
+    "InputHook",
+    "Isaac",
+    "ItemConfig",
+    "ItemPool",
+    "ItemPoolType",
+    "ItemType",
+    "KColor",
+    "KeySubType",
+    "Keyboard",
+    "LaserOffset",
+    "LaserSubType",
+    "Level",
+    "LevelCurse",
+    "LevelStage",
+    "LevelStateFlag",
+    "LocustSubtypes",
+    "ModCallbacks",
+    "Mouse",
+    "Music",
+    "MusicManager",
+    "NpcState",
+    "NullItemID",
+    "Options",
+    "PathFinder",
+    "PickupPrice",
+    "PickupVariant",
+    "PillColor",
+    "PillEffect",
+    "PlayerForm",
+    "PlayerSpriteLayer",
+    "PlayerType",
+    "PlayerTypes",
+    "PoopPickupSubType",
+    "PoopSpellType",
+    "ProjectileFlags",
+    "ProjectileParams",
+    "ProjectileVariant",
+    "QueueItemData",
+    "REPENTANCE",
+    "RNG",
+    "Random",
+    "RandomVector",
+    "RegisterMod",
+    "RenderMode",
+    "Room",
+    "RoomConfig",
+    "RoomDescriptor",
+    "RoomShape",
+    "RoomTransitionAnim",
+    "RoomType",
+    "SFXManager",
+    "SackSubType",
+    "SeedEffect",
+    "Seeds",
+    "ShockwaveParams",
+    "SkinColor",
+    "SortingLayer",
+    "SoundEffect",
+    "Sprite",
+    "StageType",
+    "StartDebug",
+    "TearFlags",
+    "TearParams",
+    "TearVariant",
+    "TemporaryEffect",
+    "TemporaryEffects",
+    "TrinketType",
+    "UseFlag",
+    "Vector",
+    "WeaponType",
+    "_G",
+    "_VERSION",
+    "assert",
+    "collectgarbage",
+    "coroutine",
+    "dofile",
+    "error",
+    "getmetatable",
+    "include",
+    "ipairs",
+    "load",
+    "loadfile",
+    "math",
+    "next",
+    "pairs",
+    "pcall",
+    "print",
+    "rawequal",
+    "rawget",
+    "rawlen",
+    "rawset",
+    "require",
+    "select",
+    "setmetatable",
+    "string",
+    "table",
+    "tonumber",
+    "tostring",
+    "type",
+    "utf8",
+    "xpcall",
+]);
+const LUA_DEBUG_ADDED_GLOBALS = new Set([
+    "debug",
+    "io",
+    "os",
+    "package",
+]);
+const RACING_PLUS_SANDBOX_ADDED_GLOBALS = new Set([
+    "sandboxTraceback",
+    "sandboxGetTraceback",
+    "getParentFunctionDescription",
+]);
+/**
+ * Helper function to get a set containing all of the global variable names that are contained
+ * within the Isaac environment by default.
+ *
+ * Returns a slightly different set depending on whether the "--luadebug" flag is enabled or not.
+ */
+export function getDefaultGlobals() {
+    const defaultGlobals = copySet(DEFAULT_GLOBALS);
+    if (isLuaDebugEnabled()) {
+        addSetsToSet(defaultGlobals, LUA_DEBUG_ADDED_GLOBALS);
+    }
+    if (isRacingPlusSandboxEnabled()) {
+        addSetsToSet(defaultGlobals, RACING_PLUS_SANDBOX_ADDED_GLOBALS);
+    }
+    return defaultGlobals;
+}
+function isRacingPlusSandboxEnabled() {
+    return getParentFunctionDescription !== undefined;
+}
+/**
+ * Helper function to get an array of any added global variables in the Isaac Lua environment.
+ * Returns a sorted array of key/value tuples.
+ */
+export function getNewGlobals() {
+    const defaultGlobals = getDefaultGlobals();
+    const newGlobals = [];
+    for (const [key, value] of pairs(_G)) {
+        if (!defaultGlobals.has(key)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const keyValueTuple = [key, value];
+            newGlobals.push(keyValueTuple);
+        }
+    }
+    newGlobals.sort(twoDimensionalSort);
+    return newGlobals;
+}
+export function logNewGlobals() {
+    const newGlobals = getNewGlobals();
+    log("List of added global variables in the Isaac environment:");
+    if (newGlobals.length === 0) {
+        log("- n/a (no extra global variables found)");
+    }
+    newGlobals.forEach(([key, value], i) => {
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        log(`${i + 1}) ${key} - ${value}`);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL2dsb2JhbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzVDLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxPQUFPLENBQUM7QUFDNUIsT0FBTyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsTUFBTSxPQUFPLENBQUM7QUFDOUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBRTdDLE1BQU0sZUFBZSxHQUF3QixJQUFJLEdBQUcsQ0FBQztJQUNuRCxnQkFBZ0I7SUFDaEIsWUFBWTtJQUNaLGFBQWE7SUFDYixjQUFjO0lBQ2QsZ0JBQWdCO0lBQ2hCLFlBQVk7SUFDWixXQUFXO0lBQ1gsYUFBYTtJQUNiLGFBQWE7SUFDYixjQUFjO0lBQ2QsV0FBVztJQUNYLE1BQU07SUFDTixXQUFXO0lBQ1gsZUFBZTtJQUNmLGNBQWM7SUFDZCxhQUFhO0lBQ2IsaUJBQWlCO0lBQ2pCLE9BQU87SUFDUCxjQUFjO0lBQ2QsWUFBWTtJQUNaLFlBQVk7SUFDWixXQUFXO0lBQ1gsVUFBVTtJQUNWLFdBQVc7SUFDWCxhQUFhO0lBQ2IsZUFBZTtJQUNmLFFBQVE7SUFDUixZQUFZO0lBQ1osc0JBQXNCO0lBQ3RCLGNBQWM7SUFDZCxnQkFBZ0I7SUFDaEIsWUFBWTtJQUNaLDBCQUEwQjtJQUMxQixhQUFhO0lBQ2IsYUFBYTtJQUNiLFdBQVc7SUFDWCxpQkFBaUI7SUFDakIsY0FBYztJQUNkLGNBQWM7SUFDZCxrQkFBa0I7SUFDbEIsV0FBVztJQUNYLFdBQVc7SUFDWCxZQUFZO0lBQ1osWUFBWTtJQUNaLGlCQUFpQjtJQUNqQixNQUFNO0lBQ04sTUFBTTtJQUNOLGVBQWU7SUFDZixZQUFZO0lBQ1osb0JBQW9CO0lBQ3BCLFlBQVk7SUFDWixnQkFBZ0I7SUFDaEIsZ0JBQWdCO0lBQ2hCLGVBQWU7SUFDZixnQkFBZ0I7SUFDaEIseUJBQXlCO0lBQ3pCLGdCQUFnQjtJQUNoQixrQkFBa0I7SUFDbEIsZUFBZTtJQUNmLGdCQUFnQjtJQUNoQixXQUFXO0lBQ1gsS0FBSztJQUNMLGNBQWM7SUFDZCxPQUFPO0lBQ1AsV0FBVztJQUNYLE9BQU87SUFDUCxZQUFZO0lBQ1osVUFBVTtJQUNWLGNBQWM7SUFDZCxVQUFVO0lBQ1YsUUFBUTtJQUNSLFlBQVk7SUFDWixVQUFVO0lBQ1YsYUFBYTtJQUNiLGNBQWM7SUFDZCxPQUFPO0lBQ1AsWUFBWTtJQUNaLFlBQVk7SUFDWixnQkFBZ0I7SUFDaEIsZ0JBQWdCO0lBQ2hCLGNBQWM7SUFDZCxPQUFPO0lBQ1AsT0FBTztJQUNQLGNBQWM7SUFDZCxVQUFVO0lBQ1YsWUFBWTtJQUNaLFNBQVM7SUFDVCxZQUFZO0lBQ1osYUFBYTtJQUNiLGVBQWU7SUFDZixXQUFXO0lBQ1gsWUFBWTtJQUNaLFlBQVk7SUFDWixtQkFBbUI7SUFDbkIsWUFBWTtJQUNaLGFBQWE7SUFDYixtQkFBbUI7SUFDbkIsZUFBZTtJQUNmLGlCQUFpQjtJQUNqQixrQkFBa0I7SUFDbEIsbUJBQW1CO0lBQ25CLGVBQWU7SUFDZixZQUFZO0lBQ1osS0FBSztJQUNMLFFBQVE7SUFDUixjQUFjO0lBQ2QsYUFBYTtJQUNiLFlBQVk7SUFDWixNQUFNO0lBQ04sWUFBWTtJQUNaLGdCQUFnQjtJQUNoQixXQUFXO0lBQ1gsb0JBQW9CO0lBQ3BCLFVBQVU7SUFDVixZQUFZO0lBQ1osYUFBYTtJQUNiLFlBQVk7SUFDWixPQUFPO0lBQ1AsaUJBQWlCO0lBQ2pCLFdBQVc7SUFDWCxjQUFjO0lBQ2QsYUFBYTtJQUNiLFFBQVE7SUFDUixXQUFXO0lBQ1gsWUFBWTtJQUNaLFdBQVc7SUFDWCxZQUFZO0lBQ1osYUFBYTtJQUNiLGlCQUFpQjtJQUNqQixrQkFBa0I7SUFDbEIsYUFBYTtJQUNiLFNBQVM7SUFDVCxRQUFRO0lBQ1IsWUFBWTtJQUNaLElBQUk7SUFDSixVQUFVO0lBQ1YsUUFBUTtJQUNSLGdCQUFnQjtJQUNoQixXQUFXO0lBQ1gsUUFBUTtJQUNSLE9BQU87SUFDUCxjQUFjO0lBQ2QsU0FBUztJQUNULFFBQVE7SUFDUixNQUFNO0lBQ04sVUFBVTtJQUNWLE1BQU07SUFDTixNQUFNO0lBQ04sT0FBTztJQUNQLE9BQU87SUFDUCxPQUFPO0lBQ1AsVUFBVTtJQUNWLFFBQVE7SUFDUixRQUFRO0lBQ1IsUUFBUTtJQUNSLFNBQVM7SUFDVCxRQUFRO0lBQ1IsY0FBYztJQUNkLFFBQVE7SUFDUixPQUFPO0lBQ1AsVUFBVTtJQUNWLFVBQVU7SUFDVixNQUFNO0lBQ04sTUFBTTtJQUNOLFFBQVE7Q0FDVCxDQUFDLENBQUM7QUFFSCxNQUFNLHVCQUF1QixHQUF3QixJQUFJLEdBQUcsQ0FBQztJQUMzRCxPQUFPO0lBQ1AsSUFBSTtJQUNKLElBQUk7SUFDSixTQUFTO0NBQ1YsQ0FBQyxDQUFDO0FBRUgsTUFBTSxpQ0FBaUMsR0FBd0IsSUFBSSxHQUFHLENBQUM7SUFDckUsa0JBQWtCO0lBQ2xCLHFCQUFxQjtJQUNyQiw4QkFBOEI7Q0FDL0IsQ0FBQyxDQUFDO0FBRUg7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsaUJBQWlCO0lBQy9CLE1BQU0sY0FBYyxHQUFHLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUVoRCxJQUFJLGlCQUFpQixFQUFFLEVBQUU7UUFDdkIsWUFBWSxDQUFDLGNBQWMsRUFBRSx1QkFBdUIsQ0FBQyxDQUFDO0tBQ3ZEO0lBRUQsSUFBSSwwQkFBMEIsRUFBRSxFQUFFO1FBQ2hDLFlBQVksQ0FBQyxjQUFjLEVBQUUsaUNBQWlDLENBQUMsQ0FBQztLQUNqRTtJQUVELE9BQU8sY0FBYyxDQUFDO0FBQ3hCLENBQUM7QUFFRCxTQUFTLDBCQUEwQjtJQUNqQyxPQUFPLDRCQUE0QixLQUFLLFNBQVMsQ0FBQztBQUNwRCxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLGFBQWE7SUFDM0IsTUFBTSxjQUFjLEdBQUcsaUJBQWlCLEVBQUUsQ0FBQztJQUMzQyxNQUFNLFVBQVUsR0FBZ0MsRUFBRSxDQUFDO0lBQ25ELEtBQUssTUFBTSxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsRUFBRSxDQUFDLEVBQUU7UUFDcEMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDNUIsOERBQThEO1lBQzlELE1BQU0sYUFBYSxHQUF5QixDQUFDLEdBQUcsRUFBRSxLQUFZLENBQUMsQ0FBQztZQUNoRSxVQUFVLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1NBQ2hDO0tBQ0Y7SUFFRCxVQUFVLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFFcEMsT0FBTyxVQUFVLENBQUM7QUFDcEIsQ0FBQztBQUVELE1BQU0sVUFBVSxhQUFhO0lBQzNCLE1BQU0sVUFBVSxHQUFHLGFBQWEsRUFBRSxDQUFDO0lBRW5DLEdBQUcsQ0FBQywwREFBMEQsQ0FBQyxDQUFDO0lBQ2hFLElBQUksVUFBVSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7UUFDM0IsR0FBRyxDQUFDLHlDQUF5QyxDQUFDLENBQUM7S0FDaEQ7SUFDRCxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUU7UUFDckMsZ0VBQWdFO1FBQ2hFLEdBQUcsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEtBQUssR0FBRyxNQUFNLEtBQUssRUFBRSxDQUFDLENBQUM7SUFDckMsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDIn0=