isaacscript-common 4.0.3 → 4.0.4

package/functions/doors.ts

@@ -1,347 +0,0 @@
-import {
-  Direction,
-  DoorSlot,
-  DoorSlotFlag,
-  DoorState,
-  DoorVariant,
-  GridRoom,
-  RoomShape,
-  RoomType,
-} from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import {
-  DEFAULT_DOOR_SLOT,
-  DOOR_SLOT_FLAG_TO_DOOR_SLOT,
-} from "../objects/doorSlotFlagToDoorSlot";
-import { DOOR_SLOT_TO_DIRECTION } from "../objects/doorSlotToDirection";
-import { OPPOSITE_DOOR_SLOTS } from "../objects/oppositeDoorSlots";
-import { ROOM_SHAPE_TO_DOOR_SLOTS } from "../objects/roomShapeToDoorSlots";
-import { directionToVector } from "./direction";
-import { getEnumValues } from "./enums";
-
-/**
- * When players enter a room, they do not appear exactly on the location of the door, because then
- * they would immediately collide with the loading zone. Instead, they are offset by this amount of
- * units.
- */
-const ROOM_ENTRY_OFFSET_FROM_DOOR = 40;
-
-export function closeAllDoors(): void {
-  for (const door of getDoors()) {
-    door.Close(true);
-  }
-}
-
-/**
- * Use this instead of the `GridEntityDoor.Close` method if you want the door to immediately close
- * without an animation.
- */
-export function closeDoorFast(door: GridEntityDoor): void {
-  door.State = DoorState.CLOSED;
-
-  const sprite = door.GetSprite();
-  sprite.Play("Closed", true);
-}
-
-export function doorSlotFlagToDoorSlot(doorSlotFlag: DoorSlotFlag): DoorSlot {
-  const doorSlot = DOOR_SLOT_FLAG_TO_DOOR_SLOT[doorSlotFlag];
-  return doorSlot === undefined ? DEFAULT_DOOR_SLOT : doorSlot;
-}
-
-export function doorSlotToDirection(doorSlot: DoorSlot): Direction {
-  return DOOR_SLOT_TO_DIRECTION[doorSlot];
-}
-
-export function getAngelRoomDoor(): GridEntityDoor | undefined {
-  const angelRoomDoors = getDoors(RoomType.ANGEL);
-  return angelRoomDoors.length === 0 ? undefined : angelRoomDoors[0];
-}
-
-export function getDevilRoomDoor(): GridEntityDoor | undefined {
-  const devilRoomDoors = getDoors(RoomType.DEVIL);
-  return devilRoomDoors.length === 0 ? undefined : devilRoomDoors[0];
-}
-
-/**
- * If there is both a Devil Room and an Angel Room door, this function will return door with the
- * lowest slot number.
- */
-export function getDevilRoomOrAngelRoomDoor(): GridEntityDoor | undefined {
-  const devilRoomOrAngelRoomDoors = getDoors(RoomType.DEVIL, RoomType.ANGEL);
-  return devilRoomOrAngelRoomDoors.length === 0
-    ? undefined
-    : devilRoomOrAngelRoomDoors[0];
-}
-
-/**
- * Helper function to get the position that a player will enter a room at.
- *
- * When players enter a room, they do not appear exactly on the location of the door, because then
- * they would immediately collide with the loading zone. Instead, they are offset by a certain
- * amount of units.
- */
-export function getDoorEnterPosition(door: GridEntityDoor): Vector {
-  const offset = getDoorEnterPositionOffset(door.Slot);
-  return door.Position.add(offset);
-}
-
-/**
- * Helper function to help calculate the position that a player will enter a room at.
- *
- * When players enter a room, they do not appear exactly on the location of the door, because then
- * they would immediately collide with the loading zone. Instead, they are offset by a certain
- * amount of units.
- */
-export function getDoorEnterPositionOffset(doorSlot: DoorSlot): Vector {
-  const direction = doorSlotToDirection(doorSlot);
-  const vector = directionToVector(direction);
-  return vector.mul(ROOM_ENTRY_OFFSET_FROM_DOOR);
-}
-
-/** Helper function to get the possible door slots that can exist for a given room shape. */
-export function getDoorSlotsForRoomShape(
-  roomShape: RoomShape,
-): ReadonlySet<DoorSlot> {
-  return ROOM_SHAPE_TO_DOOR_SLOTS[roomShape];
-}
-
-/**
- * Helper function to get all of the doors in the room. By default, it will return every door. You
- * can optionally specify one or more room types to return only the doors that match the specified
- * room types.
- */
-export function getDoors(...roomTypes: RoomType[]): GridEntityDoor[] {
-  const room = game.GetRoom();
-  const roomTypesSet = new Set(roomTypes);
-
-  const doorSlots = getEnumValues(DoorSlot);
-  const doors: GridEntityDoor[] = [];
-  for (const doorSlot of doorSlots) {
-    const door = room.GetDoor(doorSlot);
-    if (door === undefined) {
-      continue;
-    }
-
-    if (roomTypesSet.size === 0 || roomTypesSet.has(door.TargetRoomType)) {
-      doors.push(door);
-    }
-  }
-
-  return doors;
-}
-
-/**
- * Helper function to get all of the doors in the room that lead to the provided room index.
- *
- * This function is variadic, meaning that you can specify N arguments to return all of the doors
- * that match any of the N room grid indexes.
- */
-export function getDoorsToRoomIndex(...roomGridIndex: int[]): GridEntityDoor[] {
-  const roomGridIndexesSet = new Set(roomGridIndex);
-  const doors = getDoors();
-  return doors.filter((door) => roomGridIndexesSet.has(door.TargetRoomIndex));
-}
-
-export function getOppositeDoorSlot(doorSlot: DoorSlot): DoorSlot | undefined {
-  return OPPOSITE_DOOR_SLOTS[doorSlot];
-}
-
-export function getRepentanceDoor(): GridEntityDoor | undefined {
-  const doors = getDoors();
-  return doors.find((door) => isRepentanceDoor(door));
-}
-
-/** Helper function to find unused door slots in the room that can be used to make custom doors. */
-export function getUnusedDoorSlots(): DoorSlot[] {
-  const room = game.GetRoom();
-  const doorSlots = getEnumValues(DoorSlot);
-  return doorSlots.filter(
-    (doorSlot) =>
-      room.IsDoorSlotAllowed(doorSlot) && room.GetDoor(doorSlot) === undefined,
-  );
-}
-
-export function isAngelRoomDoor(door: GridEntityDoor): boolean {
-  return door.TargetRoomType === RoomType.ANGEL;
-}
-
-export function isDevilRoomDoor(door: GridEntityDoor): boolean {
-  return door.TargetRoomType === RoomType.DEVIL;
-}
-
-/** Helper function to see if a door slot could exist for a given room shape. */
-export function isDoorSlotInRoomShape(
-  doorSlot: DoorSlot,
-  roomShape: RoomShape,
-): boolean {
-  const doorSlots = getDoorSlotsForRoomShape(roomShape);
-  return doorSlots.has(doorSlot);
-}
-
-/**
- * This refers to the Repentance door that spawns in a boss room after defeating the boss. You have
- * to spend one key to open it. It has a sprite filename of "gfx/grid/Door_Downpour.anm2".
- */
-export function isDoorToDownpour(door: GridEntityDoor): boolean {
-  if (!isRepentanceDoor(door)) {
-    return false;
-  }
-
-  const sprite = door.GetSprite();
-  const filename = sprite.GetFilename();
-
-  return filename === "gfx/grid/Door_Downpour.anm2";
-}
-
-/**
- * This refers to the Repentance door that spawns in a boss room after defeating the boss. You have
- * to spend two hearts to open it. It has a sprite filename of "gfx/grid/Door_Mausoleum.anm2".
- */
-export function isDoorToMausoleum(door: GridEntityDoor): boolean {
-  if (!isRepentanceDoor(door)) {
-    return false;
-  }
-
-  const sprite = door.GetSprite();
-  const filename = sprite.GetFilename();
-
-  return filename === "gfx/grid/Door_Mausoleum.anm2";
-}
-
-/**
- * This refers to the "strange door" located on the first room of Depths 2. You open it with either
- * a Polaroid or a Negative. It has a sprite filename of "gfx/grid/Door_Mausoleum_Alt.anm2".
- */
-export function isDoorToMausoleumAscent(door: GridEntityDoor): boolean {
-  if (!isRepentanceDoor(door)) {
-    return false;
-  }
-
-  const sprite = door.GetSprite();
-  const filename = sprite.GetFilename();
-
-  return filename === "gfx/grid/Door_Mausoleum_Alt.anm2";
-}
-
-/**
- * This refers to the Repentance door that spawns in a boss room after defeating the boss. You have
- * to spend two bombs to open it. It has a sprite filename of "gfx/grid/Door_Mines.anm2".
- */
-export function isDoorToMines(door: GridEntityDoor): boolean {
-  if (!isRepentanceDoor(door)) {
-    return false;
-  }
-
-  const sprite = door.GetSprite();
-  const filename = sprite.GetFilename();
-
-  return filename === "gfx/grid/Door_Mines.anm2";
-}
-
-/**
- * This refers to the Repentance door that spawns after defeating Mom. You open it with the
- * completed knife. It has a sprite filename of "gfx/grid/Door_MomsHeart.anm2".
- */
-export function isDoorToMomsHeart(door: GridEntityDoor): boolean {
-  if (!isRepentanceDoor(door)) {
-    return false;
-  }
-
-  const sprite = door.GetSprite();
-  const filename = sprite.GetFilename();
-
-  return filename === "gfx/grid/Door_MomsHeart.anm2";
-}
-
-export function isHiddenSecretRoomDoor(door: GridEntityDoor): boolean {
-  const sprite = door.GetSprite();
-  const animation = sprite.GetAnimation();
-
-  return isSecretRoomDoor(door) && animation === "Hidden";
-}
-
-export function isRepentanceDoor(door: GridEntityDoor): boolean {
-  // eslint-disable-next-line isaacscript/strict-enums
-  return door.TargetRoomIndex === GridRoom.SECRET_EXIT;
-}
-
-export function isSecretRoomDoor(door: GridEntityDoor): boolean {
-  const sprite = door.GetSprite();
-  const filename = sprite.GetFilename();
-
-  return filename === "gfx/grid/Door_08_HoleInWall.anm2";
-}
-
-/**
- * Helper function to reset an unlocked door back to a locked state. Doing this is non-trivial
- * because in addition to calling the `GridEntityDoor.SetLocked` method, you must also:
- *
- * - Set the `VisitedCount` of the room's `RoomDescription` to 0.
- * - Set the variant to `DoorVariant.DOOR_LOCKED`.
- * - Close the door.
- */
-export function lockDoor(door: GridEntityDoor): void {
-  const level = game.GetLevel();
-
-  // We can't use the "getRoomDescriptor" function since it will cause a dependency cycle.
-  const roomDescriptor = level.GetRoomByIdx(door.TargetRoomIndex);
-  roomDescriptor.VisitedCount = 0;
-
-  door.SetVariant(DoorVariant.LOCKED);
-  door.SetLocked(true);
-  door.Close(true);
-}
-
-/**
- * For the purposes of this function, doors to Secret Rooms or Super Secret Rooms that have not been
- * discovered yet will not be opened.
- */
-export function openAllDoors(): void {
-  for (const door of getDoors()) {
-    // If we try to open a hidden Secret Room door (or Super Secret Room door), then nothing will
-    // happen.
-    door.Open();
-  }
-}
-
-/**
- * Use this instead of the `GridEntityDoor.Open` method if you want the door to immediately open
- * without an animation.
- */
-export function openDoorFast(door: GridEntityDoor): void {
-  door.State = DoorState.OPEN;
-
-  const sprite = door.GetSprite();
-  sprite.Play("Opened", true);
-}
-
-/**
- * Helper function to remove all of the doors in the room. By default, it will remove every door.
- * You can optionally specify one or more room types to remove only the doors that match the
- * specified room types.
- *
- * @returns The number of doors removed.
- */
-export function removeAllDoors(...roomTypes: RoomType[]): int {
-  const doors = getDoors(...roomTypes);
-  removeDoors(...doors);
-
-  return doors.length;
-}
-
-/** Helper function to remove a single door. */
-export function removeDoor(door: GridEntityDoor): void {
-  const room = game.GetRoom();
-  room.RemoveDoor(door.Slot);
-}
-
-/**
- * Helper function to remove the doors provided.
- *
- * This function is variadic, meaning that you can specify as many doors as you want to remove.
- */
-export function removeDoors(...doors: GridEntityDoor[]): void {
-  for (const door of doors) {
-    removeDoor(door);
-  }
-}

