isaacscript-common 6.7.1 → 6.10.0

package/src/functions/pickupsSpecific.ts

@@ -363,7 +363,7 @@ export function spawnBombPickup(
   velocity: Vector = VectorZero,
   spawner: Entity | undefined = undefined,
   seedOrRNG: Seed | RNG | undefined = undefined,
-): EntityPickupBattery {
+): EntityPickupBomb {
   return spawnPickup(
     PickupVariant.BOMB,
     bombSubType,
@@ -371,7 +371,7 @@ export function spawnBombPickup(
     velocity,
     spawner,
     seedOrRNG,
-  ) as EntityPickupBattery;
+  ) as EntityPickupBomb;
 }
 
 /**
@@ -384,7 +384,7 @@ export function spawnBombPickupWithSeed(
   seedOrRNG: Seed | RNG,
   velocity: Vector = VectorZero,
   spawner: Entity | undefined = undefined,
-): EntityPickupBattery {
+): EntityPickupBomb {
   return spawnBombPickup(bombSubType, position, velocity, spawner, seedOrRNG);
 }
 

package/src/functions/playerIndex.ts

@@ -64,7 +64,7 @@ export function getPlayerFromIndex(
  * this is not desired, pass true for the `differentiateForgottenAndSoul` argument, and the RNG of
  * Spoon Bender (3) will be used for The Soul.
  *
- * Also note that this index doesn't work in the `POST_PLAYER_INIT` function for players 2 through
+ * Also note that this index does not work in the `POST_PLAYER_INIT` function for players 2 through
  * 4. With that said, in almost all cases, you should be lazy-initializing your data structures in
  * other callbacks, so this should not be an issue.
  */

package/src/functions/rng.ts

