isaacscript-common 13.3.4 → 14.1.0

package/src/callbacks/postCustomDoorEnter.ts

@@ -1,250 +0,0 @@
-import {
-  Direction,
-  DoorSlot,
-  DoorState,
-  EffectVariant,
-  GridCollisionClass,
-  GridEntityType,
-  ModCallback,
-} from "isaac-typescript-definitions";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { game } from "../core/cachedClasses";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { directionToVector } from "../functions/direction";
-import { doorSlotToDirection } from "../functions/doors";
-import { getEffects, spawnEffect } from "../functions/entitiesSpecific";
-import { getClosestPlayer } from "../functions/players";
-import { asNumber } from "../functions/types";
-import {
-  postCustomDoorEnterFire,
-  postCustomDoorEnterHasSubscriptions,
-} from "./subscriptions/postCustomDoorEnter";
-
-interface EntityEffectCustomDoor extends EntityEffect {
-  State: DoorState;
-}
-
-interface CustomDoorData {
-  slot: DoorSlot;
-  state: DoorState;
-}
-
-const POSITION_OFFSET_MULTIPLIER = -23;
-
-const initializedEffectVariants = new Set<int>();
-
-const v = {
-  room: {
-    customDoors: new Map<PtrHash, CustomDoorData>(),
-    customDoorSlots: new Set<DoorSlot>(),
-  },
-};
-
-export function postCustomDoorEnterInit(): void {
-  saveDataManager("postCustomDoorEnter", v, hasSubscriptions);
-}
-
-function hasSubscriptions() {
-  return postCustomDoorEnterHasSubscriptions();
-}
-
-export function initCustomDoorInternal(
-  mod: ModUpgraded,
-  effectVariant: EffectVariant,
-): void {
-  initializedEffectVariants.add(effectVariant);
-
-  mod.AddCallback(
-    ModCallback.POST_EFFECT_UPDATE,
-    postEffectUpdaterCustomEntity,
-    effectVariant,
-  ); // 55
-
-  mod.AddCallback(
-    ModCallback.POST_EFFECT_RENDER,
-    postEffectRenderCustomEntity,
-    effectVariant,
-  ); // 56
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_ROOM_CLEAR_CHANGED,
-    (roomClear: boolean) => {
-      postRoomClearChanged(roomClear, effectVariant);
-    },
-  );
-}
-
-// ModCallback.POST_EFFECT_UPDATE (55)
-function postEffectUpdaterCustomEntity(effect: EntityEffect) {
-  const customDoor = effect as EntityEffectCustomDoor;
-
-  const ptrHash = GetPtrHash(effect);
-  const doorData = v.room.customDoors.get(ptrHash);
-  if (doorData === undefined) {
-    return;
-  }
-
-  if (doorData.state === customDoor.State) {
-    return;
-  }
-  doorData.state = customDoor.State;
-
-  doorChangedState(effect);
-}
-
-function doorChangedState(door: EntityEffectCustomDoor) {
-  const room = game.GetRoom();
-
-  const sprite = door.GetSprite();
-  const animation = getAnimationForCustomDoor(door);
-  sprite.Play(animation, true);
-
-  const gridIndex = room.GetGridIndex(door.Position);
-  const wall = room.GetGridEntity(gridIndex);
-  if (wall !== undefined) {
-    wall.CollisionClass =
-      door.State === DoorState.OPEN
-        ? GridCollisionClass.WALL_EXCEPT_PLAYER
-        : GridCollisionClass.WALL;
-  }
-}
-
-function getAnimationForCustomDoor(door: EntityEffectCustomDoor): string {
-  const freshlySpawned = door.FrameCount === 0;
-
-  switch (door.State) {
-    case DoorState.OPEN: {
-      return freshlySpawned ? "Opened" : "Open";
-    }
-
-    case DoorState.CLOSED: {
-      return freshlySpawned ? "Closed" : "Close";
-    }
-
-    default: {
-      return "Opened";
-    }
-  }
-}
-
-// ModCallback.POST_EFFECT_RENDER (56)
-function postEffectRenderCustomEntity(effect: EntityEffect) {
-  const ptrHash = GetPtrHash(effect);
-  const doorData = v.room.customDoors.get(ptrHash);
-  if (doorData === undefined) {
-    return;
-  }
-
-  const direction = doorSlotToDirection(doorData.slot);
-  const player = getClosestPlayer(effect.Position);
-  if (isPlayerPastDoorThreshold(effect, player, direction)) {
-    postCustomDoorEnterFire(player, effect.Variant, doorData.slot, direction);
-  }
-}
-
-function isPlayerPastDoorThreshold(
-  effect: EntityEffect,
-  player: EntityPlayer,
-  direction: Direction,
-) {
-  switch (direction) {
-    case Direction.NO_DIRECTION: {
-      return false;
-    }
-
-    // 1
-    case Direction.UP: {
-      return player.Position.Y <= effect.Position.Y;
-    }
-
-    // 2
-    case Direction.RIGHT: {
-      return player.Position.X >= effect.Position.X;
-    }
-
-    // 3
-    case Direction.DOWN: {
-      return player.Position.Y >= effect.Position.Y;
-    }
-
-    // 4
-    case Direction.LEFT: {
-      return player.Position.X <= effect.Position.X;
-    }
-  }
-}
-
-// ModCallbackCustom.POST_ROOM_CLEAR_CHANGED
-function postRoomClearChanged(
-  roomClear: boolean,
-  effectVariant: EffectVariant,
-) {
-  const state = roomClear ? DoorState.OPEN : DoorState.CLOSED;
-  const customDoors = getEffects(effectVariant);
-  for (const customDoor of customDoors) {
-    customDoor.State = state;
-  }
-}
-
-export function spawnCustomDoorInternal(
-  effectVariant: EffectVariant,
-  doorSlot: DoorSlot,
-): EntityEffect {
-  if (!initializedEffectVariants.has(effectVariant)) {
-    error(
-      'In order to spawn custom doors, you must first initialize them with the "initCustomDoor" function at the beginning of your mod.',
-    );
-  }
-
-  if (v.room.customDoorSlots.has(doorSlot)) {
-    error(
-      `There is already a custom door initialized on door slot: ${doorSlot}`,
-    );
-  }
-
-  const room = game.GetRoom();
-  const roomClear = room.IsClear();
-  const position = room.GetDoorSlotPosition(doorSlot);
-  const gridEntity = room.GetGridEntityFromPos(position);
-  if (gridEntity === undefined) {
-    error(
-      `Failed to initialize a custom door at slot ${doorSlot} because the wall on that tile does not exist.`,
-    );
-  }
-
-  const gridEntityType = gridEntity.GetType();
-  if (gridEntityType !== GridEntityType.WALL) {
-    error(
-      `Failed to initialize a custom door at slot ${doorSlot} because there is another grid entity on that tile with a type of: ${gridEntityType}`,
-    );
-  }
-
-  const effect = spawnEffect(effectVariant, 0, position);
-
-  // Do initial setup for the door.
-  effect.State = roomClear ? DoorState.OPEN : DoorState.CLOSED;
-  effect.RenderZOffset = -10000;
-  effect.PositionOffset = getPositionOffset(doorSlot);
-  const sprite = effect.GetSprite();
-  sprite.Rotation = asNumber(doorSlot) * 90 - 90;
-
-  // Keep track of metadata about this door.
-  const ptrHash = GetPtrHash(effect);
-  const doorData: CustomDoorData = {
-    slot: doorSlot,
-    state: effect.State,
-  };
-  v.room.customDoors.set(ptrHash, doorData);
-  v.room.customDoorSlots.add(doorSlot);
-
-  doorChangedState(effect);
-
-  return effect;
-}
-
-function getPositionOffset(doorSlot: DoorSlot) {
-  const direction = doorSlotToDirection(doorSlot);
-  const vector = directionToVector(direction);
-  return vector.mul(POSITION_OFFSET_MULTIPLIER);
-}

