isaacscript-common 6.10.1 → 6.11.1

package/src/features/customStage/versusScreen.ts

@@ -66,30 +66,38 @@ const PLAYER_PORTRAIT_PNG_PATH_PREFIX = "gfx/ui/stage";
 const VANILLA_VERSUS_PLAYBACK_SPEED = 0.5;
 
 const versusScreenSprite = Sprite();
-versusScreenSprite.Load("gfx/ui/boss/versusscreen.anm2", false);
-
-// In vanilla, the "overlay.png" file has a white background. We must convert it to a PNG that uses
-// a transparent background in order for the background behind it to be visible. We use the same
-// "overlay.png" file as StageAPI uses for this purpose.
-versusScreenSprite.ReplaceSpritesheet(
-  OVERLAY_ANM2_LAYER,
-  `${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/overlay.png`,
-);
-versusScreenSprite.LoadGraphics();
 
 /**
  * Unfortunately, we must split the background layer into an entirely different sprite so that we
  * can color it with the `Color` property.
  */
 const versusScreenBackgroundSprite = Sprite();
-versusScreenBackgroundSprite.Load("gfx/ui/boss/versusscreen.anm2", true);
 
 /**
  * Unfortunately, we must split the dirt layer into an entirely different sprite so that we can
  * color it with the `Color` property.
  */
 const versusScreenDirtSpotSprite = Sprite();
