isaacscript-common 6.10.2 → 6.11.2

package/src/features/customTrapdoor/touched.ts

@@ -0,0 +1,175 @@
+import {
+  EntityCollisionClass,
+  EntityPartition,
+  PlayerType,
+} from "isaac-typescript-definitions";
+import { VectorZero } from "../../constants";
+import { StageTravelState } from "../../enums/private/StageTravelState";
+import {
+  getOtherPlayers,
+  getPlayers,
+  isChildPlayer,
+} from "../../functions/playerIndex";
+import { isCharacter } from "../../functions/players";
+import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
+import { disableAllInputs } from "../disableInputs";
+import { isPlayerUsingPony } from "../ponyDetection";
+import { runInNGameFrames, runNextGameFrame } from "../runInNFrames";
+import {
+  ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL,
+  CUSTOM_TRAPDOOR_FEATURE_NAME,
+  OTHER_PLAYER_TRAPDOOR_JUMP_DELAY_GAME_FRAMES,
+  OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES,
+  TRAPDOOR_TOUCH_DISTANCE,
+} from "./customTrapdoorConstants";
+import v from "./v";
+
+export function checkCustomTrapdoorPlayerTouched(
+  gridEntity: GridEntity,
+  trapdoorDescription: CustomTrapdoorDescription,
+): void {
+  if (v.run.state !== StageTravelState.NONE) {
+    return;
+  }
+
+  if (!trapdoorDescription.open) {
+    return;
+  }
+
+  const playersTouching = Isaac.FindInRadius(
+    gridEntity.Position,
+    TRAPDOOR_TOUCH_DISTANCE,
+    EntityPartition.PLAYER,
+  );
+  for (const playerEntity of playersTouching) {
+    const player = playerEntity.ToPlayer();
+    if (player === undefined) {
+      continue;
+    }
+
+    if (
+      // We don't want a Pony dash to transition to a new floor or a crawl space.
+      !isPlayerUsingPony(player) &&
+      !isChildPlayer(player) &&
+      canPlayerInteractWithTrapdoor(player)
+    ) {
+      playerTouchedCustomTrapdoor(gridEntity, trapdoorDescription, player);
+      return; // Prevent two players from touching the same entity.
+    }
+  }
+}
+
+function canPlayerInteractWithTrapdoor(player: EntityPlayer) {
+  // Players cannot interact with stage travel entities when items are queued or while playing
+  // certain animations.
+  const sprite = player.GetSprite();
+  const animation = sprite.GetAnimation();
+  return (
+    !player.IsHoldingItem() &&
+    !ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL.has(animation)
+  );
+}
+
+function playerTouchedCustomTrapdoor(
+  gridEntity: GridEntity,
+  trapdoorDescription: CustomTrapdoorDescription,
+  player: EntityPlayer,
+) {
+  v.run.state = StageTravelState.PLAYERS_JUMPING_DOWN;
+  v.run.destination = trapdoorDescription.destination;
+
+  disableAllInputs(CUSTOM_TRAPDOOR_FEATURE_NAME);
+  setPlayerAttributes(player, gridEntity.Position);
+  dropTaintedForgotten(player);
+
+  player.PlayExtraAnimation("Trapdoor");
+
+  const otherPlayers = getOtherPlayers(player);
+  otherPlayers.forEach((otherPlayer, i) => {
+    const gameFramesToWaitBeforeJumping =
+      OTHER_PLAYER_TRAPDOOR_JUMP_DELAY_GAME_FRAMES * (i + 1);
+    const otherPlayerPtr = EntityPtr(otherPlayer);
+    runInNGameFrames(() => {
+      startDelayedJump(otherPlayerPtr, gridEntity.Position);
+    }, gameFramesToWaitBeforeJumping);
+  });
+}
+
+function startDelayedJump(entityPtr: EntityPtr, trapdoorPosition: Vector) {
+  const entity = entityPtr.Ref;
+  if (entity === undefined) {
+    return;
+  }
+
+  const player = entity.ToPlayer();
+  if (player === undefined) {
+    return;
+  }
+
+  player.PlayExtraAnimation("Trapdoor");
+
+  adjustPlayerVelocityToTrapdoor(entityPtr, player.Position, trapdoorPosition);
+}
+
+function adjustPlayerVelocityToTrapdoor(
+  entityPtr: EntityPtr,
+  startPos: Vector,
+  endPos: Vector,
+) {
+  const entity = entityPtr.Ref;
+  if (entity === undefined) {
+    return;
+  }
+
+  const player = entity.ToPlayer();
+  if (player === undefined) {
+    return;
+  }
+
+  const sprite = player.GetSprite();
+  if (sprite.IsFinished("Trapdoor")) {
+    return;
+  }
+
+  const frame = sprite.GetFrame();
+  if (frame > OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES) {
+    // We have already arrived at the trapdoor.
+    return;
+  }
+
+  const totalDifference = endPos.sub(startPos);
+  const differencePerFrame = totalDifference.div(
+    OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES,
+  );
+  const differenceForThisFrame = differencePerFrame.mul(frame + 1);
+  const targetPosition = startPos.add(differenceForThisFrame);
+  const calculatedVelocity = player.Position.sub(targetPosition);
+
+  player.Velocity = calculatedVelocity;
+
+  runNextGameFrame(() => {
+    adjustPlayerVelocityToTrapdoor(entityPtr, startPos, endPos);
+  });
+}
+
+function setPlayerAttributes(trapdoorPlayer: EntityPlayer, position: Vector) {
+  // Snap the player to the exact position of the trapdoor so that they cleanly jump down the hole.
+  trapdoorPlayer.Position = position;
+
+  for (const player of getPlayers()) {
+    // Freeze all players.
+    player.Velocity = VectorZero;
+
+    // We don't want enemy attacks to move the players.
+    player.EntityCollisionClass = EntityCollisionClass.NONE;
+  }
+}
+
+function dropTaintedForgotten(player: EntityPlayer) {
+  if (isCharacter(player, PlayerType.THE_FORGOTTEN_B)) {
+    const taintedSoul = player.GetOtherTwin();
+    if (taintedSoul !== undefined) {
+      taintedSoul.ThrowHeldEntity(VectorZero);
+    }
+  }
+}

