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

package/functions/entity.js

@@ -0,0 +1,324 @@
+import { game } from "../cachedClasses";
+import { VectorZero } from "../constants";
+import { STORY_BOSSES_SET } from "../sets/storyBossesSet";
+import { getIsaacAPIClassName } from "./isaacAPIClass";
+import { getRandom } from "./random";
+import { isRNG, newRNG } from "./rng";
+import { isPrimitive } from "./types";
+/**
+ * Helper function to count the number of entities in room. Use this over the vanilla
+ * `Isaac.CountEntities` method to avoid having to specify a spawner and to handle ignoring charmed
+ * enemies.
+ *
+ * @param entityType Default is -1. -1 matches every entity type.
+ * @param variant Default is -1. -1 matches every variant.
+ * @param subType Default is -1. -1 matches every sub-type.
+ * @param ignoreFriendly Default is false.
+ */
+export function countEntities(entityType = -1, variant = -1, subType = -1, ignoreFriendly = false) {
+    if (!ignoreFriendly) {
+        return Isaac.CountEntities(undefined, entityType, variant, subType);
+    }
+    const entities = Isaac.FindByType(entityType, variant, subType, false, ignoreFriendly);
+    return entities.length;
+}
+/**
+ * Helper function to check if one or more of a specific kind of entity is present in the current
+ * room. It uses the `countEntities` helper function to determine this.
+ *
+ * @param entityType Default is -1. -1 matches every entity type.
+ * @param variant Default is -1. -1 matches every variant.
+ * @param subType Default is -1. -1 matches every sub-type.
+ * @param ignoreFriendly Default is false.
+ */
+export function doesEntityExist(entityType = -1, variant = -1, subType = -1, ignoreFriendly = false) {
+    const count = countEntities(entityType, variant, subType, ignoreFriendly);
+    return count > 0;
+}
+/**
+ * Given an array of entities, this helper function returns the closest one to a provided reference
+ * entity.
+ *
+ * For example:
+ *
+ * ```ts
+ * const player = Isaac.GetPlayer();
+ * const gapers = getEntities(EntityType.GAPER);
+ * const closestGaper = getClosestEntityTo(player, gapers);
+ * ```
+ */
+export function getClosestEntityTo(referenceEntity, entities) {
+    let closestEntity;
+    let closestDistance = math.huge;
+    for (const entity of entities) {
+        const distance = referenceEntity.Position.Distance(entity.Position);
+        if (distance < closestDistance) {
+            closestEntity = entity;
+            closestDistance = distance;
+        }
+    }
+    return closestEntity;
+}
+/**
+ * Helper function to get all of the entities in the room or all of the entities that match a
+ * specific entity type / variant / sub-type.
+ *
+ * Due to bugs with `Isaac.FindInRadius`, this function uses `Isaac.GetRoomEntities`, which is more
+ * expensive but also more robust. (If a matching entity type is provided, then `Isaac.FindByType`
+ * will be used instead.)
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the entities in the room invisible
+ * for (const entity of getEntities()) {
+ *   entity.Visible = false;
+ * }
+ * ```
+ *
+ * @param entityType Optional. If specified, will only return NPCs that match this entity type.
+ * @param variant Optional. If specified, will only return NPCs that match this variant. Default is
+ *                -1. -1 matches every variant.
+ * @param subType Optional. If specified, will only return NPCs that match this sub-type. Default is
+ *                -1. -1 matches every sub-type.
+ * @param ignoreFriendly Optional. If set to true, it will exclude friendly NPCs from being
+ *                       returned. Default is false. Will only be taken into account if
+ *                       `matchingEntityType` is specified.
+ */
+export function getEntities(entityType, variant = -1, subType = -1, ignoreFriendly = false) {
+    if (entityType === undefined) {
+        return Isaac.GetRoomEntities();
+    }
+    return Isaac.FindByType(entityType, variant, subType, ignoreFriendly);
+}
+/**
+ * Helper function to get all the fields on an entity. For example, this is useful for comparing it
+ * to another entity later.
+ *
+ * This function will only get fields that are equal to booleans, numbers, or strings, as comparing
+ * other types is non-trivial.
+ */
+export function getEntityFields(entity) {
+    const entityFields = new LuaTable();
+    const metatable = getmetatable(entity);
+    if (metatable === undefined) {
+        error("Failed to get the metatable for an entity.");
+    }
+    setPrimitiveEntityFields(entity, metatable, entityFields);
+    // If this is a class that inherits from `Entity` (like `EntityPlayer`), the "__propget" table
+    // will not contain the attributes for `Entity`. Thus, if this is not an `Entity`, we have
+    // additional fields to add.
+    const className = getIsaacAPIClassName(entity);
+    if (className === "Entity") {
+        return entityFields;
+    }
+    const parentTable = metatable.get("__parent");
+    if (parentTable === undefined) {
+        error('Failed to get the "__parent" table for an entity.');
+    }
+    setPrimitiveEntityFields(entity, parentTable, entityFields);
+    return entityFields;
+}
+function setPrimitiveEntityFields(entity, metatable, entityFields) {
+    const propGetTable = metatable.get("__propget");
+    if (propGetTable === undefined) {
+        error('Failed to get the "__propget" table for an entity.');
+    }
+    for (const [key] of pairs(propGetTable)) {
+        // The values of this table are functions. Thus, we use the key to index the original entity.
+        const indexKey = key;
+        const value = entity[indexKey];
+        if (isPrimitive(value)) {
+            entityFields.set(indexKey, value);
+        }
+    }
+}
+/** Helper function to return a string containing the entity's type, variant, and sub-type. */
+export function getEntityID(entity) {
+    return `${entity.Type}.${entity.Variant}.${entity.SubType}`;
+}
+/**
+ * Helper function to return a formatted string in the format returned by the `getEntityID`
+ * function.
+ */
+export function getEntityIDFromConstituents(entityType, variant, subType) {
+    return `${entityType}.${variant}.${subType}`;
+}
+/**
+ * Helper function to compare two different arrays of entities. Returns the entities that are in the
+ * second array but not in the first array.
+ */
+export function getFilteredNewEntities(oldEntities, newEntities) {
+    const oldEntitiesSet = new Set();
+    for (const entity of oldEntities) {
+        const ptrHash = GetPtrHash(entity);
+        oldEntitiesSet.add(ptrHash);
+    }
+    return newEntities.filter((entity) => {
+        const ptrHash = GetPtrHash(entity);
+        return !oldEntitiesSet.has(ptrHash);
+    });
+}
+/**
+ * Helper function to measure an entity's velocity to see if it is moving.
+ *
+ * @param entity The entity whose velocity to measure.
+ * @param threshold Optional. The threshold from 0 to consider to be moving. Default is 0.01.
+ */
+export function isEntityMoving(entity, threshold = 0.01) {
+    return entity.Velocity.Length() >= threshold;
+}
+/**
+ * Helper function to determine if the specified entity type is an end-game story boss, like Isaac,
+ * Blue Baby, Mega Satan, The Beast, and so on. This is useful because certain effects should only
+ * apply to non-story bosses, like Vanishing Twin. Also see the `STORY_BOSSES` constant.
+ */
+export function isStoryBoss(entityType) {
+    return STORY_BOSSES_SET.has(entityType);
+}
+/**
+ * Helper function to parse a string that contains an entity type, a variant, and a sub-type,
+ * separated by periods.
+ *
+ * For example, passing "45.0.1" would return an array of [45, 0, 1].
+ *
+ * Returns undefined if the string cannot be parsed.
+ */
+export function parseEntityID(entityID) {
+    const entityIDArray = entityID.split(".");
+    if (entityIDArray.length !== 3) {
+        return undefined;
+    }
+    const [entityTypeString, variantString, subTypeString] = entityIDArray;
+    const entityType = tonumber(entityTypeString);
+    if (entityType === undefined) {
+        return undefined;
+    }
+    const variant = tonumber(variantString);
+    if (variant === undefined) {
+        return undefined;
+    }
+    const subType = tonumber(subTypeString);
+    if (subType === undefined) {
+        return undefined;
+    }
+    return [entityType, variant, subType];
+}
+/**
+ * Helper function to parse a string that contains an entity type and a variant separated by a
+ * period.
+ *
+ * For example, passing "45.0" would return an array of [45, 0].
+ *
+ * Returns undefined if the string cannot be parsed.
+ */
+export function parseEntityTypeVariantString(entityTypeVariantString) {
+    const entityTypeVariantArray = entityTypeVariantString.split(".");
+    if (entityTypeVariantArray.length !== 2) {
+        return undefined;
+    }
+    const [entityTypeString, variantString] = entityTypeVariantArray;
+    const entityType = tonumber(entityTypeString);
+    if (entityType === undefined) {
+        return undefined;
+    }
+    const variant = tonumber(variantString);
+    if (variant === undefined) {
+        return undefined;
+    }
+    return [entityType, variant];
+}
+/**
+ * Helper function to remove all of the matching entities in the room.
+ *
+ * @param entityType The entity type to match.
+ * @param entityVariant Optional. The variant to match. Default is -1. -1 matches every variant.
+ * @param entitySubType Optional. The sub-type to match. Default is -1. -1 matches every sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of collectibles.
+ * @returns An array of the entities that were removed.
+ */
+export function removeAllMatchingEntities(entityType, entityVariant = -1, entitySubType = -1, cap = undefined) {
+    const entities = getEntities(entityType, entityVariant, entitySubType);
+    return removeEntities(entities, cap);
+}
+/**
+ * Helper function to remove all of the entities in the supplied array.
+ *
+ * @param entities The array of entities to remove.
+ * @param cap Optional. If specified, will only remove the given amount of entities.
+ * @returns An array of the entities that were removed.
+ */
+export function removeEntities(entities, cap) {
+    if (entities.length === 0) {
+        return [];
+    }
+    const entitiesRemoved = [];
+    for (const entity of entities) {
+        entity.Remove();
+        entitiesRemoved.push(entity);
+        if (cap !== undefined && entitiesRemoved.length >= cap) {
+            return entitiesRemoved;
+        }
+    }
+    return entitiesRemoved;
+}
+/**
+ * Helper function to reroll an enemy. Use this instead of the vanilla "Game.RerollEnemy" function
+ * if you want the rerolled enemy to be returned.
+ *
+ * @param entity The entity to reroll.
+ * @returns If the game failed to reroll the enemy, returns undefined. Otherwise, returns the
+ *          rerolled entity.
+ */
+export function rerollEnemy(entity) {
+    const oldEntities = getEntities();
+    const wasRerolled = game.RerollEnemy(entity);
+    if (!wasRerolled) {
+        return undefined;
+    }
+    const newEntities = getEntities();
+    const filteredNewEntities = getFilteredNewEntities(oldEntities, newEntities);
+    if (filteredNewEntities.length === 0) {
+        error('Failed to find the new entity generated by the "Game.RerollEnemy" method.');
+    }
+    return filteredNewEntities[0];
+}
+export function setEntityRandomColor(entity) {
+    const rng = newRNG(entity.InitSeed);
+    const r = getRandom(rng);
+    const g = getRandom(rng);
+    const b = getRandom(rng);
+    const color = Color(r, g, b);
+    entity.SetColor(color, 100000, 100000, false, false);
+}
+/**
+ * Helper function to spawn an entity. Use this instead of the `Isaac.Spawn` method if you do not
+ * need to specify the velocity or spawner.
+ *
+ * Also see the `spawnWithSeed` helper function.
+ */
+export function spawn(entityType, variant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (position === undefined) {
+        const entityID = getEntityIDFromConstituents(entityType, variant, subType);
+        error(`Failed to spawn entity ${entityID} since an undefined position was passed to the "spawn" function.`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (velocity === undefined) {
+        const entityID = getEntityIDFromConstituents(entityType, variant, subType);
+        error(`Failed to spawn entity ${entityID} since an undefined velocity was passed to the "spawn" function.`);
+    }
+    if (seedOrRNG === undefined) {
+        return Isaac.Spawn(entityType, variant, subType, position, velocity, spawner);
+    }
+    const seed = isRNG(seedOrRNG) ? seedOrRNG.Next() : seedOrRNG;
+    return game.Spawn(entityType, variant, position, velocity, spawner, subType, seed);
+}
+/**
+ * Helper function to spawn an entity. Use this instead of the `Game.Spawn` method if you do not
+ * need to specify the velocity or spawner.
+ */
+export function spawnWithSeed(entityType, variant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined) {
+    return spawn(entityType, variant, subType, position, velocity, spawner, seedOrRNG);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/functions/entity.ts"],"names":[],"mappings":"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"}