@@ -5,7 +5,7 @@ import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedRNG = LuaTable<string, unknown> & {
+type SerializedRNG = LuaMap<string, unknown> & {
   readonly __serializedRNGBrand: symbol;
 };
 
@@ -63,7 +63,7 @@ export function copyRNG(
       }
 
       const seed = rng.GetSeed();
-      const rngTable = new LuaTable<string, unknown>();
+      const rngTable = new LuaMap<string, unknown>();
       rngTable.set("seed", seed);
       rngTable.set(SerializationBrand.RNG, "");
       return rngTable as SerializedRNG;
@@ -77,7 +77,7 @@ export function copyRNG(
       }
 
       const [seedNumber] = getNumbersFromTable(
-        rng as LuaTable<string, unknown>,
+        rng as LuaMap<string, unknown>,
         OBJECT_NAME,
         ...KEYS,
       );

package/src/functions/run.ts

@@ -1,6 +1,7 @@
 import { Challenge, PlayerType } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
 import { FIRST_CHARACTER } from "../constantsFirstLast";
+import { runNextRenderFrame } from "../features/runInNFrames";
 import { log } from "./log";
 
 /**
@@ -42,6 +43,19 @@ export function restart(character?: PlayerType): void {
   Isaac.ExecuteCommand(command);
 }
 
+/**
+ * Helper function to restart on the next render frame. Useful because it is impossible to restart
+ * the game inside of the `POST_NEW_ROOM`, `POST_NEW_LEVEL`, or `POST_GAME_STARTED` callbacks when a
+ * run is first starting.
+ *
+ * You can optionally specify a `PlayerType` to restart the game as that character.
+ */
+export function restartNextRenderFrame(character?: PlayerType): void {
+  runNextRenderFrame(() => {
+    restart(character);
+  });
+}
+
 /**
  * Helper function to change the run status to that of an unseeded run with a new random seed.
  *

package/src/functions/table.ts

@@ -1,12 +1,12 @@
 import { isBoolean, isNumber, isString } from "./types";
 
 /**
- * In a Map, you can use the `clear` method to delete every element. However, in a LuaTable, the
+ * In a `Map`, you can use the `clear` method to delete every element. However, in a `LuaMap`, the
  * `clear` method does not exist. Use this helper function as a drop-in replacement for this.
  */
-export function clearTable(luaTable: LuaTable): void {
-  for (const [key] of pairs(luaTable)) {
-    luaTable.delete(key);
+export function clearTable(luaMap: LuaMap): void {
+  for (const [key] of pairs(luaMap)) {
+    luaMap.delete(key);
   }
 }
 
@@ -14,13 +14,13 @@ export function clearTable(luaTable: LuaTable): void {
 export function copyValuesToTable(
   object: unknown,
   keys: string[],
-  luaTable: LuaTable<string, unknown>,
+  luaMap: LuaMap<string, unknown>,
 ): void {
-  const otherTable = object as LuaTable<string, string | number>;
+  const otherTable = object as LuaMap<string, string | number>;
 
   for (const key of keys) {
     const value = otherTable.get(key);
-    luaTable.set(key, value);
+    luaMap.set(key, value);
   }
 }
 
@@ -31,13 +31,13 @@ export function copyValuesToTable(
  * This function is variadic, meaning that you can specify N arguments to get N values.
  */
 export function getBooleansFromTable(
-  luaTable: LuaTable<string, unknown>,
+  luaMap: LuaMap<string, unknown>,
   objectName: string,
   ...keys: string[]
 ): boolean[] {
   const booleans: boolean[] = [];
   for (const key of keys) {
-    const value = luaTable.get(key);
+    const value = luaMap.get(key);
     if (value === undefined) {
       error(
         `Failed to find a value for "${key}" in a table representing a "${objectName}" object.`,
@@ -63,13 +63,13 @@ export function getBooleansFromTable(
  * This function is variadic, meaning that you can specify N arguments to get N values.
  */
 export function getNumbersFromTable(
-  luaTable: LuaTable<string, unknown>,
+  luaMap: LuaMap<string, unknown>,
   objectName: string,
   ...keys: string[]
 ): number[] {
   const numbers: number[] = [];
   for (const key of keys) {
-    const value = luaTable.get(key);
+    const value = luaMap.get(key);
     if (value === undefined) {
       error(
         `Failed to find a value for "${key}" in a table representing a "${objectName}" object.`,
@@ -103,13 +103,13 @@ export function getNumbersFromTable(
  * This function is variadic, meaning that you can specify N arguments to get N values.
  */
 export function getStringsFromTable(
-  luaTable: LuaTable<string, unknown>,
+  luaMap: LuaMap<string, unknown>,
   objectName: string,
   ...keys: string[]
 ): string[] {
   const strings: string[] = [];
   for (const key of keys) {
-    const value = luaTable.get(key);
+    const value = luaMap.get(key);
     if (value === undefined) {
       error(
         `Failed to find a value for "${key}" in a table representing a "${objectName}" object.`,
@@ -136,42 +136,44 @@ export function getStringsFromTable(
  * This function will only work on tables that have number keys or string keys. It will throw a
  * run-time error if it encounters a key of another type.
  *
- * @param luaTable The table to iterate over.
+ * @param luaMap The table to iterate over.
  * @param func The function to run for each iteration.
  * @param inOrder Optional. Whether to iterate in order. True by default. You can dynamically set to
  *                false in situations where iterating randomly would not matter and you need the
  *                extra performance.
  */
 export function iterateTableInOrder<K, V>(
-  luaTable: LuaTable<K, V>,
+  luaMap: LuaMap<K, V>,
   func: (key: K, value: V) => void,
   inOrder = true,
 ): void {
   // First, handle the trivial case of a non-deterministic iteration.
   if (!inOrder) {
-    for (const [key, value] of pairs(luaTable)) {
+    for (const [key, value] of luaMap) {
       func(key, value);
     }
     return;
   }
 
-  const keys = Object.keys(luaTable);
+  const keys = Object.keys(luaMap);
   const hasAllNumberKeys = keys.every((key) => isNumber(key));
   const hasAllStringKeys = keys.every((key) => isString(key));
   if (!hasAllNumberKeys && !hasAllStringKeys) {
     // Since the table has non-homogenous keys, we won't be able to sort it. Revert to
     // non-deterministic iteration in this case.
-    for (const [key, value] of pairs(luaTable)) {
+    for (const [key, value] of luaMap) {
       func(key, value);
     }
     return;
   }
-  keys.sort();
 
+  keys.sort();
   for (const key of keys) {
     const keyIndex = key as unknown as K;
-    const value = luaTable.get(keyIndex);
-    func(keyIndex, value);
+    const value = luaMap.get(keyIndex);
+    if (value !== undefined) {
+      func(keyIndex, value);
+    }
   }
 }
 
@@ -182,8 +184,8 @@ export function iterateTableInOrder<K, V>(
  * for.
  */
 export function tableHasKeys(
-  luaTable: LuaTable<AnyNotNil, unknown>,
+  luaMap: LuaMap<AnyNotNil, unknown>,
   ...keys: string[]
 ): boolean {
-  return keys.every((key) => luaTable.has(key));
+  return keys.every((key) => luaMap.has(key));
 }

package/src/functions/tstlClass.ts

@@ -146,7 +146,7 @@ export function newTSTLClass(oldClass: TSTLClass): TSTLClass {
 
 /** This is a re-implementation of the transpiled "__TS__New" function. */
 function newTSTLClassFromMetatable(metatable: TSTLClassMetatable): TSTLClass {
-  const newClass = new LuaTable<AnyNotNil, unknown>();
+  const newClass = new LuaMap<AnyNotNil, unknown>();
   const newClassMetatable = setmetatable(
     newClass,
     metatable.constructor.prototype,

package/src/functions/types.ts

@@ -27,7 +27,9 @@ export function isString(variable: unknown): variable is string {
   return type(variable) === "string";
 }
 
-export function isTable(variable: unknown): variable is LuaTable {
+export function isTable(
+  variable: unknown,
+): variable is LuaMap<AnyNotNil, unknown> {
   return type(variable) === "table";
 }
 

package/src/functions/vector.ts

@@ -6,7 +6,7 @@ import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedVector = LuaTable<string, unknown> & {
+type SerializedVector = LuaMap<string, unknown> & {
   readonly __serializedVectorBrand: symbol;
 };
 
@@ -55,7 +55,7 @@ export function copyVector(
         );
       }
 
-      const vectorTable = new LuaTable<string, unknown>();
+      const vectorTable = new LuaMap<string, unknown>();
       copyValuesToTable(vector, KEYS, vectorTable);
       vectorTable.set(SerializationBrand.VECTOR, "");
       return vectorTable as SerializedVector;
@@ -69,7 +69,7 @@ export function copyVector(
       }
 
       const [x, y] = getNumbersFromTable(
-        vector as LuaTable<string, unknown>,
+        vector as LuaMap<string, unknown>,
         OBJECT_NAME,
         ...KEYS,
       );

package/src/interfaces/SaveData.ts

@@ -15,7 +15,7 @@
  * - `Set`
  * - serializable Isaac API classes (such as `Color`)
  * - TSTL classes (i.e. classes that you made yourself)
- * - sub-objects or a `LuaTable` that contains the above values
+ * - sub-objects or a `LuaMap` that contains the above values
  *
  * (Unfortunately, it is not possible to create a recursive type definition that matches these
  * properties. This means that the TypeScript compiler will not be able to validate that you are

package/src/interfaces/private/TSTLClassMetatable.ts

@@ -3,6 +3,6 @@ export interface TSTLClassMetatable {
   __index: unknown;
   constructor: {
     name: string;
-    prototype: LuaMetatable<LuaTable<AnyNotNil, unknown>>;
+    prototype: LuaMetatable<LuaMap<AnyNotNil, unknown>>;
   };
 }

package/src/types/PlayerIndex.ts

@@ -1,6 +1,7 @@
 /**
- * PlayerIndex is a specific type of string; see the documentation for the `getPlayerIndex`
- * function. Mods can signify that data structures handle `EntityPlayer` by using this type.
+ * PlayerIndex is a specific type of number that represents a unique identifier for a player. Mods
+ * can signify that data structures handle `EntityPlayer` by using this type. For more information,
+ * see the documentation for the `getPlayerIndex` function.
  *
  * For example:
  *

package/src/types/private/IsaacAPIClass.ts

@@ -1,3 +1,3 @@
-export type IsaacAPIClass = LuaTable<string, unknown> & {
+export type IsaacAPIClass = LuaMap<string, unknown> & {
   readonly __isaacAPIClassBrand: symbol;
 };

package/src/types/private/SerializedIsaacAPIClass.ts

@@ -1,3 +1,3 @@
-export type SerializedIsaacAPIClass = LuaTable<string, unknown> & {
+export type SerializedIsaacAPIClass = LuaMap<string, unknown> & {
   readonly __serializedIsaacAPIClassBrand: symbol;
 };

package/src/types/private/TSTLClass.ts

@@ -1,3 +1,3 @@
-export type TSTLClass = LuaTable<AnyNotNil, unknown> & {
+export type TSTLClass = LuaMap<AnyNotNil, unknown> & {
   readonly __tstlClassBrand: symbol;
 };

package/dist/features/saveDataManager/serializationBrand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializationBrand.d.ts","sourceRoot":"","sources":["../../../src/features/saveDataManager/serializationBrand.ts"],"names":[],"mappings":"AASA,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAM1D"}