package/src/features/customTrapdoor/v.ts

@@ -0,0 +1,26 @@
+import { LevelStage, StageType } from "isaac-typescript-definitions";
+import { DefaultMap } from "../../classes/DefaultMap";
+import { StageTravelState } from "../../enums/private/StageTravelState";
+import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
+
+const v = {
+  run: {
+    state: StageTravelState.NONE,
+
+    /** The render frame that this state was reached. */
+    stateRenderFrame: null as int | null,
+
+    destination: null as
+      | [stage: LevelStage, stageType: StageType]
+      | string
+      | null,
+  },
+
+  level: {
+    /** Indexed by room list index and grid index. */
+    trapdoors: new DefaultMap<int, Map<int, CustomTrapdoorDescription>>(
+      () => new Map(),
+    ),
+  },
+};
+export default v;

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;
@@ -156,7 +161,7 @@ function preUseItemWeNeedToGoDeeper(
     fillRoomWithDecorations();
   });
 
-  // Cancel the effect.
+  // Cancel the original effect.
   return true;
 }
 

package/src/features/extraConsoleCommands/init.ts

@@ -8,6 +8,7 @@ import {
 } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../../classes/ModUpgraded";
 import { MAX_SPEED_STAT } from "../../constants";
+import { bitFlags } from "../../functions/flag";
 import { getMapPartialMatch } from "../../functions/map";
 import { printConsole } from "../../functions/utils";
 import { debugDisplayInit } from "../debugDisplay/debugDisplay";
@@ -349,8 +350,10 @@ function entityTakeDmgPlayer() {
 }
 
 // ModCallback.POST_CURSE_EVAL (12)