package/functions/easing.ts

@@ -1,182 +0,0 @@
-/* eslint-disable no-nested-ternary */
-/* eslint-disable no-return-assign */
-/* eslint-disable sort-exports/sort-exports */
-
-// These functions are from:
-// https://easings.net/
-
-export function easeInSine(x: number): number {
-  return 1 - Math.cos((x * Math.PI) / 2);
-}
-
-export function easeOutSine(x: number): number {
-  return Math.sin((x * Math.PI) / 2);
-}
-
-export function easeInOutSine(x: number): number {
-  return -(Math.cos(Math.PI * x) - 1) / 2;
-}
-
-export function easeInCubic(x: number): number {
-  return x * x * x;
-}
-
-export function easeOutCubic(x: number): number {
-  return 1 - (1 - x) ** 3;
-}
-
-export function easeInOutCubic(x: number): number {
-  return x < 0.5 ? 4 * x * x * x : 1 - (-2 * x + 2) ** 3 / 2;
-}
-
-export function easeInQuint(x: number): number {
-  return x * x * x * x * x;
-}
-
-export function easeOutQuint(x: number): number {
-  return 1 - (1 - x) ** 5;
-}
-
-export function easeInOutQuint(x: number): number {
-  return x < 0.5 ? 16 * x * x * x * x * x : 1 - (-2 * x + 2) ** 5 / 2;
-}
-
-export function easeInCirc(x: number): number {
-  return 1 - Math.sqrt(1 - x ** 2);
-}
-
-export function easeOutCirc(x: number): number {
-  return Math.sqrt(1 - (x - 1) ** 2);
-}
-
-export function easeInOutCirc(x: number): number {
-  return x < 0.5
-    ? (1 - Math.sqrt(1 - (2 * x) ** 2)) / 2
-    : (Math.sqrt(1 - (-2 * x + 2) ** 2) + 1) / 2;
-}
-
-export function easeInElastic(x: number): number {
-  const c4 = (2 * Math.PI) / 3;
-
-  return x === 0
-    ? 0
-    : x === 1
-    ? 1
-    : -(2 ** (10 * x - 10)) * Math.sin((x * 10 - 10.75) * c4);
-}
-
-export function easeOutElastic(x: number): number {
-  const c4 = (2 * Math.PI) / 3;
-
-  return x === 0
-    ? 0
-    : x === 1
-    ? 1
-    : 2 ** (-10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;
-}
-
-export function easeInOutElastic(x: number): number {
-  const c5 = (2 * Math.PI) / 4.5;
-
-  return x === 0
-    ? 0
-    : x === 1
-    ? 1
-    : x < 0.5
-    ? -(2 ** (20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2
-    : (2 ** (-20 * x + 10) * Math.sin((20 * x - 11.125) * c5)) / 2 + 1;
-}
-
-export function easeInQuad(x: number): number {
-  return x * x;
-}
-
-export function easeOutQuad(x: number): number {
-  return 1 - (1 - x) * (1 - x);
-}
-
-export function easeInOutQuad(x: number): number {
-  return x < 0.5 ? 2 * x * x : 1 - (-2 * x + 2) ** 2 / 2;
-}
-
-export function easeInQuart(x: number): number {
-  return x * x * x * x;
-}
-
-export function easeOutQuart(x: number): number {
-  return 1 - (1 - x) ** 4;
-}
-
-export function easeInOutQuart(x: number): number {
-  return x < 0.5 ? 8 * x * x * x * x : 1 - (-2 * x + 2) ** 4 / 2;
-}
-
-export function easeInExpo(x: number): number {
-  return x === 0 ? 0 : 2 ** (10 * x - 10);
-}
-
-export function easeOutExpo(x: number): number {
-  return x === 1 ? 1 : 1 - 2 ** (-10 * x);
-}
-
-export function easeInOutExpo(x: number): number {
-  return x === 0
-    ? 0
-    : x === 1
-    ? 1
-    : x < 0.5
-    ? 2 ** (20 * x - 10) / 2
-    : (2 - 2 ** (-20 * x + 10)) / 2;
-}
-
-export function easeInBack(x: number): number {
-  const c1 = 1.70158;
-  const c3 = c1 + 1;
-
-  return c3 * x * x * x - c1 * x * x;
-}
-
-export function easeOutBack(x: number): number {
-  const c1 = 1.70158;
-  const c3 = c1 + 1;
-
-  return 1 + c3 * (x - 1) ** 3 + c1 * (x - 1) ** 2;
-}
-
-export function easeInOutBack(x: number): number {
-  const c1 = 1.70158;
-  const c2 = c1 * 1.525;
-
-  return x < 0.5
-    ? ((2 * x) ** 2 * ((c2 + 1) * 2 * x - c2)) / 2
-    : ((2 * x - 2) ** 2 * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
-}
-
-export function easeInBounce(x: number): number {
-  return 1 - easeOutBounce(1 - x);
-}
-
-export function easeOutBounce(x: number): number {
-  const n1 = 7.5625;
-  const d1 = 2.75;
-
-  if (x < 1 / d1) {
-    return n1 * x * x;
-  }
-
-  if (x < 2 / d1) {
-    return n1 * (x -= 1.5 / d1) * x + 0.75;
-  }
-
-  if (x < 2.5 / d1) {
-    return n1 * (x -= 2.25 / d1) * x + 0.9375;
-  }
-
-  return n1 * (x -= 2.625 / d1) * x + 0.984375;
-}
-
-export function easeInOutBounce(x: number): number {
-  return x < 0.5
-    ? (1 - easeOutBounce(1 - 2 * x)) / 2
-    : (1 + easeOutBounce(2 * x - 1)) / 2;
-}

package/functions/eden.ts

@@ -1,47 +0,0 @@
-import { CollectibleType, ItemConfigTag } from "isaac-typescript-definitions";
-import { isHiddenCollectible, isPassiveCollectible } from "./collectibles";
-import { getCollectibleSet } from "./collectibleSet";
-import { collectibleHasTag } from "./collectibleTag";
-import { getRandomSeed } from "./rng";
-import { copySet, getRandomSetElement } from "./set";
-
-const EDEN_PASSIVE_COLLECTIBLES_SET = new Set<CollectibleType>();
-
-function initCollectibleSet() {
-  const collectibleSet = getCollectibleSet();
-
-  for (const collectibleType of collectibleSet.values()) {
-    if (
-      isPassiveCollectible(collectibleType) &&
-      !isHiddenCollectible(collectibleType) &&
-      !collectibleHasTag(collectibleType, ItemConfigTag.NO_EDEN)
-    ) {
-      EDEN_PASSIVE_COLLECTIBLES_SET.add(collectibleType);
-    }
-  }
-}
-
-export function getEdenPassives(): Set<CollectibleType> {
-  // Lazy initialize the set.
-  if (EDEN_PASSIVE_COLLECTIBLES_SET.size === 0) {
-    initCollectibleSet();
-  }
-
-  return copySet(EDEN_PASSIVE_COLLECTIBLES_SET);
-}
-
-export function getRandomEdenPassive(
-  seedOrRNG: Seed | RNG = getRandomSeed(),
-  exceptions: CollectibleType[] | readonly CollectibleType[] = [],
-): CollectibleType {
-  // Lazy initialize the set.
-  if (EDEN_PASSIVE_COLLECTIBLES_SET.size === 0) {
-    initCollectibleSet();
-  }
-
-  return getRandomSetElement(
-    EDEN_PASSIVE_COLLECTIBLES_SET,
-    seedOrRNG,
-    exceptions,
-  );
-}

package/functions/effects.ts

@@ -1,20 +0,0 @@
-import { inRectangle } from "./math";
-
-/** For `EntityType.EFFECT` (1000), `EffectVariant.DICE_FLOOR` (76) */
-export const DICE_FLOOR_TRIGGER_SQUARE_SIZE = 75;
-
-/** Helper function to see if a player is close enough to activate a Dice Room floor. */
-export function isCloseEnoughToTriggerDiceFloor(
-  player: EntityPlayer,
-  diceFloor: EntityEffect,
-): boolean {
-  // Unlike other entities, the dice floor has a rectangular hit box, not a circular one.
-  const topLeft = diceFloor.Position.add(
-    Vector(-DICE_FLOOR_TRIGGER_SQUARE_SIZE, -DICE_FLOOR_TRIGGER_SQUARE_SIZE),
-  );
-  const bottomRight = diceFloor.Position.add(
-    Vector(DICE_FLOOR_TRIGGER_SQUARE_SIZE, DICE_FLOOR_TRIGGER_SQUARE_SIZE),
-  );
-
-  return inRectangle(player.Position, topLeft, bottomRight);
-}