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

package/functions/entitySpecific.js

@@ -0,0 +1,481 @@
+import { EntityType, } from "isaac-typescript-definitions";
+import { VectorZero } from "../constants";
+import { getEntities, getFilteredNewEntities, removeEntities, spawn, } from "./entity";
+/**
+ * Helper function to get all of the `EntityType.BOMB` in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the bombs in the room invisible
+ * for (const bomb of getBombs()) {
+ *   bomb.Visible = false;
+ * }
+ * ```
+ */
+export function getBombs(bombVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.BOMB, bombVariant, subType);
+    const bombs = [];
+    for (const entity of entities) {
+        const bomb = entity.ToBomb();
+        if (bomb !== undefined) {
+            bombs.push(bomb);
+        }
+    }
+    return bombs;
+}
+/**
+ * Helper function to get all of the `EntityType.EFFECT` in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the effects in the room invisible
+ * for (const effect of getEffects()) {
+ *   effect.Visible = false;
+ * }
+ * ```
+ */
+export function getEffects(effectVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.EFFECT, effectVariant, subType);
+    const effects = [];
+    for (const entity of entities) {
+        const effect = entity.ToEffect();
+        if (effect !== undefined) {
+            effects.push(effect);
+        }
+    }
+    return effects;
+}
+/**
+ * Helper function to get all of the familiars in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the familiars in the room invisible
+ * for (const familiar of getFamiliars()) {
+ *   familiar.Visible = false;
+ * }
+ * ```
+ */
+export function getFamiliars(familiarVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.FAMILIAR, familiarVariant, subType);
+    const familiars = [];
+    for (const entity of entities) {
+        const familiar = entity.ToFamiliar();
+        if (familiar !== undefined) {
+            familiars.push(familiar);
+        }
+    }
+    return familiars;
+}
+/**
+ * Helper function to get all of the `EntityType.KNIFE` in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the knives in the room invisible
+ * for (const knife of getKnives()) {
+ *   knife.Visible = false;
+ * }
+ * ```
+ */
+export function getKnives(knifeVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.KNIFE, knifeVariant, subType);
+    const knives = [];
+    for (const entity of entities) {
+        const knife = entity.ToKnife();
+        if (knife !== undefined) {
+            knives.push(knife);
+        }
+    }
+    return knives;
+}
+/**
+ * Helper function to get all of the `EntityType.LASER` in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the lasers in the room invisible
+ * for (const laser of getLasers()) {
+ *   laser.Visible = false;
+ * }
+ * ```
+ */
+export function getLasers(laserVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.LASER, laserVariant, subType);
+    const lasers = [];
+    for (const entity of entities) {
+        const laser = entity.ToLaser();
+        if (laser !== undefined) {
+            lasers.push(laser);
+        }
+    }
+    return lasers;
+}
+/** The same thing as the `getEntities` function, but returns only NPCs. */
+export function getNPCs(entityType, variant, subType, ignoreFriendly = false) {
+    const entities = getEntities(entityType, variant, subType, ignoreFriendly);
+    const npcs = [];
+    for (const entity of entities) {
+        const npc = entity.ToNPC();
+        if (npc !== undefined) {
+            npcs.push(npc);
+        }
+    }
+    return npcs;
+}
+/**
+ * Helper function to get all of the pickups in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the pickups in the room invisible
+ * for (const pickup of getPickups()) {
+ *   pickup.Visible = false;
+ * }
+ * ```
+ */
+export function getPickups(pickupVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.PICKUP, pickupVariant, subType);
+    const pickups = [];
+    for (const entity of entities) {
+        const pickup = entity.ToPickup();
+        if (pickup !== undefined) {
+            pickups.push(pickup);
+        }
+    }
+    return pickups;
+}
+/**
+ * Helper function to get all of the `EntityType.PROJECTILE` in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the projectiles in the room invisible
+ * for (const projectile of getProjectiles()) {
+ *   projectile.Visible = false;
+ * }
+ * ```
+ */
+export function getProjectiles(projectileVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.PROJECTILE, projectileVariant, subType);
+    const projectiles = [];
+    for (const entity of entities) {
+        const projectile = entity.ToProjectile();
+        if (projectile !== undefined) {
+            projectiles.push(projectile);
+        }
+    }
+    return projectiles;
+}
+/**
+ * Helper function to get all of the `EntityType.SLOT` in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the slots in the room invisible
+ * for (const slot of getSlots()) {
+ *   slot.Visible = false;
+ * }
+ * ```
+ */
+export function getSlots(slotVariant = -1, subType = -1) {
+    const slots = getEntities(EntityType.SLOT, slotVariant, subType);
+    return slots;
+}
+/**
+ * Helper function to get all of the `EntityType.TEAR` in the room.
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the tears in the room invisible
+ * for (const tear of getTears()) {
+ *   tear.Visible = false;
+ * }
+ * ```
+ */
+export function getTears(tearVariant = -1, subType = -1) {
+    const entities = getEntities(EntityType.TEAR, tearVariant, subType);
+    const tears = [];
+    for (const entity of entities) {
+        const tear = entity.ToTear();
+        if (tear !== undefined) {
+            tears.push(tear);
+        }
+    }
+    return tears;
+}
+/**
+ * The base game `EntityNPC.FireProjectiles` method does not return anything, which is a problem in
+ * situations where you need to work with the fired projectiles. This function invokes that method,
+ * and then returns the projectiles that were spawned.
+ *
+ * @param npc The EntityNPC firing projectiles.
+ * @param position The starting position of the projectiles.
+ * @param velocity The starting velocity of the projectiles.
+ * @param projectilesMode A ProjectilesMode enum value defining how to fire the projectiles.
+ * @param projectileParams A ProjectileParams object containing various parameters for the
+ *                         projectiles.
+ * @returns An array of EntityProjectiles containing all fired projectiles.
+ */
+export function npcFireProjectiles(npc, position, velocity, projectilesMode, projectileParams) {
+    const oldEntities = getProjectiles();
+    npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
+    const newEntities = getProjectiles();
+    const filteredNewEntities = getFilteredNewEntities(oldEntities, newEntities);
+    return filteredNewEntities;
+}
+/**
+ * Helper function to remove all of the `EntityType.BOMB` in the room.
+ *
+ * @param bombVariant Optional. If specified, will only remove bombs that match this variant.
+ * @param subType Optional. If specified, will only remove bombs that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of bombs.
+ * @returns An array of the bombs that were removed.
+ */
+export function removeAllBombs(bombVariant, subType, cap) {
+    const bombs = getBombs(bombVariant, subType);
+    return removeEntities(bombs, cap);
+}
+/**
+ * Helper function to remove all of the effects in the room.
+ *
+ * @param effectVariant Optional. If specified, will only remove effects that match this variant.
+ * @param subType Optional. If specified, will only remove effects that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of effects.
+ * @returns An array of the effects that were removed.
+ */
+export function removeAllEffects(effectVariant, subType, cap) {
+    const effects = getEffects(effectVariant, subType);
+    return removeEntities(effects, cap);
+}
+/**
+ * Helper function to remove all of the familiars in the room.
+ *
+ * @param familiarVariant Optional. If specified, will only remove familiars that match this
+ *                        variant.
+ * @param subType Optional. If specified, will only remove familiars that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of familiars.
+ * @returns An array of the familiars that were removed.
+ */
+export function removeAllFamiliars(familiarVariant, subType, cap) {
+    const familiars = getFamiliars(familiarVariant, subType);
+    return removeEntities(familiars, cap);
+}
+/**
+ * Helper function to remove all of the `EntityType.KNIFE` in the room.
+ *
+ * @param knifeVariant Optional. If specified, will only remove knives that match this variant.
+ * @param subType Optional. If specified, will only remove knives that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of knives.
+ * @returns An array of the knives that were removed.
+ */
+export function removeAllKnives(knifeVariant, subType, cap) {
+    const knives = getKnives(knifeVariant, subType);
+    return removeEntities(knives, cap);
+}
+/**
+ * Helper function to remove all of the `EntityType.LASER` in the room.
+ *
+ * @param laserVariant Optional. If specified, will only remove lasers that match this variant.
+ * @param subType Optional. If specified, will only remove lasers that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of lasers.
+ * @returns An array of the lasers that were removed.
+ */
+export function removeAllLasers(laserVariant, subType, cap) {
+    const lasers = getLasers(laserVariant, subType);
+    return removeEntities(lasers, cap);
+}
+/**
+ * Helper function to remove all NPCs in the room.
+ *
+ * @param cap Optional. If specified, will only remove the given amount of NPCs.
+ * @returns An array of the NPCs that were removed.
+ */
+export function removeAllNPCs(cap) {
+    const npcs = getNPCs();
+    return removeEntities(npcs, cap);
+}
+/**
+ * Helper function to remove all of the pickups in the room.
+ *
+ * @param pickupVariant Optional. If specified, will only remove pickups that match this variant.
+ * @param subType Optional. If specified, will only remove pickups that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of pickups.
+ * @returns An array of the pickups that were removed.
+ */
+export function removeAllPickups(pickupVariant, subType, cap) {
+    const pickups = getPickups(pickupVariant, subType);
+    return removeEntities(pickups, cap);
+}
+/**
+ * Helper function to remove all of the `EntityType.PROJECTILE` in the room.
+ *
+ * @param projectileVariant Optional. If specified, will only remove projectiles that match this
+ *                          variant.
+ * @param subType Optional. If specified, will only remove projectiles that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of projectiles.
+ * @returns An array of the projectiles that were removed.
+ */
+export function removeAllProjectiles(projectileVariant, subType, cap) {
+    const projectiles = getProjectiles(projectileVariant, subType);
+    return removeEntities(projectiles, cap);
+}
+/**
+ * Helper function to remove all of the `EntityType.SLOT` in the room.
+ *
+ * @param slotVariant Optional. If specified, will only remove slots that match this variant.
+ * @param subType Optional. If specified, will only remove slots that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of slots.
+ * @returns An array of the slots that were removed.
+ */
+export function removeAllSlots(slotVariant, subType, cap) {
+    const slots = getSlots(slotVariant, subType);
+    return removeEntities(slots, cap);
+}
+/**
+ * Helper function to remove all of the `EntityType.TEAR` in the room.
+ *
+ * @param tearVariant Optional. If specified, will only remove tears that match this variant.
+ * @param subType Optional. If specified, will only remove tears that match this sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of tears.
+ * @returns An array of the tears that were removed.
+ */
+export function removeAllTears(tearVariant, subType, cap) {
+    const tears = getTears(tearVariant, subType);
+    return removeEntities(tears, cap);
+}
+/** Helper function to spawn a `EntityType.BOMB` (4). */
+export function spawnBomb(bombVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.BOMB, bombVariant, subType, position, velocity, spawner, seedOrRNG);
+    const bomb = entity.ToBomb();
+    if (bomb === undefined) {
+        error("Failed to spawn a bomb.");
+    }
+    return bomb;
+}
+/** Helper function to spawn a `EntityType.BOMB` (4) with a specific seed. */
+export function spawnBombWithSeed(bombVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnBomb(bombVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.EFFECT` (1000). */
+export function spawnEffect(effectVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.EFFECT, effectVariant, subType, position, velocity, spawner, seedOrRNG);
+    const effect = entity.ToEffect();
+    if (effect === undefined) {
+        error("Failed to spawn an effect.");
+    }
+    return effect;
+}
+/** Helper function to spawn a `EntityType.EFFECT` (1000) with a specific seed. */
+export function spawnEffectWithSeed(effectVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnEffect(effectVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.FAMILIAR` (3). */
+export function spawnFamiliar(familiarVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.FAMILIAR, familiarVariant, subType, position, velocity, spawner, seedOrRNG);
+    const familiar = entity.ToFamiliar();
+    if (familiar === undefined) {
+        error("Failed to spawn a familiar.");
+    }
+    return familiar;
+}
+/** Helper function to spawn a `EntityType.FAMILIAR` (3) with a specific seed. */
+export function spawnFamiliarWithSeed(familiarVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnFamiliar(familiarVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.KNIFE` (8). */
+export function spawnKnife(knifeVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.KNIFE, knifeVariant, subType, position, velocity, spawner, seedOrRNG);
+    const knife = entity.ToKnife();
+    if (knife === undefined) {
+        error("Failed to spawn a knife.");
+    }
+    return knife;
+}
+/** Helper function to spawn a `EntityType.KNIFE` (8) with a specific seed. */
+export function spawnKnifeWithSeed(knifeVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnKnife(knifeVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.LASER` (7). */
+export function spawnLaser(laserVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.LASER, laserVariant, subType, position, velocity, spawner, seedOrRNG);
+    const laser = entity.ToLaser();
+    if (laser === undefined) {
+        error("Failed to spawn a laser.");
+    }
+    return laser;
+}
+/** Helper function to spawn a `EntityType.LASER` (7) with a specific seed. */
+export function spawnLaserWithSeed(laserVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnLaser(laserVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn an NPC. */
+export function spawnNPC(entityType, variant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(entityType, variant, subType, position, velocity, spawner, seedOrRNG);
+    const npc = entity.ToNPC();
+    if (npc === undefined) {
+        error("Failed to spawn an NPC.");
+    }
+    return npc;
+}
+/** Helper function to spawn an NPC with a specific seed. */
+export function spawnNPCWithSeed(entityType, variant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnNPC(entityType, variant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.PICKUP` (5). */
+export function spawnPickup(pickupVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.PICKUP, pickupVariant, subType, position, velocity, spawner, seedOrRNG);
+    const pickup = entity.ToPickup();
+    if (pickup === undefined) {
+        error("Failed to spawn a pickup.");
+    }
+    return pickup;
+}
+/** Helper function to spawn a `EntityType.PICKUP` (5) with a specific seed. */
+export function spawnPickupWithSeed(pickupVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnPickup(pickupVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.PROJECTILE` (9). */
+export function spawnProjectile(projectileVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.PROJECTILE, projectileVariant, subType, position, velocity, spawner, seedOrRNG);
+    const projectile = entity.ToProjectile();
+    if (projectile === undefined) {
+        error("Failed to spawn a projectile.");
+    }
+    return projectile;
+}
+/** Helper function to spawn a `EntityType.PROJECTILE` (9) with a specific seed. */
+export function spawnProjectileWithSeed(projectileVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnProjectile(projectileVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.SLOT` (6). */
+export function spawnSlot(slotVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    return spawn(EntityType.SLOT, slotVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.SLOT` (6) with a specific seed. */
+export function spawnSlotWithSeed(slotVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnSlot(slotVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+/** Helper function to spawn a `EntityType.TEAR` (2). */
+export function spawnTear(tearVariant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    const entity = spawn(EntityType.TEAR, tearVariant, subType, position, velocity, spawner, seedOrRNG);
+    const tear = entity.ToTear();
+    if (tear === undefined) {
+        error("Failed to spawn a tear.");
+    }
+    return tear;
+}
+/** Helper function to spawn a `EntityType.EntityType` (2) with a specific seed. */
+export function spawnTearWithSeed(tearVariant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawnTear(tearVariant, subType, position, velocity, spawner, seedOrRNG);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entitySpecific.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/functions/entitySpecific.ts"],"names":[],"mappings":"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"}

package/functions/entityTypes.js

@@ -0,0 +1,6 @@
+import { EntityType } from "isaac-typescript-definitions";
+/** For `EntityType.SLOT` (6) */
+export function isSlot(entity) {
+    return entity.Type === EntityType.SLOT;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5VHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2Z1bmN0aW9ucy9lbnRpdHlUeXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFMUQsZ0NBQWdDO0FBQ2hDLE1BQU0sVUFBVSxNQUFNLENBQUMsTUFBYztJQUNuQyxPQUFPLE1BQU0sQ0FBQyxJQUFJLEtBQUssVUFBVSxDQUFDLElBQUksQ0FBQztBQUN6QyxDQUFDIn0=

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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