-function postCurseEval(curses: int) {
-  return v.persistent.disableCurses ? LevelCurse.NONE : curses;
+function postCurseEval(
+  curses: BitFlags<LevelCurse>,
+): BitFlags<LevelCurse> | undefined {
+  return v.persistent.disableCurses ? bitFlags(LevelCurse.NONE) : curses;
 }
 
 // ModCallback.EXECUTE_CMD (22)

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/features/saveDataManager/main.ts

@@ -171,7 +171,7 @@ function clearAndCopyAllElements(
 ) {
   clearTable(oldTable);
 
-  for (const [key, value] of pairs(newTable)) {
+  for (const [key, value] of newTable) {
     oldTable.set(key, value);
   }
 }

package/src/features/taintedLazarusPlayers.ts

@@ -2,29 +2,39 @@
 // Lazarus.
 
 import { ModCallback, PlayerType } from "isaac-typescript-definitions";
+import { ModUpgraded } from "../classes/ModUpgraded";
 import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { logError } from "../functions/log";
 import { saveDataManager } from "./saveDataManager/exports";
 
 const FEATURE_NAME = "taintedLazarusPlayers";
 
 const v = {
   run: {
-    queuedTaintedLazarus: [] as EntityPtr[],
-    queuedDeadTaintedLazarus: [] as EntityPtr[],
+    queuedTaintedLazarus: [] as EntityPlayer[],
+    queuedDeadTaintedLazarus: [] as EntityPlayer[],
 
     /**
-     * The PostPlayerInit callback fires for Dead Tainted Lazarus at the beginning of the run.
+     * The `POST_PLAYER_INIT` callback fires for Dead Tainted Lazarus at the beginning of the run.
      * However, the player index for the Dead Tainted Lazarus player object at that time does not
      * actually correspond to the player index for the real player once Flip has been used. Thus, we
      * revert to using PtrHash as an index for our map, which is consistent between the Dead Tainted
-     * Lazarus object in the PostPlayerInit callback and the "real" Dead Tainted Lazarus.
+     * Lazarus object in the `POST_PLAYER_INIT` callback and the "real" Dead Tainted Lazarus.
+     *
+     * We use `EntityPlayer` as the value for the map instead of `EntityPtr` because using the
+     * pointer does not work for some reason. (When we unwrap it after one or more flips have been
+     * used, the pointers no longer point to the original objects, even if we manually update the
+     * pointers in the `POST_FLIP` callback.)
      */
-    subPlayerMap: new Map<PtrHash, EntityPtr>(),
+    subPlayerMap: new Map<PtrHash, EntityPlayer>(),
   },
 };
 
 /** @internal */
-export function taintedLazarusPlayersInit(mod: Mod): void {
+export function taintedLazarusPlayersInit(mod: ModUpgraded): void {
+  // `EntityPtr` is not serializable, so we cannot save data. However, this is inconsequential,
+  // since the `POST_PLAYER_INIT` callback will fire when a run is continued, which will repopulate
+  // the `subPlayerMap`.
   saveDataManager(FEATURE_NAME, v, () => false);
 
   mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit);
@@ -32,13 +42,12 @@ export function taintedLazarusPlayersInit(mod: Mod): void {
 
 // ModCallback.POST_PLAYER_INIT (9)
 function postPlayerInit(player: EntityPlayer) {
-  const entityPtr = EntityPtr(player);
   const character = player.GetPlayerType();
 
   if (character === PlayerType.LAZARUS_B) {
-    v.run.queuedTaintedLazarus.push(entityPtr);
+    v.run.queuedTaintedLazarus.push(player);
   } else if (character === PlayerType.LAZARUS_2_B) {
-    v.run.queuedDeadTaintedLazarus.push(entityPtr);
+    v.run.queuedDeadTaintedLazarus.push(player);
   } else {
     return;
   }
@@ -47,6 +56,8 @@ function postPlayerInit(player: EntityPlayer) {
 }
 
 /**
+ * Indexes are the `PtrHash`, values are the `EntityPtr` of the *other* Lazarus.
+ *
  * When starting a run, the PostPlayerInit callback will fire first for Dead Tainted Lazarus, then
  * for Tainted Lazarus. When continuing a run, the PostPlayerInit callback will fire first for the
  * character that is currently active. Thus, since the order of the characters is not certain, we
@@ -61,15 +72,8 @@ function checkDequeue() {
     return;
   }
 
-  const taintedLazarusPtr = v.run.queuedTaintedLazarus.shift();
-  const deadTaintedLazarusPtr = v.run.queuedDeadTaintedLazarus.shift();
-
-  if (taintedLazarusPtr === undefined || deadTaintedLazarusPtr === undefined) {
-    return;
-  }
-
-  const taintedLazarus = taintedLazarusPtr.Ref;
-  const deadTaintedLazarus = deadTaintedLazarusPtr.Ref;
+  const taintedLazarus = v.run.queuedTaintedLazarus.shift();
+  const deadTaintedLazarus = v.run.queuedDeadTaintedLazarus.shift();
 
   if (taintedLazarus === undefined || deadTaintedLazarus === undefined) {
     return;
@@ -78,8 +82,15 @@ function checkDequeue() {
   const taintedLazarusPtrHash = GetPtrHash(taintedLazarus);
   const deadTaintedLazarusPtrHash = GetPtrHash(deadTaintedLazarus);
 
-  v.run.subPlayerMap.set(taintedLazarusPtrHash, deadTaintedLazarusPtr);
-  v.run.subPlayerMap.set(deadTaintedLazarusPtrHash, taintedLazarusPtr);
+  if (taintedLazarusPtrHash === deadTaintedLazarusPtrHash) {
+    logError(
+      "Failed to cache the Tainted Lazarus player objects, since the hash for Tainted Lazarus and Dead Tainted Lazarus were the same.",
+    );
+    return;
+  }
+
+  v.run.subPlayerMap.set(taintedLazarusPtrHash, deadTaintedLazarus);
+  v.run.subPlayerMap.set(deadTaintedLazarusPtrHash, taintedLazarus);
 }
 
 /**
@@ -99,15 +110,5 @@ export function getTaintedLazarusSubPlayer(
   errorIfFeaturesNotInitialized(FEATURE_NAME);
 
   const ptrHash = GetPtrHash(player);
-  const entityPtr = v.run.subPlayerMap.get(ptrHash);
-  if (entityPtr === undefined) {
-    return undefined;
-  }
-
-  const entity = entityPtr.Ref;
-  if (entity === undefined) {
-    return undefined;
-  }
-
-  return entity.ToPlayer();
+  return v.run.subPlayerMap.get(ptrHash);
 }

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

@@ -550,8 +550,8 @@ function getCopiedEntries(
   entries: Array<[key: AnyNotNil, value: unknown]>;
   convertedNumberKeysToStrings: boolean;
 } {
-  // First, shallow copy the entries. We cannot use "pairs" to iterate over a Map or Set. We cannot
-  // use "[...pairs(object)]", as it results in a run-time error.
+  // First, shallow copy the entries. We cannot use "pairs" to iterate over a `Map` or `Set`. We
+  // cannot use "[...pairs(object)]", as it results in a run-time error.
   const entries: Array<[key: AnyNotNil, value: unknown]> = [];
   if (isTSTLMap(object) || isTSTLSet(object) || isDefaultMap(object)) {
     for (const [key, value] of object.entries()) {

package/src/functions/deepCopyTests.ts

@@ -32,11 +32,11 @@ export function runDeepCopyTests(): void {
   copiedDefaultMapHasChildDefaultMap();
   copiedDefaultMapHasBrand();
 
-  copiedSerializedMapHasStringKeyType();
-  copiedSerializedMapHasNumberKeyType();
+  copiedSerializedMapHasStringKey();
+  copiedSerializedMapHasNumberKey();
 
-  copiedSerializedDefaultMapHasStringKeyType();
-  copiedSerializedDefaultMapHasNumberKeyType();
+  copiedSerializedDefaultMapHasStringKey();
+  copiedSerializedDefaultMapHasNumberKey();
 
   log("All deep copy tests passed!");
 }
@@ -464,112 +464,108 @@ function copiedDefaultMapHasBrand() {
   }
 }
 
-function copiedSerializedMapHasStringKeyType() {
+function copiedSerializedMapHasStringKey() {
   const mapKey = "123";
   const mapValue = 456;
   const oldMap = new Map<string, number>();
   oldMap.set(mapKey, mapValue);
 
-  const tempTable = deepCopy(
+  const serializedOldMap = deepCopy(
     oldMap,
     SerializationType.SERIALIZE,
-    "copiedSerializedMapHasStringKeyTypeSerialize",
+    "copiedSerializedMapHasStringKey-serialize",
   );
 
   const newTable = deepCopy(
-    tempTable,
+    serializedOldMap,
     SerializationType.DESERIALIZE,
-    "copiedSerializedMapHasStringKeyTypeDeserialize",
+    "copiedSerializedMapHasStringKey-deserialize",
   );
 
   const newMap = newTable as Map<string, number>;
-  if (![...newMap.keys()].includes(mapKey)) {
+  if (!newMap.has(mapKey)) {
+    const keyType = type(mapKey);
     error(
-      `The copied Map did not have a key of: ${mapKey} with type ${type(
-        mapKey,
-      )}`,
+      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
     );
   }
 }
 
-function copiedSerializedMapHasNumberKeyType() {
+function copiedSerializedMapHasNumberKey() {
   const mapKey = 123;
   const mapValue = 456;
   const oldMap = new Map<number, number>();
   oldMap.set(mapKey, mapValue);
 
-  const tempTable = deepCopy(
+  const serializedOldMap = deepCopy(
     oldMap,
     SerializationType.SERIALIZE,
-    "copiedSerializedMapHasNumberKeyTypeSerialize",
+    "copiedSerializedMapHasNumberKey-serialize",
   );
 
   const newTable = deepCopy(
-    tempTable,
+    serializedOldMap,
     SerializationType.DESERIALIZE,
-    "copiedSerializedMapHasNumberKeyTypeDeserialize",
+    "copiedSerializedMapHasNumberKey-deserialize",
   );
 
   const newMap = newTable as Map<number, number>;
-  if (![...newMap.keys()].includes(mapKey)) {
+  if (!newMap.has(mapKey)) {
+    const keyType = type(mapKey);
     error(
-      `The copied Map did not have a key of: ${mapKey} with type ${type(
-        mapKey,
-      )}`,
+      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
     );
   }
 }
 
-function copiedSerializedDefaultMapHasStringKeyType() {
+function copiedSerializedDefaultMapHasStringKey() {
   const mapKey = "123";
-  const oldMap = new DefaultMap<string, number>(456);
-  oldMap.getAndSetDefault(mapKey);
+  const oldDefaultMap = new DefaultMap<string, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
 
-  const tempTable = deepCopy(
-    oldMap,
+  const serializedOldDefaultMap = deepCopy(
+    oldDefaultMap,
     SerializationType.SERIALIZE,
-    "copiedSerializedDefaultMapHasStringKeyTypeSerialize",
+    "copiedSerializedDefaultMapHasStringKey-serialize",
   );
 
   const newTable = deepCopy(
-    tempTable,
+    serializedOldDefaultMap,
     SerializationType.DESERIALIZE,
-    "copiedSerializedDefaultMapHasStringKeyTypeDeserialize",
+    "copiedSerializedDefaultMapHasStringKey-deserialize",
   );
 
-  const newMap = newTable as DefaultMap<string, number>;
-  if (![...newMap.keys()].includes(mapKey)) {
+  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 ${type(
-        mapKey,
-      )}`,
+      `The copied DefaultMap did not have a key of "${mapKey}" with type: ${keyType}`,
     );
   }
 }
 
-function copiedSerializedDefaultMapHasNumberKeyType() {
+function copiedSerializedDefaultMapHasNumberKey() {
   const mapKey = 123;
-  const oldMap = new DefaultMap<number, number>(456);
-  oldMap.getAndSetDefault(mapKey);
+  const oldDefaultMap = new DefaultMap<number, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
 
-  const tempTable = deepCopy(
-    oldMap,
+  const serializedOldDefaultMap = deepCopy(
+    oldDefaultMap,
     SerializationType.SERIALIZE,
-    "copiedSerializedDefaultMapHasNumberKeyTypeSerialize",
+    "copiedSerializedDefaultMapHasNumberKey-serialize",
   );
 
   const newTable = deepCopy(
-    tempTable,
+    serializedOldDefaultMap,
     SerializationType.DESERIALIZE,
-    "copiedSerializedDefaultMapHasNumberKeyTypeDeserialize",
+    "copiedSerializedDefaultMapHasNumberKey-deserialize",
   );
 
-  const newMap = newTable as DefaultMap<number, number>;
-  if (![...newMap.keys()].includes(mapKey)) {
+  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 ${type(
-        mapKey,
-      )}`,
+      `The copied DefaultMap did not have a key of: ${mapKey} with type ${keyType}`,
     );
   }
 }

package/src/functions/entities.ts

@@ -181,7 +181,7 @@ function setPrimitiveEntityFields(
     error('Failed to get the "__propget" table for an entity.');
   }
 
-  for (const [key] of pairs(propGetTable)) {
+  for (const [key] of propGetTable) {
     // The values of this table are functions. Thus, we use the key to index the original entity.
     const indexKey = key as keyof typeof entity;
     const value = entity[indexKey];

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);