isaacscript-common 2.3.0 → 2.3.1

package/functions/entitySpecific.d.ts

@@ -0,0 +1,264 @@
+import { BombVariant, EffectVariant, EntityType, FamiliarVariant, KnifeVariant, LaserVariant, PickupVariant, ProjectilesMode, ProjectileVariant, SlotVariant, TearVariant } from "isaac-typescript-definitions";
+/**
+ * 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 declare function getBombs(bombVariant?: BombVariant, subType?: number): EntityBomb[];
+/**
+ * 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 declare function getEffects(effectVariant?: EffectVariant, subType?: number): EntityEffect[];
+/**
+ * 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 declare function getFamiliars(familiarVariant?: FamiliarVariant, subType?: number): EntityFamiliar[];
+/**
+ * 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 declare function getKnives(knifeVariant?: KnifeVariant, subType?: number): EntityKnife[];
+/**
+ * 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 declare function getLasers(laserVariant?: LaserVariant, subType?: number): EntityLaser[];
+/** The same thing as the `getEntities` function, but returns only NPCs. */
+export declare function getNPCs(entityType?: EntityType, variant?: int, subType?: int, ignoreFriendly?: boolean): EntityNPC[];
+/**
+ * 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 declare function getPickups(pickupVariant?: PickupVariant, subType?: number): EntityPickup[];
+/**
+ * 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 declare function getProjectiles(projectileVariant?: ProjectileVariant, subType?: number): EntityProjectile[];
+/**
+ * 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 declare function getSlots(slotVariant?: SlotVariant, subType?: number): EntitySlot[];
+/**
+ * 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 declare function getTears(tearVariant?: TearVariant, subType?: number): EntityTear[];
+/**
+ * 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 declare function npcFireProjectiles(npc: EntityNPC, position: Vector, velocity: Vector, projectilesMode: ProjectilesMode, projectileParams: ProjectileParams): EntityProjectile[];
+/**
+ * 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 True if one or more bombs were removed, false otherwise.
+ */
+export declare function removeAllBombs(bombVariant?: BombVariant, subType?: int, cap?: int): boolean;
+/**
+ * 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 True if one or more effects were removed, false otherwise.
+ */
+export declare function removeAllEffects(effectVariant?: EffectVariant, subType?: int, cap?: int): boolean;
+/**
+ * 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 True if one or more familiars were removed, false otherwise.
+ */
+export declare function removeAllFamiliars(familiarVariant?: FamiliarVariant, subType?: int, cap?: int): boolean;
+/**
+ * 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 True if one or more knives were removed, false otherwise.
+ */
+export declare function removeAllKnives(knifeVariant?: KnifeVariant, subType?: int, cap?: int): boolean;
+/**
+ * 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 True if one or more lasers were removed, false otherwise.
+ */
+export declare function removeAllLasers(laserVariant?: LaserVariant, subType?: int, cap?: int): boolean;
+/**
+ * Helper function to remove all NPCs in the room.
+ *
+ * @param cap Optional. If specified, will only remove the given amount of NPCs.
+ * @returns True if one or more NPCs were removed, false otherwise.
+ */
+export declare function removeAllNPCs(cap?: int): boolean;
+/**
+ * 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 True if one or more pickups were removed, false otherwise.
+ */
+export declare function removeAllPickups(pickupVariant?: PickupVariant, subType?: int, cap?: int): boolean;
+/**
+ * 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 True if one or more projectiles were removed, false otherwise.
+ */
+export declare function removeAllProjectiles(projectileVariant?: ProjectileVariant, subType?: int, cap?: int): boolean;
+/**
+ * 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 True if one or more slots were removed, false otherwise.
+ */
+export declare function removeAllSlots(slotVariant?: SlotVariant, subType?: int, cap?: int): boolean;
+/**
+ * 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 True if one or more tears were removed, false otherwise.
+ */
+export declare function removeAllTears(tearVariant?: TearVariant, subType?: int, cap?: int): boolean;
+/** Helper function to spawn a `EntityType.BOMB` (4). */
+export declare function spawnBomb(bombVariant: BombVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityBomb;
+/** Helper function to spawn a `EntityType.BOMB` (4) with a specific seed. */
+export declare function spawnBombWithSeed(bombVariant: BombVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityBomb;
+/** Helper function to spawn a `EntityType.EFFECT` (1000). */
+export declare function spawnEffect(effectVariant: EffectVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityEffect;
+/** Helper function to spawn a `EntityType.EFFECT` (1000) with a specific seed. */
+export declare function spawnEffectWithSeed(effectVariant: EffectVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityEffect;
+/** Helper function to spawn a `EntityType.FAMILIAR` (3). */
+export declare function spawnFamiliar(familiarVariant: FamiliarVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityFamiliar;
+/** Helper function to spawn a `EntityType.FAMILIAR` (3) with a specific seed. */
+export declare function spawnFamiliarWithSeed(familiarVariant: FamiliarVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityFamiliar;
+/** Helper function to spawn a `EntityType.KNIFE` (8). */
+export declare function spawnKnife(knifeVariant: KnifeVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityKnife;
+/** Helper function to spawn a `EntityType.KNIFE` (8) with a specific seed. */
+export declare function spawnKnifeWithSeed(knifeVariant: KnifeVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityKnife;
+/** Helper function to spawn a `EntityType.LASER` (7). */
+export declare function spawnLaser(laserVariant: LaserVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityLaser;
+/** Helper function to spawn a `EntityType.LASER` (7) with a specific seed. */
+export declare function spawnLaserWithSeed(laserVariant: LaserVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityLaser;
+/** Helper function to spawn an NPC. */
+export declare function spawnNPC(entityType: EntityType, variant: int, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityNPC;
+/** Helper function to spawn an NPC with a specific seed. */
+export declare function spawnNPCWithSeed(entityType: EntityType, variant: int, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityNPC;
+/** Helper function to spawn a `EntityType.PICKUP` (5). */
+export declare function spawnPickup(pickupVariant: PickupVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityPickup;
+/** Helper function to spawn a `EntityType.PICKUP` (5) with a specific seed. */
+export declare function spawnPickupWithSeed(pickupVariant: PickupVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityPickup;
+/** Helper function to spawn a `EntityType.PROJECTILE` (9). */
+export declare function spawnProjectile(projectileVariant: ProjectileVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityProjectile;
+/** Helper function to spawn a `EntityType.PROJECTILE` (9) with a specific seed. */
+export declare function spawnProjectileWithSeed(projectileVariant: ProjectileVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityProjectile;
+/** Helper function to spawn a `EntityType.SLOT` (6). */
+export declare function spawnSlot(slotVariant: SlotVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): Entity;
+/** Helper function to spawn a `EntityType.SLOT` (6) with a specific seed. */
+export declare function spawnSlotWithSeed(slotVariant: SlotVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): Entity;
+/** Helper function to spawn a `EntityType.TEAR` (2). */
+export declare function spawnTear(tearVariant: TearVariant, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): EntityTear;
+/** Helper function to spawn a `EntityType.EntityType` (2) with a specific seed. */
+export declare function spawnTearWithSeed(tearVariant: TearVariant, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): EntityTear;