package/src/callbacks/subscriptions/postCustomDoorEnter.ts

@@ -1,42 +0,0 @@
-import { Direction, DoorSlot } from "isaac-typescript-definitions";
-
-export type PostCustomDoorEnterRegisterParameters = [
-  callback: (
-    player: EntityPlayer,
-    effectVariant: int,
-    doorSlot: DoorSlot,
-    direction: Direction,
-  ) => void,
-  effectVariant?: int,
-];
-
-const subscriptions: PostCustomDoorEnterRegisterParameters[] = [];
-
-export function postCustomDoorEnterHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-export function postCustomDoorEnterRegister(
-  ...args: PostCustomDoorEnterRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-export function postCustomDoorEnterFire(
-  player: EntityPlayer,
-  effectVariant: int,
-  doorSlot: DoorSlot,
-  direction: Direction,
-): void {
-  for (const [callback, callbackEffectVariant] of subscriptions) {
-    // Handle the optional 2nd callback argument.
-    if (
-      callbackEffectVariant !== undefined &&
-      callbackEffectVariant !== effectVariant
-    ) {
-      continue;
-    }
-
-    callback(player, effectVariant, doorSlot, direction);
-  }
-}

package/src/classes/CustomCallback.ts

@@ -1,23 +0,0 @@
-/* eslint-disable */
-
-export class CustomCallback<AddParams extends [], FireParams extends []> {
-  subscriptions: AddParams[] = [];
-
-  hasSubscriptions(): boolean {
-    return this.subscriptions.length > 0;
-  }
-
-  add(...args: AddParams): void {
-    this.subscriptions.push(args);
-  }
-
-  remove(callback: AddParams[0]): void {
-    const subscriptionIndexMatchingCallback = this.subscriptions.find(
-      (subscription) => {
-        // const subscriptionCallback = subscription[0];
-      },
-    );
-  }
-
-  fire(...args: FireParams): void {}
-}

package/src/features/customDoor.ts

@@ -1,66 +0,0 @@
-import { DoorSlot, EffectVariant } from "isaac-typescript-definitions";
-import {
-  initCustomDoorInternal,
-  spawnCustomDoorInternal,
-} from "../callbacks/postCustomDoorEnter";
-import { ModUpgraded } from "../classes/ModUpgraded";
-
-/**
- * `isaacscript-common` provides custom doors that can be spawned where any wall segment is. If you
- * use this feature, you must first call this initialization function at the beginning of your mod.
- *
- * Each kind of custom door that you create must have an entry in the "content/entities2.xml" file,
- * like so:
- *
- * ```xml
- * <entity id="1000" name="Foo Custom Door" anm2path="grid/door_foo.anm2" />
- * ```
- *
- * (Custom door entities must have an id of "1000", which corresponds to an effect. If you do not
- * specify the variant, then the game will automatically assign it.)
- *
- * Next, pass the variant into this function:
- *
- * ```ts
- * const modVanilla = RegisterMod("My Mod", 1);
- * const mod = upgradeMod(modVanilla);
- * const fooEffectVariant = Isaac.GetEntityVariantByName("Foo Custom Door");
- * initCustomDoor(mod, fooEffectVariant);
- * ```
- *
- * Also see the `spawnCustomDoor` function.
- */
-export function initCustomDoor(
-  mod: ModUpgraded,
-  effectVariant: EffectVariant,
-): void {
-  initCustomDoorInternal(mod, effectVariant);
-}
-
-/**
- * Helper function to spawn a custom door. This is intended to be called from the `POST_NEW_ROOM`
- * callback when the player enters a room that should have a custom door. (You could also call it
- * from another callback if you want the door to appear e.g. after clearing all enemies.)
- *
- * Like other entities, the door is not persistent, so you must spawn it every time when re-entering
- * the room.
- *
- * Handle when a player enters the door by hooking the custom `POST_CUSTOM_DOOR_ENTER` callback.
- *
- * The custom door is an `EntityEffect`. You can manually open or close the door by modifying its
- * state. (The values to use correspond to the `DoorState` enum.)
- *
- * This function will throw a run-time error if:
- * - the door slot already has a vanilla door
- * - the door slot already has a custom door
- * - the tile at the door slot does not have a wall
- *
- * Before using this function, you must first initialize the effect/door variant with the
- * `initCustomDoor` function.
- */
-export function spawnCustomDoor(
-  effectVariant: EffectVariant,
-  doorSlot: DoorSlot,
-): EntityEffect {
-  return spawnCustomDoorInternal(effectVariant, doorSlot);
-}