isaacscript-common 3.16.1 → 4.0.1-dev.0

package/features/disableInputs.ts

@@ -0,0 +1,193 @@
+import {
+  ButtonAction,
+  InputHook,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { getMoveActions, getShootActions } from "../functions/input";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "input disabler";
+
+const v = {
+  run: {
+    /** Indexed by the requesting feature key. */
+    disableInputsWithWhitelistMap: new Map<
+      string,
+      Set<ButtonAction> | ReadonlySet<ButtonAction>
+    >(),
+
+    /** Indexed by the requesting feature key. */
+    enableInputsWithBlacklistMap: new Map<
+      string,
+      Set<ButtonAction> | ReadonlySet<ButtonAction>
+    >(),
+  },
+};
+
+/** @internal */
+export function disableInputsInit(mod: Mod): void {
+  saveDataManager("disableInputs", v);
+
+  mod.AddCallback(
+    ModCallback.INPUT_ACTION,
+    isActionPressed,
+    InputHook.IS_ACTION_PRESSED, // 0
+  );
+
+  mod.AddCallback(
+    ModCallback.INPUT_ACTION,
+    isActionTriggered,
+    InputHook.IS_ACTION_TRIGGERED, // 1
+  );
+
+  mod.AddCallback(
+    ModCallback.INPUT_ACTION,
+    getActionValue,
+    InputHook.GET_ACTION_VALUE, // 2
+  );
+}
+
+// InputHook.IS_ACTION_PRESSED (0)
+function isActionPressed(
+  _entity: Entity | undefined,
+  _inputHook: InputHook,
+  buttonAction: ButtonAction,
+) {
+  return getReturnValue(buttonAction, true);
+}
+
+// InputHook.IS_ACTION_TRIGGERED (1)
+function isActionTriggered(
+  _entity: Entity | undefined,
+  _inputHook: InputHook,
+  buttonAction: ButtonAction,
+) {
+  return getReturnValue(buttonAction, true);
+}
+
+// InputHook.GET_ACTION_VALUE (2)
+function getActionValue(
+  _entity: Entity | undefined,
+  _inputHook: InputHook,
+  buttonAction: ButtonAction,
+) {
+  return getReturnValue(buttonAction, false);
+}
+
+function getReturnValue(buttonAction: ButtonAction, booleanCallback: boolean) {
+  const disableValue = booleanCallback ? false : 0;
+
+  for (const whitelist of v.run.disableInputsWithWhitelistMap.values()) {
+    if (!whitelist.has(buttonAction)) {
+      return disableValue;
+    }
+  }
+
+  for (const blacklist of v.run.enableInputsWithBlacklistMap.values()) {
+    if (blacklist.has(buttonAction)) {
+      return disableValue;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Helper function to enable all inputs. Use this function to set things back to normal after having
+ * used one of the other helper functions to disable inputs.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function enableAllInputs(key: string): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  v.run.disableInputsWithWhitelistMap.delete(key);
+  v.run.enableInputsWithBlacklistMap.delete(key);
+}
+
+/**
+ * Helper function to disable all inputs. This is useful because `EntityPlayer.ControlsEnabled` can
+ * be changed by the game under certain conditions.
+ *
+ * Use the `enableAllInputs` helper function to set things back to normal.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function disableAllInputs(key: string): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  v.run.disableInputsWithWhitelistMap.set(key, new Set());
+  v.run.enableInputsWithBlacklistMap.delete(key);
+}
+
+/**
+ * Helper function to enable all inputs besides the ones provided. This is useful because
+ * `EntityPlayer.ControlsEnabled` can be changed by the game under certain conditions.
+ *
+ * Use the `enableAllInputs` helper function to set things back to normal.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ * @param blacklist A set of ButtonActions to disallow.
+ */
+export function enableAllInputsExceptFor(
+  key: string,
+  blacklist: Set<ButtonAction> | ReadonlySet<ButtonAction>,
+): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  v.run.disableInputsWithWhitelistMap.delete(key);
+  v.run.enableInputsWithBlacklistMap.set(key, blacklist);
+}
+
+/**
+ * Helper function to disable all inputs besides the ones provided. This is useful because
+ * `EntityPlayer.ControlsEnabled` can be changed by the game under certain conditions.
+ *
+ * Use the `enableAllInputs` helper function to set things back to normal.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ * @param whitelist A set of ButtonActions to allow.
+ */
+export function disableAllInputsExceptFor(
+  key: string,
+  whitelist: Set<ButtonAction>,
+): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  v.run.disableInputsWithWhitelistMap.set(key, whitelist);
+  v.run.enableInputsWithBlacklistMap.delete(key);
+}
+
+/**
+ * Helper function to disable only the inputs used for moving the character (or moving the cursor in
+ * the UI). This is useful because `EntityPlayer.ControlsEnabled` can be changed by the game under
+ * certain conditions.
+ *
+ * Use the `enableAllInputs` helper function to set things back to normal.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function disableMovementInputs(key: string): void {
+  const moveActions = getMoveActions();
+  enableAllInputsExceptFor(key, moveActions);
+}
+
+/**
+ * Helper function to disable only the inputs used for shooting tears. This is useful because
+ * `EntityPlayer.ControlsEnabled` can be changed by the game under certain conditions.
+ *
+ * Use the `enableAllInputs` helper function to set things back to normal.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function disableShootingInputs(key: string): void {
+  const shootActions = getShootActions();
+  enableAllInputsExceptFor(key, shootActions);
+}

package/features/disableSound.ts

@@ -0,0 +1,77 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { musicManager } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { stopAllSoundEffects } from "../functions/sound";
+import { saveDataManager } from "./saveDataManager/exports";
+
+const FEATURE_NAME = "sound disabler";
+
+let musicWasEnabled = false;
+
+const v = {
+  run: {
+    disableSoundSet: new Set<string>(),
+  },
+};
+
+/** @internal */
+export function disableSoundsInit(mod: Mod): void {
+  saveDataManager("disableSounds", v);
+
+  mod.AddCallback(ModCallback.POST_RENDER, postRender);
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (v.run.disableSoundSet.size === 0) {
+    return;
+  }
+
+  stopAllSoundEffects();
+}
+
+/**
+ * Helper function to stop muting all sound effects and music.
+ *
+ * Use this function to set things back to normal after having used `disableAllSounds`.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function enableAllSound(key: string): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  if (!v.run.disableSoundSet.has(key)) {
+    return;
+  }
+  v.run.disableSoundSet.delete(key);
+
+  if (v.run.disableSoundSet.size === 0 && musicWasEnabled) {
+    musicManager.Enable();
+  }
+
+  // Stop all sound effects that were initialized prior to enabling sounds (in case there was a
+  // sound played played previously on this render frame).
+  stopAllSoundEffects();
+}
+
+/**
+ * Helper function to disable all sound effects and music (by constantly musting them).
+ *
+ * Use the `enableAllSounds` helper function to set things back to normal.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function disableAllSound(key: string): void {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+
+  if (v.run.disableSoundSet.size === 0) {
+    musicWasEnabled = musicManager.IsEnabled();
+  }
+
+  v.run.disableSoundSet.add(key);
+
+  // Stop all sound effects that were initialized prior to disabling sounds.
+  stopAllSoundEffects();
+}

package/features/extraConsoleCommands/commandsDisplay.ts

@@ -0,0 +1,290 @@
+import {
+  toggleBombDisplay,
+  toggleDoorDisplay,
+  toggleEffectDisplay,
+  toggleFamiliarDisplay,
+  toggleKnifeDisplay,
+  toggleLaserDisplay,
+  toggleNPCDisplay,
+  togglePickupDisplay,
+  togglePitDisplay,
+  togglePlayerDisplay,
+  togglePoopDisplay,
+  togglePressurePlateDisplay,
+  toggleProjectileDisplay,
+  toggleRockDisplay,
+  toggleSlotDisplay,
+  toggleSpikesDisplay,
+  toggleTearDisplay,
+  toggleTNTDisplay,
+} from "../debugDisplay/exports";
+
+/**
+ * Toggles custom text to appear next to every bomb. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setBombDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function bombDisplay(): void {
+  toggleBombDisplay();
+}
+
+/** Alias for the "bombDisplay" command. */
+export function bombsDisplay(): void {
+  bombDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every door. Useful for debugging.
+ *
+ * By default, the grid entity ID will be displayed. Use the `setDoorDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function doorDisplay(): void {
+  toggleDoorDisplay();
+}
+
+/** Alias for the "doorDisplay" command. */
+export function doorsDisplay(): void {
+  doorDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every effect. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setEffectDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function effectDisplay(): void {
+  toggleEffectDisplay();
+}
+
+/** Alias for the "effectDisplay" command. */
+export function effectsDisplay(): void {
+  effectDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every familiar. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setFamiliarDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function familiarDisplay(): void {
+  toggleFamiliarDisplay();
+}
+
+/** Alias for the "familiarDisplay" command. */
+export function familiarsDisplay(): void {
+  familiarDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every knife. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setKnifeDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function knifeDisplay(): void {
+  toggleKnifeDisplay();
+}
+
+/** Alias for the "knifeDisplay" command. */
+export function knivesDisplay(): void {
+  knifeDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every laser. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setLaserDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function laserDisplay(): void {
+  toggleLaserDisplay();
+}
+
+/** Alias for the "laserDisplay" command. */
+export function lasersDisplay(): void {
+  laserDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every NPC. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setNPCDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function npcDisplay(): void {
+  toggleNPCDisplay();
+}
+
+/** Alias for the "npcDisplay" command. */
+export function npcsDisplay(): void {
+  npcDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every pickup. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setPickupDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function pickupDisplay(): void {
+  togglePickupDisplay();
+}
+
+/** Alias for the "pickupDisplay" command. */
+export function pickupsDisplay(): void {
+  pickupDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every pit. Useful for debugging.
+ *
+ * By default, the grid entity ID will be displayed. Use the `setPitDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function pitDisplay(): void {
+  togglePitDisplay();
+}
+
+/** Alias for the "pitDisplay" command. */
+export function pitsDisplay(): void {
+  pitDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every player. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setPlayerDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function playerDisplay(): void {
+  togglePlayerDisplay();
+}
+
+/** Alias for the "playerDisplay" command. */
+export function playersDisplay(): void {
+  playerDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every poop. Useful for debugging.
+ *
+ * By default, the grid entity ID will be displayed. Use the `setPoopDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function poopDisplay(): void {
+  togglePoopDisplay();
+}
+
+/** Alias for the "poopDisplay" command. */
+export function poopsDisplay(): void {
+  poopDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every pressure plate. Useful for debugging.
+ *
+ * By default, the grid entity ID will be displayed. Use the `setPressurePlateDisplay` helper
+ * function to assign the text that you want to appear.
+ */
+export function pressurePlateDisplay(): void {
+  togglePressurePlateDisplay();
+}
+
+/** Alias for the "pressurePlateDisplay" command. */
+export function pressurePlatesDisplay(): void {
+  pressurePlateDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every projectile. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setProjectileDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function projectileDisplay(): void {
+  toggleProjectileDisplay();
+}
+
+/** Alias for the "projectileDisplay" command. */
+export function projectilesDisplay(): void {
+  projectileDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every rock. Useful for debugging.
+ *
+ * By default, the grid entity ID will be displayed. Use the `setRockDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function rockDisplay(): void {
+  toggleRockDisplay();
+}
+
+/** Alias for the "rockDisplay" command. */
+export function rocksDisplay(): void {
+  rockDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every slot. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setSlotDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function slotDisplay(): void {
+  toggleSlotDisplay();
+}
+
+/** Alias for the "slotDisplay" command. */
+export function slotsDisplay(): void {
+  slotDisplay();
+}
+
+/** Alias for the "spikesDisplay" command. */
+export function spikeDisplay(): void {
+  spikesDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every spikes. Useful for debugging.
+ *
+ * By default, the grid entity ID will be displayed. Use the `setSpikesDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function spikesDisplay(): void {
+  toggleSpikesDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every tear. Useful for debugging.
+ *
+ * By default, the entity ID will be displayed. Use the `setTearDisplay` helper function to assign
+ * the text that you want to appear.
+ */
+export function tearDisplay(): void {
+  toggleTearDisplay();
+}
+
+/** Alias for the "tearDisplay" command. */
+export function tearsDisplay(): void {
+  tearDisplay();
+}
+
+/**
+ * Toggles custom text to appear next to every TNT. Useful for debugging.
+ *
+ * By default, the grid entity ID will be displayed. Use the `setTNTDisplay` helper function to
+ * assign the text that you want to appear.
+ */
+export function tntDisplay(): void {
+  toggleTNTDisplay();
+}
+
+/** Alias for the "tntDisplay" command. */
+export function tntsDisplay(): void {
+  tntDisplay();
+}

package/features/extraConsoleCommands/commandsSubroutines.lua

@@ -108,7 +108,7 @@ function ____exports.spawnTrapdoorOrCrawlspace(self, trapdoor)
 end
 function ____exports.warpToRoomType(self, roomType)
     local roomTypeName = ROOM_TYPE_NAMES[roomType]
-    if roomTypeName == nil or roomTypeName == DEFAULT_ROOM_TYPE_NAME then
+    if roomTypeName == DEFAULT_ROOM_TYPE_NAME then
         printConsole(
             nil,
             "Invalid room type: " .. tostring(roomType)

package/features/extraConsoleCommands/commandsSubroutines.ts

@@ -0,0 +1,139 @@
+import {
+  Direction,
+  EntityType,
+  GridEntityType,
+  GridRoom,
+  RoomType,
+} from "isaac-typescript-definitions";
+import { game } from "../../cachedClasses";
+import { HealthType } from "../../enums/HealthType";
+import { directionToVector } from "../../functions/direction";
+import { spawnGridWithVariant } from "../../functions/gridEntity";
+import { logEntities, logGridEntities } from "../../functions/log";
+import { addPlayerHealthType } from "../../functions/playerHealth";
+import { getRoomData, getRoomDescriptor } from "../../functions/roomData";
+import { changeRoom, getRoomGridIndexesForType } from "../../functions/rooms";
+import { printConsole } from "../../functions/utils";
+import {
+  DEFAULT_ROOM_TYPE_NAME,
+  ROOM_TYPE_NAMES,
+} from "../../objects/roomTypeNames";
+
+const DEFAULT_MOVE_UNITS = 0.5;
+
+export function addHeart(params: string, healthType: HealthType): void {
+  let numHearts = healthType === HealthType.MAX_HEARTS ? 2 : 1;
+  if (params !== "") {
+    const num = tonumber(params);
+    if (num === undefined) {
+      printConsole("That is an invalid amount of hearts to add.");
+      return;
+    }
+
+    numHearts = num;
+  }
+
+  const player = Isaac.GetPlayer();
+  addPlayerHealthType(player, healthType, numHearts);
+}
+
+export function devilAngel(useDevil: boolean): void {
+  const level = game.GetLevel();
+
+  const devilAngelRoomData = getRoomData(GridRoom.DEVIL);
+  if (devilAngelRoomData !== undefined) {
+    const roomType = devilAngelRoomData.Type;
+    const conflictingType = useDevil ? RoomType.ANGEL : RoomType.DEVIL;
+    if (roomType === conflictingType) {
+      // Delete the room data, which will allow the `Level.InitializeDevilAngelRoom` method to work.
+      const roomDescriptor = getRoomDescriptor(GridRoom.DEVIL);
+      roomDescriptor.Data = undefined;
+    }
+  }
+
+  if (useDevil) {
+    level.InitializeDevilAngelRoom(false, true);
+  } else {
+    level.InitializeDevilAngelRoom(true, false);
+  }
+
+  changeRoom(GridRoom.DEVIL);
+}
+
+export function listEntities(
+  params: string,
+  includeBackgroundEffects: boolean,
+): void {
+  let entityTypeFilter: EntityType | undefined;
+  if (params !== "") {
+    entityTypeFilter = tonumber(params);
+    if (entityTypeFilter === undefined) {
+      printConsole("That is an invalid entity type to filter by.");
+      return;
+    }
+  }
+
+  logEntities(includeBackgroundEffects, entityTypeFilter);
+  printConsole('Logged the entities in the room to the "log.txt" file.');
+}
+
+export function listGridEntities(params: string, includeWalls: boolean): void {
+  let gridEntityTypeFilter: GridEntityType | undefined;
+  if (params !== "") {
+    gridEntityTypeFilter = tonumber(params);
+    if (gridEntityTypeFilter === undefined) {
+      printConsole("That is an invalid grid entity type to filter by.");
+      return;
+    }
+  }
+
+  logGridEntities(includeWalls, gridEntityTypeFilter);
+  printConsole('Logged the grid entities in the room to the "log.txt" file.');
+}
+
+export function movePlayer(params: string, direction: Direction): void {
+  let amount = DEFAULT_MOVE_UNITS;
+  if (params !== "") {
+    const num = tonumber(params);
+    if (num === undefined) {
+      printConsole("That is an invalid amount of units to move.");
+      return;
+    }
+
+    amount = num;
+  }
+
+  const player = Isaac.GetPlayer();
+  const vector = directionToVector(direction);
+  const modifiedVector = vector.mul(amount);
+  player.Position = player.Position.add(modifiedVector);
+}
+
+export function spawnTrapdoorOrCrawlspace(trapdoor: boolean): void {
+  const room = game.GetRoom();
+  const player = Isaac.GetPlayer();
+  const position = room.FindFreeTilePosition(player.Position, 0);
+  const gridIndex = room.GetGridIndex(position);
+  const gridEntityType = trapdoor
+    ? GridEntityType.TRAPDOOR
+    : GridEntityType.CRAWL_SPACE;
+
+  spawnGridWithVariant(gridEntityType, 0, gridIndex);
+}
+
+export function warpToRoomType(roomType: RoomType): void {
+  const roomTypeName = ROOM_TYPE_NAMES[roomType];
+  if (roomTypeName === DEFAULT_ROOM_TYPE_NAME) {
+    printConsole(`Invalid room type: ${roomType}`);
+  }
+
+  const gridIndexes = getRoomGridIndexesForType(roomType);
+  const firstGridIndex = gridIndexes[0];
+  if (firstGridIndex === undefined) {
+    printConsole(`There are no ${roomTypeName}s on this floor.`);
+    return;
+  }
+
+  changeRoom(firstGridIndex);
+  printConsole(`Warped to room type: ${roomTypeName} (${roomType})`);
+}