isaacscript-common 6.6.0 → 6.6.1-dev.2

package/functions/playerIndex.js

@@ -0,0 +1,160 @@
+import { CollectibleType, PlayerType } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+const DEFAULT_COLLECTIBLE_TYPE = CollectibleType.SAD_ONION;
+const EXCLUDED_CHARACTERS = new Set([
+    PlayerType.ESAU,
+    PlayerType.THE_SOUL_B, // 40
+]);
+/**
+ * Helper function to get every player with no restrictions, by using `Game.GetNumPlayers` and
+ * `Isaac.GetPlayer`.
+ *
+ * This function is almost never what you want to use. For most purposes, use the `getPlayers`
+ * helper function instead to get a filtered list of players.
+ */
+export function getAllPlayers() {
+    const numPlayers = game.GetNumPlayers();
+    const players = [];
+    for (let i = 0; i < numPlayers; i++) {
+        const player = Isaac.GetPlayer(i);
+        players.push(player);
+    }
+    return players;
+}
+export function getPlayerFromIndex(playerIndex) {
+    const players = getPlayers();
+    return players.find((player) => getPlayerIndex(player) === playerIndex);
+}
+/**
+ * Mods often have to track variables relating to the player. In naive mods, information will only
+ * be stored about the first player. However, in order to be robust, mods must handle up to 4
+ * players playing at the same time. This means that information must be stored on a map data
+ * structure. Finding a good index for these types of map data structures is difficult:
+ *
+ * - We cannot use the index from `Isaac.GetPlayer(i)` since this fails in the case where there are
+ *   two players and the first player leaves the run.
+ * - We cannot use `EntityPlayer.ControllerIndex` as an index because it fails in the case of Jacob
+ *   & Esau or Tainted Forgotten. It also fails in the case of a player changing their controls
+ *   mid-run.
+ * - We cannot use `EntityPlayer.GetData().index` because it does not persist across saving and
+ *   continuing.
+ * - We cannot use `GetPtrHash()` as an index because it does not persist across exiting and
+ *   relaunching the game.
+ * - We cannot use `EntityPlayer.InitSeed` because it is not consistent with additional players
+ *   beyond the first.
+ *
+ * Instead, we use the `EntityPlayer.GetCollectibleRNG` method with an arbitrary value of Sad Onion
+ * (1). This works even if the player does not have any Sad Onions.
+ *
+ * Since the RNG value is the same for both Tainted Lazarus and Dead Tainted Lazarus, we revert to
+ * using the RNG of The Inner Eye (2) for Dead Tainted Lazarus.
+ *
+ * Note that by default, this returns the same index for both The Forgotten and The Soul. (Even
+ * though they are technically different characters, they share the same inventory and InitSeed.) If
+ * this is not desired, pass true for the `differentiateForgottenAndSoul` argument, and the RNG of
+ * Spoon Bender (3) will be used for The Soul.
+ */
+export function getPlayerIndex(player, differentiateForgottenAndSoul = false) {
+    // Sub-players use separate RNG values for some reason, so we need to always use the main player:
+    // https://github.com/Meowlala/RepentanceAPIIssueTracker/issues/443
+    // We can safely ignore the player's character because regardless of whether the main player ends
+    // up being The Forgotten or The Soul, the collectible RNG values will be the same. The
+    // `EntityPlayer.IsSubPlayer` method can return true for Dead Tainted Lazarus during the
+    // PostPlayerInit callback, but since we fall back to the player in the case of
+    // "getSubPlayerParent" returning undefined, we do not need to explicitly check for this case.
+    let playerToUse = player;
+    const isSubPlayer = player.IsSubPlayer();
+    if (isSubPlayer) {
+        // The "getSubPlayerParent" function will return undefined in the situation where we are on Dead
+        // Tainted Lazarus in the PostPlayerInit callback.
+        const playerParent = getSubPlayerParent(player);
+        if (playerParent !== undefined) {
+            playerToUse = playerParent;
+        }
+    }
+    const collectibleType = getPlayerIndexCollectibleType(player, differentiateForgottenAndSoul);
+    const collectibleRNG = playerToUse.GetCollectibleRNG(collectibleType);
+    const seed = collectibleRNG.GetSeed();
+    return seed;
+}
+function getPlayerIndexCollectibleType(player, differentiateForgottenAndSoul) {
+    const character = player.GetPlayerType();
+    switch (character) {
+        // 17
+        case PlayerType.THE_SOUL: {
+            return differentiateForgottenAndSoul
+                ? CollectibleType.SPOON_BENDER
+                : DEFAULT_COLLECTIBLE_TYPE;
+        }
+        // 38
+        case PlayerType.LAZARUS_2_B: {
+            return CollectibleType.INNER_EYE;
+        }
+        default: {
+            return DEFAULT_COLLECTIBLE_TYPE;
+        }
+    }
+}
+/**
+ * Helper function to return the index of this player with respect to the output of the
+ * `Isaac.GetPlayer` method.
+ *
+ * Note that if you storing information about a player in a data structure, you never want to use
+ * this index; use the `getPlayerIndex` function instead.
+ */
+export function getPlayerIndexVanilla(playerToFind) {
+    const numPlayers = game.GetNumPlayers();
+    const playerToFindHash = GetPtrHash(playerToFind);
+    for (let i = 0; i < numPlayers; i++) {
+        const player = Isaac.GetPlayer(i);
+        const playerHash = GetPtrHash(player);
+        if (playerHash === playerToFindHash) {
+            return i;
+        }
+    }
+    return undefined;
+}
+/**
+ * This function always excludes players with a non-undefined parent, since they are not real
+ * players (e.g. the Strawman Keeper).
+ *
+ * If this is not desired, use the `getAllPlayers` helper function instead.
+ *
+ * @param performCharacterExclusions Whether or not to exclude characters that are not directly
+ *                                 controlled by the player (i.e. Esau & Tainted Soul). Default is
+ *                                 false.
+ */
+export function getPlayers(performCharacterExclusions = false) {
+    const players = getAllPlayers();
+    const nonChildPlayers = players.filter((player) => !isChildPlayer(player));
+    const nonChildPlayersFiltered = nonChildPlayers.filter((player) => {
+        const character = player.GetPlayerType();
+        return !EXCLUDED_CHARACTERS.has(character);
+    });
+    return performCharacterExclusions ? nonChildPlayersFiltered : nonChildPlayers;
+}
+/**
+ * Helper function to get a parent `EntityPlayer` object for a given `EntitySubPlayer` object. This
+ * is useful because calling the `EntityPlayer.GetSubPlayer` method on a sub-player object will
+ * return undefined.
+ */
+export function getSubPlayerParent(subPlayer) {
+    const subPlayerPtrHash = GetPtrHash(subPlayer);
+    const players = getPlayers();
+    return players.find((player) => {
+        const thisPlayerSubPlayer = player.GetSubPlayer();
+        if (thisPlayerSubPlayer === undefined) {
+            return false;
+        }
+        const thisPlayerSubPlayerPtrHash = GetPtrHash(thisPlayerSubPlayer);
+        return thisPlayerSubPlayerPtrHash === subPlayerPtrHash;
+    });
+}
+/**
+ * Some players are "child" players, meaning that they have a non-undefined Parent property. (For
+ * example, the Strawman Keeper.)
+ */
+export function isChildPlayer(player) {
+    return player.Parent !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/playerIndex.lua

@@ -175,3 +175,5 @@ function ____exports.getPlayerIndexVanilla(self, playerToFind)
     return nil
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL3BsYXllckluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztNQW1HUywrQkEvRkgsMEJBRUE7QUFOTiw2Q0FBNEM7QUFBbkM7QUFBaUI7QUFDMUIsMEJBQXFCO0FBQVo7Ozs7OztBQWlCVDtBQUNRLHVCQUFhLEtBQUs7QUFFbEIsb0JBQTBCOztBQUN2QixrQkFBSTtjQUFHLElBQUk7QUFDWiwyQkFBUyxnQkFBZ0I7QUFDL0Isb0NBQWE7QUFGaUI7OztBQUtoQyxXQUFPO0FBVFQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFnREEsMENBQ0UsUUFDQTtPQUFBO1FBQUEsZ0NBQWdDOztBQVU1Qix3QkFBYztBQUNaLHdCQUFjLE9BQU87T0FDdkI7QUFHSSw2QkFBZSxvQ0FBbUI7V0FDcEM7QUFDRiwwQkFBYzs7O0FBSVosNEJBQWtCLG1DQUN0QixRQUNBO0FBRUksMkJBQWlCLFlBQVksa0JBQWtCO0FBQy9DLGlCQUFPLGVBQWU7QUFFNUIsV0FBTztBQTlCVDtBQWlDQSxTQUFTLG9DQUNQLFFBQ0E7QUFFTSxzQkFBWSxPQUFPOzs2QkFFakI7MkNBRUQ7OztBQUNILHVCQUFPLGtDQUNILGdDQUNBOzs7bURBSUQ7OztBQUNILHVCQUFPOzs7OztBQUlQLHVCQUFPOzs7Ozs7Ozs7Ozs7O0FBdUNiLHNDQUEyQjtPQUFBO1FBQUEsNkJBQTZCOztBQUNoRCxvQkFBVTtBQUNWLDRCQUFrQjtRQUFBO1FBQWUsZUFBQyxRQUFXLFdBQUMsK0JBQWMsT0FBM0I7O0FBQ2pDLG9DQUEwQjtRQUFBO1FBQXVCLGVBQUM7QUFDaEQsOEJBQVksT0FBTztBQUN6Qix1QkFBUSxvQkFBb0IsSUFBSTtRQUZxQjs7QUFLdkQsV0FBTywrQkFBNkIsMkJBQTBCO0FBUmhFOzs7O0FBZ0JBLDhDQUNFO0FBRU0sNkJBQW1CLFdBQVc7QUFDOUIsb0JBQVU7QUFFaEIsV0FBTztRQUFBO1FBQWEsZUFBQztBQUNiLHdDQUFzQixPQUFPO2VBQy9CO0FBQ0YsdUJBQU87O0FBR0gsK0NBQTZCLFdBQVc7QUFDOUMsbUJBQU8sOEJBQStCO1FBUHBCOztBQU50Qjs7O0FBcUJBLHlDQUE4QjtBQUM1QixXQUFPO0FBRFQ7QUEvTE0sMkJBQTJCO0FBRTNCLHNCQUErQyxVQUFJLEtBQUksQ0FDM0QsaUJBQ0E7QUFzQkYsOENBQ0U7QUFFTSxvQkFBVTtBQUNoQixXQUFPO1FBQUE7UUFBYSxlQUFDLFFBQVcsdUNBQWUsV0FBWSxXQUF2Qzs7QUFKdEI7Ozs7OztBQXFHQSxpREFDRTtBQUVNLHVCQUFhLEtBQUs7QUFDbEIsNkJBQW1CLFdBQVc7O0FBRTNCLGtCQUFJO2NBQUcsSUFBSTtBQUNaLDJCQUFTLGdCQUFnQjtBQUN6QiwrQkFBYSxXQUFXO2VBQzFCLGNBQWU7QUFDakIsdUJBQU87O0FBSnFCOzs7QUFRaEM7QUFkRiIsImZpbGUiOiJwbGF5ZXJJbmRleC5sdWEiLCJzb3VyY2VSb290IjoiIn0=

package/functions/pocketItems.js

@@ -0,0 +1,124 @@
+import { ActiveSlot, Card, CollectibleType, PillColor, PlayerType, PocketItemSlot, } from "isaac-typescript-definitions";
+import { PocketItemType } from "../enums/PocketItemType";
+import { getEnumValues } from "./enums";
+import { isCharacter } from "./player";
+/**
+ * Helper function to get the `PocketItemSlot` that the player's pocket active collectible item is
+ * in, if any. Returns undefined if the player does not have a pocket active item.
+ */
+export function getActivePocketItemSlot(player) {
+    const pocketItems = getPocketItems(player);
+    for (const pocketItem of pocketItems) {
+        if (pocketItem.type === PocketItemType.ACTIVE_ITEM) {
+            return pocketItem.slot;
+        }
+    }
+    return undefined;
+}
+export function getFirstCardOrPill(player) {
+    const pocketItems = getPocketItems(player);
+    return pocketItems.find((pocketItem) => pocketItem.type === PocketItemType.CARD ||
+        pocketItem.type === PocketItemType.PILL);
+}
+/**
+ * Use this helper function as a workaround for the `EntityPlayer.GetPocketItem` method not working
+ * correctly.
+ *
+ * Note that due to API limitations, there is no way to determine the location of a Dice Bag trinket
+ * dice. Furthermore, when the player has a Dice Bag trinket dice and a pocket active at the same
+ * time, there is no way to determine the location of the pocket active item. If this function
+ * cannot determine the identity of a particular slot, it will mark the type of the slot as
+ * `PocketItemType.UNDETERMINABLE`.
+ */
+export function getPocketItems(player) {
+    const pocketItem = player.GetActiveItem(ActiveSlot.POCKET);
+    const hasPocketItem = pocketItem !== CollectibleType.NULL;
+    const pocketItem2 = player.GetActiveItem(ActiveSlot.POCKET_SINGLE_USE);
+    const hasPocketItem2 = pocketItem2 !== CollectibleType.NULL;
+    const maxPocketItems = player.GetMaxPocketItems();
+    const pocketItemSlots = getEnumValues(PocketItemSlot);
+    const pocketItems = [];
+    let pocketItemIdentified = false;
+    let pocketItem2Identified = false;
+    for (const slot of pocketItemSlots) {
+        const card = player.GetCard(slot);
+        const pillColor = player.GetPill(slot);
+        if (card !== Card.NULL) {
+            pocketItems.push({
+                slot,
+                type: PocketItemType.CARD,
+                subType: card,
+            });
+        }
+        else if (pillColor !== PillColor.NULL) {
+            pocketItems.push({
+                slot,
+                type: PocketItemType.PILL,
+                subType: pillColor,
+            });
+        }
+        else if (hasPocketItem && !hasPocketItem2 && !pocketItemIdentified) {
+            pocketItemIdentified = true;
+            pocketItems.push({
+                slot,
+                type: PocketItemType.ACTIVE_ITEM,
+                subType: pocketItem,
+            });
+        }
+        else if (!hasPocketItem && hasPocketItem2 && !pocketItem2Identified) {
+            pocketItem2Identified = true;
+            pocketItems.push({
+                slot,
+                type: PocketItemType.DICE_BAG_DICE,
+                subType: pocketItem2,
+            });
+        }
+        else if (hasPocketItem && hasPocketItem2) {
+            pocketItems.push({
+                slot,
+                type: PocketItemType.UNDETERMINABLE,
+                subType: 0,
+            });
+        }
+        else {
+            pocketItems.push({
+                slot,
+                type: PocketItemType.EMPTY,
+                subType: 0,
+            });
+        }
+        // eslint-disable-next-line isaacscript/strict-enums
+        if (slot + 1 === maxPocketItems) {
+            break;
+        }
+    }
+    return pocketItems;
+}
+/**
+ * Returns whether or not the player can hold an additional pocket item, beyond what they are
+ * currently carrying. This takes into account items that modify the max number of pocket items,
+ * like Starter Deck.
+ *
+ * If the player is the Tainted Soul, this always returns false, since that character cannot pick up
+ * items. (Only Tainted Forgotten can pick up items.)
+ */
+export function hasOpenPocketItemSlot(player) {
+    if (isCharacter(player, PlayerType.THE_SOUL_B)) {
+        return false;
+    }
+    const pocketItems = getPocketItems(player);
+    return pocketItems.some((pocketItem) => pocketItem.type === PocketItemType.EMPTY);
+}
+/**
+ * Helper function to determine whether or not the player's "active" pocket item slot is set to
+ * their pocket active item.
+ */
+export function isFirstSlotPocketActiveItem(player) {
+    const pocketItems = getPocketItems(player);
+    const firstPocketItem = pocketItems[0];
+    if (firstPocketItem === undefined) {
+        return false;
+    }
+    return firstPocketItem.type === PocketItemType.ACTIVE_ITEM;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/pocketItems.lua

@@ -102,3 +102,5 @@ function ____exports.isFirstSlotPocketActiveItem(self, player)
     return firstPocketItem.type == PocketItemType.ACTIVE_ITEM
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL3BvY2tldEl0ZW1zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSw2Q0FPTztBQU5MO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUVGLDJCQUErQjtBQUF0QjtBQUVULGtCQUE4QjtBQUFyQjtBQUNULG1CQUE0QjtBQUFuQjs7Ozs7Ozs7O0FBd0NULDBDQUErQjtBQUN2Qix1QkFBYSxPQUFPLGNBQWM7QUFDbEMsMEJBQWdCLGNBQWU7QUFFL0Isd0JBQWMsT0FBTyxjQUFjO0FBQ25DLDJCQUFpQixlQUFnQjtBQUVqQywyQkFBaUIsT0FBTztBQUN4Qiw0QkFBa0IsbUJBQWM7QUFFaEMsd0JBQXVDO0FBQ3pDLGlDQUF1QjtBQUN2QixrQ0FBd0I7QUFDNUIsY0FBVyxlQUFRO0FBQ1gscUJBQU8sT0FBTyxRQUFRO0FBQ3RCLDBCQUFZLE9BQU8sUUFBUTtXQUU3QixRQUFTO0FBQ1gsNENBQWlCLENBQ2YsYUFDQSxPQUFNLHFCQUNOLFVBQVM7ZUFFRixhQUFjO0FBQ3ZCLDRDQUFpQixDQUNmLGFBQ0EsT0FBTSxxQkFDTixVQUFTO2VBRUYsc0JBQWtCLHVCQUFtQjtBQUM5QyxtQ0FBdUI7QUFDdkIsNENBQWlCLENBQ2YsYUFDQSxPQUFNLDRCQUNOLFVBQVM7ZUFFRixJQUFDLGtCQUFpQix1QkFBbUI7QUFDOUMsb0NBQXdCO0FBQ3hCLDRDQUFpQixDQUNmLGFBQ0EsT0FBTSw4QkFDTixVQUFTO2VBRUYsa0JBQWlCO0FBQzFCLDRDQUFpQixDQUNmLGFBQ0EsT0FBTSwrQkFDTixVQUFTOztBQUdYLDRDQUFpQixDQUNmLGFBQ0EsT0FBTSxzQkFDTixVQUFTOztXQUtULE9BQU8sS0FBTTtBQUNmOzs7QUFJSixXQUFPO0FBL0RUOzs7QUFsQ0EsbURBQ0U7QUFFTSx3QkFBYyxnQ0FBZTtBQUNuQyxjQUFXLHFCQUFjO1dBQ25CLG1CQUFvQjtBQUN0QixtQkFBTzs7O0FBSVg7QUFWRjtBQWFBLDhDQUNFO0FBRU0sd0JBQWMsZ0NBQWU7QUFDbkMsV0FBTztRQUFBO1FBQ0wsZUFBQyxZQUNDLDBCQUFvQix1QkFDcEIsbUJBQW9CLG1CQUZ0Qjs7QUFMSjs7Ozs7OztBQStGQSxpREFBc0M7T0FDaEMsaUJBQVksUUFBUTtBQUN0QixlQUFPOztBQUdILHdCQUFjLGdDQUFlO0FBQ25DLFdBQU87UUFBQTtRQUNMLGVBQUMsWUFBZSwwQkFBb0Isb0JBQXBDOztBQVBKOzs7QUFlQSx1REFBNEM7QUFDcEMsd0JBQWMsZ0NBQWU7QUFDN0IsNEJBQWtCLFlBQVk7T0FDaEM7QUFDRixlQUFPOztBQUdULFdBQU8sd0JBQXlCO0FBUGxDIiwiZmlsZSI6InBvY2tldEl0ZW1zLmx1YSIsInNvdXJjZVJvb3QiOiIifQ==

package/functions/positionVelocity.js

@@ -0,0 +1,136 @@
+import { EffectVariant, HeavenLightDoorSubType, } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { DISTANCE_OF_GRID_TILE } from "../constants";
+import { getEntities } from "./entity";
+import { getEffects } from "./entitySpecific";
+import { getPlayerCloserThan } from "./player";
+import { getPlayers } from "./playerIndex";
+const MAX_FIND_FREE_POSITION_ATTEMPTS = 100;
+export function anyEntityCloserThan(entities, position, distance) {
+    return entities.some((entity) => position.Distance(entity.Position) <= distance);
+}
+/** Iterates over all players and checks if any player is close enough to the specified position. */
+export function anyPlayerCloserThan(position, distance) {
+    const players = getPlayers();
+    return players.some((player) => player.Position.Distance(position) <= distance);
+}
+/**
+ * Helper function to get a room position that is not overlapping with a grid entity, a heaven door,
+ * or a player. The `Room.FindFreePickupSpawnPosition` method will return locations that overlap
+ * with heaven doors and partially overlap with players, if the thing being spawned is bigger than a
+ * tile (like a Blood Donation Machine). Use this function instead if you want to account for those
+ * specific situations.
+ *
+ * @param startingPosition The position to start searching from. If this position is not overlapping
+ *                         with anything, then it will be returned.
+ * @param avoidActiveEntities Optional. Default is false.
+ */
+export function findFreePosition(startingPosition, avoidActiveEntities = false) {
+    const room = game.GetRoom();
+    const heavenDoors = getEffects(EffectVariant.HEAVEN_LIGHT_DOOR, HeavenLightDoorSubType.HEAVEN_DOOR);
+    for (let i = 0; i < MAX_FIND_FREE_POSITION_ATTEMPTS; i++) {
+        const position = room.FindFreePickupSpawnPosition(startingPosition, i, avoidActiveEntities);
+        const closePlayer = getPlayerCloserThan(position, DISTANCE_OF_GRID_TILE);
+        if (closePlayer !== undefined) {
+            continue;
+        }
+        const isCloseHeavenDoor = anyEntityCloserThan(heavenDoors, position, DISTANCE_OF_GRID_TILE);
+        if (isCloseHeavenDoor) {
+            continue;
+        }
+        return position;
+    }
+    // We failed to find a free position in N iterations.
+    return room.FindFreePickupSpawnPosition(startingPosition);
+}
+/**
+ * Helper function to get a map containing the positions of every entity in the current room.
+ *
+ * This is useful for rewinding entity positions at a later time. Also see `setEntityPositions`.
+ *
+ * @param entities Optional. If provided, will only get the positions of the provided entities. Use
+ *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
+ *                 multiple times.
+ */
+export function getEntityPositions(entities) {
+    if (entities === undefined) {
+        entities = getEntities();
+    }
+    const entityPositions = new Map();
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        entityPositions.set(ptrHash, entity.Position);
+    }
+    return entityPositions;
+}
+/**
+ * Helper function to get a map containing the velocities of every entity in the current room.
+ *
+ * This is useful for rewinding entity velocities at a later time. Also see `setEntityVelocities`.
+ *
+ * @param entities Optional. If provided, will only get the velocities of the provided entities. Use
+ *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
+ *                 multiple times.
+ */
+export function getEntityVelocities(entities) {
+    if (entities === undefined) {
+        entities = getEntities();
+    }
+    const entityVelocities = new Map();
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        entityVelocities.set(ptrHash, entity.Velocity);
+    }
+    return entityVelocities;
+}
+/**
+ * Helper function to set the position of every entity in the room based on a map of positions. If
+ * an entity is found that does not have matching element in the provided map, then that entity will
+ * be skipped.
+ *
+ * This function is useful for rewinding entity positions at a later time. Also see
+ * `getEntityPositions`.
+ *
+ * @param entityPositions The map providing the positions for every entity.
+ * @param entities Optional. If provided, will only set the positions of the provided entities. Use
+ *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
+ *                 multiple times.
+ */
+export function setEntityPositions(entityPositions, entities) {
+    if (entities === undefined) {
+        entities = getEntities();
+    }
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        const entityPosition = entityPositions.get(ptrHash);
+        if (entityPosition !== undefined) {
+            entity.Position = entityPosition;
+        }
+    }
+}
+/**
+ * Helper function to set the velocity of every entity in the room based on a map of velocities. If
+ * an entity is found that does not have matching element in the provided map, then that entity will
+ * be skipped.
+ *
+ * This function is useful for rewinding entity velocities at a later time. Also see
+ * `getEntityVelocities`.
+ *
+ * @param entityVelocities The map providing the velocities for every entity.
+ * @param entities Optional. If provided, will only set the velocities of the provided entities. Use
+ *                 this with cached entities to avoid invoking the `Isaac.GetRoomEntities` method
+ *                 multiple times.
+ */
+export function setEntityVelocities(entityVelocities, entities) {
+    if (entities === undefined) {
+        entities = getEntities();
+    }
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        const entityVelocity = entityVelocities.get(ptrHash);
+        if (entityVelocity !== undefined) {
+            entity.Velocity = entityVelocity;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/positionVelocity.lua

@@ -152,3 +152,5 @@ function ____exports.setEntityVelocities(self, entityVelocities, entities)
     end
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL3Bvc2l0aW9uVmVsb2NpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSw2Q0FHTztBQUZMO0FBQ0E7QUFFRiwwQkFBcUI7QUFBWjtBQUNULHNCQUFzQztBQUE3QjtBQUNULG1CQUE0QjtBQUFuQjtBQUNULDJCQUEyQjtBQUFsQjtBQUNULG1CQUFvQztBQUEzQjtBQUNULHdCQUEyQjtBQUFsQjtBQUVILHdDQUFrQztBQUV4QywrQ0FDRSxVQUNBLFVBQ0E7QUFFQSxXQUFPO1FBQUE7UUFDTCxlQUFDLFFBQVcsZ0JBQVMsU0FBUyxvQkFBb0IsUUFBbEQ7O0FBTko7O0FBV0EsK0NBQ0UsVUFDQTtBQUVNLG9CQUFVO0FBQ2hCLFdBQU87UUFBQTtRQUNMLGVBQUMsUUFBVyx1QkFBZ0IsU0FBUyxhQUFhLFFBQWxEOztBQU5KOzs7Ozs7Ozs7O0FBcUJBLDRDQUNFLGtCQUNBO09BQUE7UUFBQSxzQkFBc0I7O0FBRWhCLGlCQUFPLEtBQUs7QUFDWix3QkFBYyxnQkFDbEIsaUNBQ0E7O0FBR08sa0JBQUk7Y0FBRyxJQUFJOztBQUNaLGlDQUFXLEtBQUssNEJBQ3BCLGtCQUNBLEdBQ0E7QUFHSSxvQ0FBYyx5QkFBb0IsVUFBVTttQkFDOUM7QUFDRjs7QUFHSSwwQ0FBb0IscUNBQ3hCLGFBQ0EsVUFDQTttQkFFRTtBQUNGOztBQUdGLHVCQUFPOzs7QUFyQjRDOzs7QUF5QnJELFdBQU8sS0FBSyw0QkFBNEI7QUFuQzFDOzs7Ozs7OztBQStDQSw4Q0FBbUM7T0FDN0I7QUFDRixtQkFBVzs7QUFHUCw0QkFBa0IsVUFBSTtBQUM1QixjQUFXLGlCQUFVO0FBQ2Isd0JBQVUsV0FBVztRQUMzQixnQkFBZ0IsSUFBSSxTQUFTOztBQUcvQixXQUFPO0FBWFQ7Ozs7Ozs7O0FBdUJBLCtDQUFvQztPQUM5QjtBQUNGLG1CQUFXOztBQUdQLDZCQUFtQixVQUFJO0FBQzdCLGNBQVcsaUJBQVU7QUFDYix3QkFBVSxXQUFXO1FBQzNCLGlCQUFpQixJQUFJLFNBQVM7O0FBR2hDLFdBQU87QUFYVDs7Ozs7Ozs7Ozs7O0FBMkJBLDhDQUNFLGlCQUNBO09BRUk7QUFDRixtQkFBVzs7QUFHYixjQUFXLGlCQUFVO0FBQ2Isd0JBQVUsV0FBVztBQUNyQiwrQkFBaUIsZ0JBQWdCLElBQUk7V0FDdkM7QUFDRiw4QkFBa0I7OztBQVp4Qjs7Ozs7Ozs7Ozs7O0FBOEJBLCtDQUNFLGtCQUNBO09BRUk7QUFDRixtQkFBVzs7QUFHYixjQUFXLGlCQUFVO0FBQ2Isd0JBQVUsV0FBVztBQUNyQiwrQkFBaUIsaUJBQWlCLElBQUk7V0FDeEM7QUFDRiw4QkFBa0I7OztBQVp4QiIsImZpbGUiOiJwb3NpdGlvblZlbG9jaXR5Lmx1YSIsInNvdXJjZVJvb3QiOiIifQ==

package/functions/random.js

@@ -0,0 +1,73 @@
+import { getRandomSeed, isRNG, newRNG } from "./rng";
+/**
+ * This returns a random float between 0 and 1. It is inclusive on the low end, but exclusive on the
+ * high end. (This is because the `RNG.RandomFloat` method will never return a value of exactly 1.)
+ *
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ */
+export function getRandom(seedOrRNG = getRandomSeed()) {
+    const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
+    return rng.RandomFloat();
+}
+/**
+ * This returns a random float between min and max.
+ *
+ * For example:
+ *
+ * ```ts
+ * const realNumberBetweenOneAndThree = getRandomFloat(1, 3);
+ * ```
+ *
+ * @param min The lower bound for the random number (inclusive).
+ * @param max The upper bound for the random number (exclusive).
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ */
+export function getRandomFloat(min, max, seedOrRNG = getRandomSeed()) {
+    if (min > max) {
+        const oldMin = min;
+        const oldMax = max;
+        min = oldMax;
+        max = oldMin;
+    }
+    // From: https://stackoverflow.com/questions/40431966
+    return min + getRandom(seedOrRNG) * (max - min);
+}
+/**
+ * This returns a random integer between min and max. It is inclusive on both ends.
+ *
+ * Note that this function will invoke the `Next` method on the `RNG` object before returning the
+ * random number.
+ *
+ * For example:
+ *
+ * ```ts
+ * const oneTwoOrThree = getRandomInt(1, 3);
+ * ```
+ *
+ * @param min The lower bound for the random number (inclusive).
+ * @param max The upper bound for the random number (inclusive).
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of elements that will be skipped over when getting the
+ *                   random integer. For example, a min of 1, a max of 4, and an exceptions array of
+ *                   `[2]` would cause the function to return either 1, 3, or 4. Default is an empty
+ *                   array.
+ */
+export function getRandomInt(min, max, seedOrRNG = getRandomSeed(), exceptions = []) {
+    const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
+    if (min > max) {
+        const oldMin = min;
+        const oldMax = max;
+        min = oldMax;
+        max = oldMin;
+    }
+    const exceptionsSet = new Set(exceptions);
+    let randomInt;
+    do {
+        randomInt = rng.RandomInt(max - min + 1) + min;
+    } while (exceptionsSet.has(randomInt));
+    return randomInt;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFuZG9tLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mdW5jdGlvbnMvcmFuZG9tLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLE9BQU8sQ0FBQztBQUVyRDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsU0FBUyxDQUFDLFlBQXdCLGFBQWEsRUFBRTtJQUMvRCxNQUFNLEdBQUcsR0FBRyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQzdELE9BQU8sR0FBRyxDQUFDLFdBQVcsRUFBRSxDQUFDO0FBQzNCLENBQUM7QUFFRDs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsTUFBTSxVQUFVLGNBQWMsQ0FDNUIsR0FBUSxFQUNSLEdBQVEsRUFDUixZQUF3QixhQUFhLEVBQUU7SUFFdkMsSUFBSSxHQUFHLEdBQUcsR0FBRyxFQUFFO1FBQ2IsTUFBTSxNQUFNLEdBQUcsR0FBRyxDQUFDO1FBQ25CLE1BQU0sTUFBTSxHQUFHLEdBQUcsQ0FBQztRQUNuQixHQUFHLEdBQUcsTUFBTSxDQUFDO1FBQ2IsR0FBRyxHQUFHLE1BQU0sQ0FBQztLQUNkO0lBRUQscURBQXFEO0lBQ3JELE9BQU8sR0FBRyxHQUFHLFNBQVMsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUMsQ0FBQztBQUNsRCxDQUFDO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBb0JHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FDMUIsR0FBUSxFQUNSLEdBQVEsRUFDUixZQUF3QixhQUFhLEVBQUUsRUFDdkMsYUFBcUMsRUFBRTtJQUV2QyxNQUFNLEdBQUcsR0FBRyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBRTdELElBQUksR0FBRyxHQUFHLEdBQUcsRUFBRTtRQUNiLE1BQU0sTUFBTSxHQUFHLEdBQUcsQ0FBQztRQUNuQixNQUFNLE1BQU0sR0FBRyxHQUFHLENBQUM7UUFDbkIsR0FBRyxHQUFHLE1BQU0sQ0FBQztRQUNiLEdBQUcsR0FBRyxNQUFNLENBQUM7S0FDZDtJQUVELE1BQU0sYUFBYSxHQUFHLElBQUksR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRTFDLElBQUksU0FBYyxDQUFDO0lBQ25CLEdBQUc7UUFDRCxTQUFTLEdBQUcsR0FBRyxDQUFDLFNBQVMsQ0FBQyxHQUFHLEdBQUcsR0FBRyxHQUFHLENBQUMsQ0FBQyxHQUFHLEdBQUcsQ0FBQztLQUNoRCxRQUFRLGFBQWEsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLEVBQUU7SUFFdkMsT0FBTyxTQUFTLENBQUM7QUFDbkIsQ0FBQyJ9

package/functions/random.lua

@@ -85,3 +85,5 @@ function ____exports.getRandomInt(self, min, max, seedOrRNG, exceptions)
     return randomInt
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL3JhbmRvbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsZ0JBQTZDO0FBQXBDO0FBQWU7QUFBTzs7Ozs7O0FBUy9CLHFDQUEwQjtPQUFBO1FBQUEsWUFBd0I7O0FBQzFDLGdCQUFNLFdBQU0sZUFBYSxhQUFZLFlBQU87QUFDbEQsV0FBTyxJQUFJO0FBRmI7Ozs7Ozs7Ozs7Ozs7QUFtQkEsMENBQ0UsS0FDQSxLQUNBO09BQUE7UUFBQSxZQUF3Qjs7T0FFcEIsTUFBTTtBQUNGLHVCQUFTO0FBQ1QsdUJBQVM7QUFDZixjQUFNO0FBQ04sY0FBTTs7QUFJUixXQUFPLE1BQU0sMkJBQVUsYUFBYyxPQUFNO0FBYjdDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQXFDQSx3Q0FDRSxLQUNBLEtBQ0EsV0FDQTtPQURBO1FBQUEsWUFBd0I7O09BQ3hCO1FBQUEsYUFBcUM7O0FBRS9CLGdCQUFNLFdBQU0sZUFBYSxhQUFZLFlBQU87T0FFOUMsTUFBTTtBQUNGLHVCQUFTO0FBQ1QsdUJBQVM7QUFDZixjQUFNO0FBQ04sY0FBTTs7QUFHRiwwQkFBZ0IsVUFBSSxLQUFJO0FBRTFCOzs7QUFFRix3QkFBWSxJQUFJLFVBQVUsTUFBTSxNQUFNLEtBQUs7O1VBQ3BDLGtCQUFjLElBQUk7QUFFM0IsV0FBTztBQXRCVCIsImZpbGUiOiJyYW5kb20ubHVhIiwic291cmNlUm9vdCI6IiJ9