-versusScreenDirtSpotSprite.Load("gfx/ui/boss/versusscreen.anm2", true);
+
+/**
+ * We must load the sprites in an init function to prevent issues with mods that replace the vanilla
+ * files. (For some reason, loading the sprites will cause the overwrite to no longer apply on the
+ * second and subsequent runs.)
+ */
+export function versusScreenInit(): void {
+  // In vanilla, the "overlay.png" file has a white background. We must convert it to a PNG that
+  // uses a transparent background in order for the background behind it to be visible. We use the
+  // same "overlay.png" file as StageAPI uses for this purpose.
+  versusScreenSprite.Load("gfx/ui/boss/versusscreen.anm2", false);
+  versusScreenSprite.ReplaceSpritesheet(
+    OVERLAY_ANM2_LAYER,
+    `${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/overlay.png`,
+  );
+  versusScreenSprite.LoadGraphics();
+
+  versusScreenBackgroundSprite.Load("gfx/ui/boss/versusscreen.anm2", true);
+  versusScreenDirtSpotSprite.Load("gfx/ui/boss/versusscreen.anm2", true);
+}
 
 export function playVersusScreenAnimation(customStage: CustomStage): void {
   const room = game.GetRoom();

package/src/features/customTrapdoor/customTrapdoorConstants.ts

@@ -0,0 +1,13 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export const CUSTOM_TRAPDOOR_FEATURE_NAME = "customTrapdoor";
+
+/** This also applies to crawl spaces. The value was determined through trial and error. */
+export const TRAPDOOR_OPEN_DISTANCE = 60;
+
+export const TRAPDOOR_OPEN_DISTANCE_AFTER_BOSS = TRAPDOOR_OPEN_DISTANCE * 2.5;
+export const TRAPDOOR_BOSS_REACTION_FRAMES = 30;
+
+export const GridEntityTypeCustom = {
+  TRAPDOOR_CUSTOM: 1000 as GridEntityType,
+} as const;

package/src/features/customTrapdoor/exports.ts

@@ -0,0 +1,168 @@
+import {
+  GridCollisionClass,
+  LevelStage,
+  RoomType,
+  StageType,
+} from "isaac-typescript-definitions";
+import { game } from "../../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../../featuresInitialized";
+import { getNextStage, getNextStageType } from "../../functions/nextStage";
+import { anyPlayerCloserThan } from "../../functions/positionVelocity";
+import { spawnCustomGridEntity } from "../customGridEntity";
+import { getRoomClearGameFrame } from "../roomClearFrame";
+import {
+  CUSTOM_TRAPDOOR_FEATURE_NAME,
+  GridEntityTypeCustom,
+  TRAPDOOR_BOSS_REACTION_FRAMES,
+  TRAPDOOR_OPEN_DISTANCE,
+  TRAPDOOR_OPEN_DISTANCE_AFTER_BOSS,
+} from "./customTrapdoorConstants";
+import { getCustomTrapdoorDescription } from "./v";
+
+/**
+ * Helper function to spawn a trapdoor grid entity that will have one or more of the following
+ * attributes:
+ *
+ * - custom destination (or custom logic for after the player enters)
+ * - custom graphics
+ * - custom logic for opening/closing
+ * - TODO: animation
+ *
+ * You can use this function to take the player to your custom stage.
+ *
+ * Under the hood, the custom trapdoor is represented by a decoration grid entity and is manually
+ * respawned every time the player re-enters the room.
+ *
+ * @param gridIndexOrPosition The location in the room to spawn the trapdoor.
+ * @param _destination Used to specify where the player will go after jumping into the trapdoor. Can
+ *                     either be a tuple containing the stage and stage type, a string containing
+ *                     the name of a custom stage, or undefined. If undefined, nothing will happen
+ *                     after the player jumps in the trapdoor. (Use undefined to perform some custom
+ *                     behavior and/or handle the traveling part yourself.) You can also specify a
+ *                     function that returns one of these things. By default, the destination will
+ *                     be set to the next floor like that of a vanilla trapdoor.
+ * @param anm2Path Optional. The path to the anm2 file to use. By default, the vanilla trapdoor anm2
+ *                 of "gfx/grid/door_11_trapdoor.anm2" will be used.
+ * @param _shouldOpenFunc Optional. If the trapdoor is currently closed, this function will run on
+ *                        every frame to determine if it should open. By default, a function that
+ *                        emulates a vanilla trapdoor will be used.
+ * @param _shouldCloseFunc Optional. If the trapdoor is currently open, this function will run on
+ *                         every frame to determine if it should close. By default, a function that
+ *                         emulates a vanilla trapdoor will be used.
+ * @param _spawnOpen Optional. Whether or not to spawn the trapdoor in an open state. Can either be
+ *                   a boolean or a function returning a boolean. By default, a function that
+ *                   emulates a vanilla trapdoor will be used.
+ */
+export function spawnCustomTrapdoor(
+  gridIndexOrPosition: int | Vector,
+  _destination:
+    | [stage: LevelStage, stageType: StageType]
+    | string
+    | ((
+        gridEntity: GridEntity,
+      ) =>
+        | [stage: LevelStage, stageType: StageType]
+        | string
+        | undefined) = defaultDestinationFunc,
+  anm2Path = "gfx/grid/door_11_trapdoor.anm2",
+  _shouldOpenFunc: (gridEntity: GridEntity) => boolean = defaultShouldOpenFunc,
+  _shouldCloseFunc: (
+    gridEntity: GridEntity,
+  ) => boolean = defaultShouldCloseFunc,
+  _spawnOpen:
+    | boolean
+    | ((gridEntity: GridEntity) => boolean) = defaultShouldSpawnOpenFunc,
+): GridEntity {
+  errorIfFeaturesNotInitialized(CUSTOM_TRAPDOOR_FEATURE_NAME);
+
+  // TODO
+  return spawnCustomGridEntity(
+    GridEntityTypeCustom.TRAPDOOR_CUSTOM,
+    gridIndexOrPosition,
+    anm2Path,
+    "Closed",
+    GridCollisionClass.NONE,
+  );
+}
+
+function defaultDestinationFunc(): [stage: LevelStage, stageType: StageType] {
+  const nextStage = getNextStage();
+  const nextStageType = getNextStageType();
+
+  return [nextStage, nextStageType];
+}
+
+function defaultShouldOpenFunc(gridEntity: GridEntity): boolean {
+  const trapdoorDescription = getCustomTrapdoorDescription(gridEntity);
+  if (trapdoorDescription === undefined) {
+    return false;
+  }
+
+  const room = game.GetRoom();
+  const roomClear = room.IsClear();
+
+  return (
+    !anyPlayerCloserThan(gridEntity.Position, TRAPDOOR_OPEN_DISTANCE) &&
+    !isPlayerCloseAfterBoss(gridEntity.Position) &&
+    !shouldBeClosedFromStartingInRoomWithEnemies(
+      trapdoorDescription.firstSpawn,
+      roomClear,
+    )
+  );
+}
+
+function isPlayerCloseAfterBoss(position: Vector) {
+  const gameFrameCount = game.GetFrameCount();
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const roomClearGameFrame = getRoomClearGameFrame();
+
+  // In order to prevent a player from accidentally entering a freshly-spawned trapdoor after
+  // killing the boss of the floor, we use a wider open distance for a short amount of frames.
+  if (
+    roomType !== RoomType.BOSS ||
+    roomClearGameFrame === undefined ||
+    gameFrameCount >= roomClearGameFrame + TRAPDOOR_BOSS_REACTION_FRAMES
+  ) {
+    return false;
+  }
+
+  return anyPlayerCloserThan(position, TRAPDOOR_OPEN_DISTANCE_AFTER_BOSS);
+}
+
+function shouldBeClosedFromStartingInRoomWithEnemies(
+  firstSpawn: boolean,
+  roomClear: boolean,
+) {
+  return firstSpawn && !roomClear;
+}
+
+/** By default, trapdoors will never close if they are already open. */
+function defaultShouldCloseFunc(): boolean {
+  return false;
+}
+
+function defaultShouldSpawnOpenFunc(gridEntity: GridEntity): boolean {
+  const room = game.GetRoom();
+  const roomFrameCount = room.GetFrameCount();
+  const roomClear = room.IsClear();
+
+  // Trapdoors created after a room has already initialized should spawn closed by default:
+  // - Trapdoors created after bosses should spawn closed so that players do not accidentally jump
+  //   into them.
+  // - Trapdoors created by We Need to Go Deeper should spawn closed because the player will be
+  //   standing on top of them.
+  if (roomFrameCount > 0) {
+    return false;
+  }
+
+  // If we just entered a new room with enemies in it, spawn the trapdoor closed so that the player
+  // has to defeat the enemies first before using the trapdoor.
+  if (!roomClear) {
+    return false;
+  }
+
+  // If we just entered a new room that is already cleared, spawn the trapdoor closed if we are
+  // standing close to it, and open otherwise.
+  return defaultShouldOpenFunc(gridEntity);
+}

package/src/features/customTrapdoor/v.ts

@@ -0,0 +1,20 @@
+import { StageTravelState } from "../../enums/private/StageTravelState";
+import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
+
+const v = {
+  run: {
+    state: StageTravelState.NONE,
+  },
+
+  room: {
+    /** Indexed by grid index. */
+    trapdoors: new Map<int, CustomTrapdoorDescription>(),
+  },
+};
+
+export function getCustomTrapdoorDescription(
+  gridEntity: GridEntity,
+): CustomTrapdoorDescription | undefined {
+  const gridIndex = gridEntity.GetGridIndex();
+  return v.room.trapdoors.get(gridIndex);
+}

package/src/features/deployJSONRoom.ts

@@ -4,6 +4,7 @@
 // it from scratch based on the JSON data.
 
 import {
+  ActiveSlot,
   CollectibleType,
   EffectVariant,
   EntityCollisionClass,
@@ -16,6 +17,7 @@ import {
   PickupVariant,
   PitfallVariant,
   RoomType,
+  UseFlag,
 } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
 import { DefaultMap } from "../classes/DefaultMap";
@@ -113,6 +115,9 @@ function preUseItemWeNeedToGoDeeper(
   _collectibleType: CollectibleType,
   _rng: RNG,
   player: EntityPlayer,
+  _useFlags: BitFlags<UseFlag>,
+  _activeSlot: ActiveSlot,
+  _customVarData: int,
 ): boolean | undefined {
   if (v.room.manuallyUsingShovel) {
     return undefined;

package/src/features/extraConsoleCommands/listCommands.ts

@@ -50,7 +50,7 @@ import {
 } from "../../constantsFirstLast";
 import { HealthType } from "../../enums/HealthType";
 import { getCardName } from "../../functions/cards";
-import { getCharacterName } from "../../functions/character";
+import { getCharacterName } from "../../functions/characters";
 import { addCharge } from "../../functions/charge";
 import { isValidCollectibleType } from "../../functions/collectibles";
 import { runDeepCopyTests } from "../../functions/deepCopyTests";

package/src/functions/{character.ts → characters.ts}

@@ -1,5 +1,6 @@
 import { PlayerType } from "isaac-typescript-definitions";
 import { LAST_VANILLA_CHARACTER } from "../constantsFirstLast";
+import { CHARACTER_DAMAGE_MULTIPLIERS } from "../objects/characterDamageMultipliers";
 import { CHARACTER_NAMES } from "../objects/characterNames";
 import { CHARACTERS_THAT_START_WITH_AN_ACTIVE_ITEM_SET } from "../sets/charactersThatStartWithAnActiveItemSet";
 import { CHARACTERS_WITH_BLACK_HEART_FROM_ETERNAL_HEART_SET } from "../sets/charactersWithBlackHeartFromEternalHeartSet";
@@ -56,6 +57,18 @@ export function characterStartsWithActiveItem(character: PlayerType): boolean {
   return CHARACTERS_THAT_START_WITH_AN_ACTIVE_ITEM_SET.has(character);
 }
 
+/** Helper function to get the numerical damage multiplier for a character. */
+export function getCharacterDamageMultiplier(
+  character: PlayerType,
+  hasWhoreOfBabylon = false,
+): float {
+  if (character === PlayerType.EVE && hasWhoreOfBabylon) {
+    return 1.0;
+  }
+
+  return CHARACTER_DAMAGE_MULTIPLIERS[character];
+}
+
 /**
  * - Most characters have a 56 frame death animation (i.e. the "Death" animation).
  * - The Lost and Tainted Lost have a 38 frame death animation (i.e. the "LostDeath" animation).

package/src/functions/deepCopy.ts

@@ -568,6 +568,14 @@ function getCopiedEntries(
     entries.sort(twoDimensionalSort);
   }
 
+  // During serialization, we brand some Lua tables with a special identifier to signify that it has
+  // keys that should be deserialized to numbers.
+  const convertStringKeysToNumbers =
+    serializationType === SerializationType.DESERIALIZE &&
+    entries.some(
+      ([key]) => key === (SerializationBrand.OBJECT_WITH_NUMBER_KEYS as string),
+    );
+
   const hasNumberKeys = entries.some(([key]) => isNumber(key));
   const convertNumberKeysToStrings =
     serializationType === SerializationType.SERIALIZE && hasNumberKeys;
@@ -589,7 +597,16 @@ function getCopiedEntries(
       insideMap,
     );
 
-    const keyToUse = convertNumberKeysToStrings ? tostring(key) : key;
+    let keyToUse = key;
+    if (convertStringKeysToNumbers) {
+      const numberKey = tonumber(key);
+      if (numberKey !== undefined) {
+        keyToUse = numberKey;
+      }
+    }
+    if (convertNumberKeysToStrings) {
+      keyToUse = tostring(key);
+    }
     copiedEntries.push([keyToUse, newValue]);
   }
 

package/src/functions/deepCopyTests.ts

@@ -32,6 +32,12 @@ export function runDeepCopyTests(): void {
   copiedDefaultMapHasChildDefaultMap();
   copiedDefaultMapHasBrand();
 
+  copiedSerializedMapHasStringKey();
+  copiedSerializedMapHasNumberKey();
+
+  copiedSerializedDefaultMapHasStringKey();
+  copiedSerializedDefaultMapHasNumberKey();
+
   log("All deep copy tests passed!");
 }
 
@@ -457,3 +463,109 @@ function copiedDefaultMapHasBrand() {
     );
   }
 }
+
+function copiedSerializedMapHasStringKey() {
+  const mapKey = "123";
+  const mapValue = 456;
+  const oldMap = new Map<string, number>();
+  oldMap.set(mapKey, mapValue);
+
+  const serializedOldMap = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedMapHasStringKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedMapHasStringKey-deserialize",
+  );
+
+  const newMap = newTable as Map<string, number>;
+  if (!newMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
+    );
+  }
+}
+
+function copiedSerializedMapHasNumberKey() {
+  const mapKey = 123;
+  const mapValue = 456;
+  const oldMap = new Map<number, number>();
+  oldMap.set(mapKey, mapValue);
+
+  const serializedOldMap = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedMapHasNumberKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedMapHasNumberKey-deserialize",
+  );
+
+  const newMap = newTable as Map<number, number>;
+  if (!newMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
+    );
+  }
+}
+
+function copiedSerializedDefaultMapHasStringKey() {
+  const mapKey = "123";
+  const oldDefaultMap = new DefaultMap<string, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
+
+  const serializedOldDefaultMap = deepCopy(
+    oldDefaultMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedDefaultMapHasStringKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldDefaultMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedDefaultMapHasStringKey-deserialize",
+  );
+
+  const newDefaultMap = newTable as DefaultMap<string, number>;
+  if (!newDefaultMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied DefaultMap did not have a key of "${mapKey}" with type: ${keyType}`,
+    );
+  }
+}
+
+function copiedSerializedDefaultMapHasNumberKey() {
+  const mapKey = 123;
+  const oldDefaultMap = new DefaultMap<number, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
+
+  const serializedOldDefaultMap = deepCopy(
+    oldDefaultMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedDefaultMapHasNumberKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldDefaultMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedDefaultMapHasNumberKey-deserialize",
+  );
+
+  const newDefaultMap = newTable as DefaultMap<number, number>;
+  if (!newDefaultMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied DefaultMap did not have a key of: ${mapKey} with type ${keyType}`,
+    );
+  }
+}

package/src/functions/jsonHelpers.ts

@@ -1,12 +1,12 @@
-import * as json from "json";
+import * as jsonLua from "../lib/jsonLua";
 import { logError } from "./log";
 
 function tryDecode(this: void, jsonString: string) {
-  return json.decode(jsonString) as LuaMap;
+  return jsonLua.decode(jsonString) as LuaMap;
 }
 
 function tryEncode(this: void, luaTable: unknown) {
-  return json.encode(luaTable);
+  return jsonLua.encode(luaTable);
 }
 
 /**
@@ -16,6 +16,9 @@ function tryEncode(this: void, luaTable: unknown) {
  * fails, it will return a blank Lua table instead of throwing an error. (This allows execution to
  * continue in cases where users have no current save data or have manually removed their existing
  * save data.)
+ *
+ * Under the hood, this uses a custom JSON parser that was measured to be 11.8 times faster than the
+ * vanilla JSON parser.
  */
 export function jsonDecode(jsonString: string): LuaMap<AnyNotNil, unknown> {
   const [ok, luaTableOrErrMsg] = pcall(tryDecode, jsonString);
@@ -34,6 +37,9 @@ export function jsonDecode(jsonString: string): LuaMap<AnyNotNil, unknown> {
  * In most cases, this function will be used for writing data to a "save#.dat" file. If encoding
  * fails, it will throw an error to prevent writing a blank string or corrupted data to a user's
  * "save#.dat" file.
+ *
+ * Under the hood, this uses a custom JSON parser that was measured to be 11.8 times faster than the
+ * vanilla JSON parser.
  */
 export function jsonEncode(luaTable: unknown): string {
   const [ok, jsonStringOrErrMsg] = pcall(tryEncode, luaTable);

package/src/functions/mergeTests.ts

@@ -266,8 +266,6 @@ function oldTableHasFilledDefaultMap() {
 }
 
 function oldTableHasVector() {
-  log("Starting test: oldTableHasVector");
-
   interface Foo {
     bar: Vector;
   }
@@ -307,8 +305,6 @@ function oldTableHasVector() {
 }
 
 function oldTableHasVectorSerialized() {
-  log("Starting test: oldTableHasVectorSerialized");
-
   interface Foo {
     bar: Vector;
   }
@@ -355,8 +351,6 @@ function oldTableHasVectorSerialized() {
 }
 
 function oldTableHasRNG() {
-  log("Starting test: oldTableHasRNG");
-
   interface Foo {
     bar: RNG;
   }
@@ -392,8 +386,6 @@ function oldTableHasRNG() {
 }
 
 function oldTableHasRNGSerialized() {
-  log("Starting test: oldTableHasRNGSerialized");
-
   interface Foo {
     bar: RNG;
   }

package/src/functions/playerIndex.ts

@@ -28,6 +28,10 @@ export function getAllPlayers(): EntityPlayer[] {
   return players;
 }
 
+/**
+ * Helper function to get the corresponding `EntityPlayer` object that corresponds to a
+ * `PlayerIndex`.
+ */
 export function getPlayerFromIndex(
   playerIndex: PlayerIndex,
 ): EntityPlayer | undefined {
@@ -194,8 +198,8 @@ export function getSubPlayerParent(
 }
 
 /**
- * Some players are "child" players, meaning that they have a non-undefined Parent property. (For
- * example, the Strawman Keeper.)
+ * Helper function to detect if a particular player is a "child" player, meaning that they have a
+ * non-undefined `EntityPlayer.Parent` property. (For example, the Strawman Keeper.)
  */
 export function isChildPlayer(player: EntityPlayer): boolean {
   return player.Parent !== undefined;

package/src/functions/players.ts

@@ -17,7 +17,7 @@ import {
   getCharacterMaxHeartContainers,
   getCharacterName,
   isVanillaCharacter,
-} from "./character";
+} from "./characters";
 import { getCollectibleMaxCharges } from "./collectibles";
 import { getCollectibleArray } from "./collectibleSet";
 import { getEnumValues } from "./enums";

package/src/functions/revive.ts

@@ -10,7 +10,7 @@ import {
   MAX_TAINTED_SAMSON_BERSERK_CHARGE,
   TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE,
 } from "../constants";
-import { getCharacterDeathAnimationName } from "./character";
+import { getCharacterDeathAnimationName } from "./characters";
 import {
   getPlayerMaxHeartContainers,
   getPlayerNumHitsRemaining,

package/src/index.ts

@@ -22,8 +22,12 @@ export {
 } from "./features/characterHealthConversion";
 export { registerCharacterStats } from "./features/characterStats";
 export { getCollectibleItemPoolType } from "./features/collectibleItemPoolType";
-export { removeCustomGrid, spawnCustomGrid } from "./features/customGridEntity";
+export {
+  removeCustomGrid,
+  spawnCustomGridEntity as spawnCustomGrid,
+} from "./features/customGridEntity";
 export * from "./features/customStage/exports";
+export * from "./features/customTrapdoor/exports";
 export * from "./features/debugDisplay/exports";
 export {
   deployJSONRoom,
@@ -82,7 +86,7 @@ export * from "./functions/bosses";
 export * from "./functions/cacheFlag";
 export * from "./functions/cards";
 export * from "./functions/challenges";
-export * from "./functions/character";
+export * from "./functions/characters";
 export * from "./functions/charge";
 export * from "./functions/chargeBar";
 export * from "./functions/collectibleCacheFlag";

package/src/initCustomCallbacks.ts

@@ -37,8 +37,9 @@ import { postPlayerChangeHealthInit } from "./callbacks/postPlayerChangeHealth";
 import { postPlayerChangeTypeInit } from "./callbacks/postPlayerChangeType";
 import { postPlayerCollectibleCallbacksInit } from "./callbacks/postPlayerCollectible";
 import { postPlayerFatalDamageInit } from "./callbacks/postPlayerFatalDamage";
+import { postPlayerInitFirstInit } from "./callbacks/postPlayerInitFirst";
 import { postPlayerInitLateInit } from "./callbacks/postPlayerInitLate";
-import { postPlayerReorderedCallbacksInit } from "./callbacks/postPlayerReordered";
+import { postPlayerReorderedCallbacksInit } from "./callbacks/postPlayerReorderedCallbacks";
 import { postPoopRenderInit } from "./callbacks/postPoopRender";
 import { postPoopUpdateInit } from "./callbacks/postPoopUpdate";
 import { postPressurePlateRenderInit } from "./callbacks/postPressurePlateRender";
@@ -105,6 +106,7 @@ export function initCustomCallbacks(mod: ModUpgraded): void {
   postPlayerChangeTypeInit(mod);
   postPlayerCollectibleCallbacksInit(mod);
   postPlayerFatalDamageInit(mod);
+  postPlayerInitFirstInit(mod);
   postPlayerInitLateInit(mod);
   postPlayerReorderedCallbacksInit(mod);
   postPoopRenderInit(mod);

package/src/initFeatures.ts

@@ -23,7 +23,12 @@ import { sirenHelpersInit } from "./features/sirenHelpers";
 import { stageHistoryInit } from "./features/stageHistory";
 import { taintedLazarusPlayersInit } from "./features/taintedLazarusPlayers";
 
-export function initFeaturesMajor(mod: ModUpgraded): void {
+export function initFeatures(mod: ModUpgraded): void {
+  initFeaturesMajor(mod);
+  initFeaturesMinor(mod);
+}
+
+function initFeaturesMajor(mod: ModUpgraded) {
   customStageInit(mod);
   deployJSONRoomInit(mod);
   runInNFramesInit(mod);
@@ -32,7 +37,7 @@ export function initFeaturesMajor(mod: ModUpgraded): void {
   customGridEntityInit(mod);
 }
 
-export function initFeaturesMinor(mod: ModUpgraded): void {
+function initFeaturesMinor(mod: ModUpgraded) {
   disableAllSoundInit(mod);
   disableInputsInit(mod);
   fadeInRemoverInit(mod);

package/src/interfaces/AddCallbackParameterCustom.ts

@@ -50,8 +50,8 @@ import { PostPlayerChangeTypeRegisterParameters } from "../callbacks/subscriptio
 import { PostPlayerCollectibleAddedRegisterParameters } from "../callbacks/subscriptions/postPlayerCollectibleAdded";
 import { PostPlayerCollectibleRemovedRegisterParameters } from "../callbacks/subscriptions/postPlayerCollectibleRemoved";
 import { PostPlayerFatalDamageRegisterParameters } from "../callbacks/subscriptions/postPlayerFatalDamage";
+import { PostPlayerInitFirstRegisterParameters } from "../callbacks/subscriptions/postPlayerInitFirst";
 import { PostPlayerInitLateRegisterParameters } from "../callbacks/subscriptions/postPlayerInitLate";
-import { PostPlayerInitReorderedRegisterParameters } from "../callbacks/subscriptions/postPlayerInitReordered";
 import { PostPlayerRenderReorderedRegisterParameters } from "../callbacks/subscriptions/postPlayerRenderReordered";
 import { PostPlayerUpdateReorderedRegisterParameters } from "../callbacks/subscriptions/postPlayerUpdateReordered";
 import { PostPoopRenderRegisterParameters } from "../callbacks/subscriptions/postPoopRender";
@@ -136,8 +136,8 @@ export interface AddCallbackParameterCustom {
   [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED]: PostPlayerCollectibleAddedRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED]: PostPlayerCollectibleRemovedRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE]: PostPlayerFatalDamageRegisterParameters;
+  [ModCallbackCustom.POST_PLAYER_INIT_FIRST]: PostPlayerInitFirstRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_INIT_LATE]: PostPlayerInitLateRegisterParameters;
-  [ModCallbackCustom.POST_PLAYER_INIT_REORDERED]: PostPlayerInitReorderedRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_RENDER_REORDERED]: PostPlayerRenderReorderedRegisterParameters;
   [ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED]: PostPlayerUpdateReorderedRegisterParameters;
   [ModCallbackCustom.POST_POOP_RENDER]: PostPoopRenderRegisterParameters;