isaacscript-common 6.6.1-dev.1 → 6.6.1-dev.2

package/functions/saveFile.js

@@ -0,0 +1,104 @@
+import { CollectibleType, PlayerType, TrinketType, } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { getCollectibleSet } from "./collectibleSet";
+import { anyPlayerHasCollectible, getPlayersOfType } from "./player";
+import { mapGetPlayer, mapSetPlayer } from "./playerDataStructures";
+import { getPlayers } from "./playerIndex";
+import { repeat } from "./utils";
+const COLLECTIBLES_THAT_AFFECT_ITEM_POOLS = [
+    CollectibleType.CHAOS,
+    CollectibleType.SACRED_ORB,
+    CollectibleType.TMTRAINER, // 721
+];
+const TRINKETS_THAT_AFFECT_ITEM_POOLS = [
+    TrinketType.NO,
+];
+/**
+ * Helper function to see if the given collectible is unlocked on the player's save file. This
+ * requires providing the corresponding item pool that the collectible is located in.
+ *
+ * - If any player currently has the item, then it is assumed to be unlocked. (This is because Eden
+ *   may have randomly started with the provided collectible, and it will be subsequently removed
+ *   from all pools.)
+ * - If the collectible is located in more than one item pool, then any item pool can be provided.
+ * - If the collectible is not located in any item pools, then this function will always return
+ *   false.
+ * - If any player is Tainted Lost, they will be temporarily changed to Isaac and then temporarily
+ *   changed back (because Tainted Lost is not able to retrieve some collectibles from item pools).
+ */
+export function isCollectibleUnlocked(collectibleTypeToCheckFor, itemPoolToCheckFor) {
+    // If Eden is holding this collectible, then it is obviously unlocked (and it will also be removed
+    // from pools, so the below check won't work).
+    if (anyPlayerHasCollectible(collectibleTypeToCheckFor)) {
+        return true;
+    }
+    // On Tainted Lost, it is impossible to retrieve non-offensive collectibles from pools, so we
+    // temporarily change the character to Isaac.
+    const taintedLosts = getPlayersOfType(PlayerType.THE_LOST_B);
+    for (const player of taintedLosts) {
+        player.ChangePlayerType(PlayerType.ISAAC);
+    }
+    // Before checking the item pools, remove any collectibles or trinkets that affect retrieved
+    // collectible types.
+    const removedItemsMap = new Map();
+    const removedTrinketsMap = new Map();
+    for (const player of getPlayers()) {
+        const removedItems = [];
+        for (const itemToRemove of COLLECTIBLES_THAT_AFFECT_ITEM_POOLS) {
+            if (player.HasCollectible(itemToRemove)) {
+                const numCollectibles = player.GetCollectibleNum(itemToRemove);
+                repeat(numCollectibles, () => {
+                    player.RemoveCollectible(itemToRemove);
+                    removedItems.push(itemToRemove);
+                });
+            }
+        }
+        mapSetPlayer(removedItemsMap, player, removedItems);
+        const removedTrinkets = [];
+        for (const trinketToRemove of TRINKETS_THAT_AFFECT_ITEM_POOLS) {
+            if (player.HasTrinket(trinketToRemove)) {
+                const numTrinkets = player.GetTrinketMultiplier(trinketToRemove);
+                repeat(numTrinkets, () => {
+                    player.TryRemoveTrinket(trinketToRemove);
+                    removedTrinkets.push(trinketToRemove);
+                });
+            }
+        }
+        mapSetPlayer(removedTrinketsMap, player, removedTrinkets);
+    }
+    // Blacklist every collectible in the game except for the provided collectible.
+    const itemPool = game.GetItemPool();
+    const collectibleSet = getCollectibleSet();
+    for (const collectibleType of collectibleSet.values()) {
+        if (collectibleType !== collectibleTypeToCheckFor) {
+            itemPool.AddRoomBlacklist(collectibleType);
+        }
+    }
+    // Get a collectible from the pool and see if it is the intended collectible. (We can use any
+    // arbitrary value as the seed since it should not influence the result.)
+    const retrievedCollectibleType = itemPool.GetCollectible(itemPoolToCheckFor, false, 1);
+    const collectibleUnlocked = retrievedCollectibleType === collectibleTypeToCheckFor;
+    // Reset the blacklist
+    itemPool.ResetRoomBlacklist();
+    // Give back items/trinkets, if necessary.
+    for (const player of getPlayers()) {
+        const removedItems = mapGetPlayer(removedItemsMap, player);
+        if (removedItems !== undefined) {
+            for (const collectibleType of removedItems) {
+                player.AddCollectible(collectibleType, 0, false); // Prevent Chaos from spawning pickups
+            }
+        }
+        const removedTrinkets = mapGetPlayer(removedTrinketsMap, player);
+        if (removedTrinkets !== undefined) {
+            for (const trinketType of removedTrinkets) {
+                player.AddTrinket(trinketType, false);
+            }
+        }
+    }
+    // Change any players back to Tainted Lost, if necessary.
+    for (const player of taintedLosts) {
+        player.ChangePlayerType(PlayerType.THE_LOST_B);
+    }
+    return collectibleUnlocked;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F2ZUZpbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2Z1bmN0aW9ucy9zYXZlRmlsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUVmLFVBQVUsRUFDVixXQUFXLEdBQ1osTUFBTSw4QkFBOEIsQ0FBQztBQUN0QyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFeEMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDckQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLGdCQUFnQixFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDcEUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBRWpDLE1BQU0sbUNBQW1DLEdBQStCO0lBQ3RFLGVBQWUsQ0FBQyxLQUFLO0lBQ3JCLGVBQWUsQ0FBQyxVQUFVO0lBQzFCLGVBQWUsQ0FBQyxTQUFTLEVBQUUsTUFBTTtDQUNsQyxDQUFDO0FBRUYsTUFBTSwrQkFBK0IsR0FBMkI7SUFDOUQsV0FBVyxDQUFDLEVBQUU7Q0FDZixDQUFDO0FBRUY7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQixDQUNuQyx5QkFBMEMsRUFDMUMsa0JBQWdDO0lBRWhDLGtHQUFrRztJQUNsRyw4Q0FBOEM7SUFDOUMsSUFBSSx1QkFBdUIsQ0FBQyx5QkFBeUIsQ0FBQyxFQUFFO1FBQ3RELE9BQU8sSUFBSSxDQUFDO0tBQ2I7SUFFRCw2RkFBNkY7SUFDN0YsNkNBQTZDO0lBQzdDLE1BQU0sWUFBWSxHQUFHLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUM3RCxLQUFLLE1BQU0sTUFBTSxJQUFJLFlBQVksRUFBRTtRQUNqQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO0tBQzNDO0lBRUQsNEZBQTRGO0lBQzVGLHFCQUFxQjtJQUNyQixNQUFNLGVBQWUsR0FBRyxJQUFJLEdBQUcsRUFBa0MsQ0FBQztJQUNsRSxNQUFNLGtCQUFrQixHQUFHLElBQUksR0FBRyxFQUE4QixDQUFDO0lBQ2pFLEtBQUssTUFBTSxNQUFNLElBQUksVUFBVSxFQUFFLEVBQUU7UUFDakMsTUFBTSxZQUFZLEdBQXNCLEVBQUUsQ0FBQztRQUMzQyxLQUFLLE1BQU0sWUFBWSxJQUFJLG1DQUFtQyxFQUFFO1lBQzlELElBQUksTUFBTSxDQUFDLGNBQWMsQ0FBQyxZQUFZLENBQUMsRUFBRTtnQkFDdkMsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxDQUFDO2dCQUMvRCxNQUFNLENBQUMsZUFBZSxFQUFFLEdBQUcsRUFBRTtvQkFDM0IsTUFBTSxDQUFDLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxDQUFDO29CQUN2QyxZQUFZLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO2dCQUNsQyxDQUFDLENBQUMsQ0FBQzthQUNKO1NBQ0Y7UUFFRCxZQUFZLENBQUMsZUFBZSxFQUFFLE1BQU0sRUFBRSxZQUFZLENBQUMsQ0FBQztRQUVwRCxNQUFNLGVBQWUsR0FBa0IsRUFBRSxDQUFDO1FBQzFDLEtBQUssTUFBTSxlQUFlLElBQUksK0JBQStCLEVBQUU7WUFDN0QsSUFBSSxNQUFNLENBQUMsVUFBVSxDQUFDLGVBQWUsQ0FBQyxFQUFFO2dCQUN0QyxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMsb0JBQW9CLENBQUMsZUFBZSxDQUFDLENBQUM7Z0JBQ2pFLE1BQU0sQ0FBQyxXQUFXLEVBQUUsR0FBRyxFQUFFO29CQUN2QixNQUFNLENBQUMsZ0JBQWdCLENBQUMsZUFBZSxDQUFDLENBQUM7b0JBQ3pDLGVBQWUsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7Z0JBQ3hDLENBQUMsQ0FBQyxDQUFDO2FBQ0o7U0FDRjtRQUVELFlBQVksQ0FBQyxrQkFBa0IsRUFBRSxNQUFNLEVBQUUsZUFBZSxDQUFDLENBQUM7S0FDM0Q7SUFFRCwrRUFBK0U7SUFDL0UsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3BDLE1BQU0sY0FBYyxHQUFHLGlCQUFpQixFQUFFLENBQUM7SUFDM0MsS0FBSyxNQUFNLGVBQWUsSUFBSSxjQUFjLENBQUMsTUFBTSxFQUFFLEVBQUU7UUFDckQsSUFBSSxlQUFlLEtBQUsseUJBQXlCLEVBQUU7WUFDakQsUUFBUSxDQUFDLGdCQUFnQixDQUFDLGVBQWUsQ0FBQyxDQUFDO1NBQzVDO0tBQ0Y7SUFFRCw2RkFBNkY7SUFDN0YseUVBQXlFO0lBQ3pFLE1BQU0sd0JBQXdCLEdBQUcsUUFBUSxDQUFDLGNBQWMsQ0FDdEQsa0JBQWtCLEVBQ2xCLEtBQUssRUFDTCxDQUFTLENBQ1YsQ0FBQztJQUVGLE1BQU0sbUJBQW1CLEdBQ3ZCLHdCQUF3QixLQUFLLHlCQUF5QixDQUFDO0lBRXpELHNCQUFzQjtJQUN0QixRQUFRLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztJQUU5QiwwQ0FBMEM7SUFDMUMsS0FBSyxNQUFNLE1BQU0sSUFBSSxVQUFVLEVBQUUsRUFBRTtRQUNqQyxNQUFNLFlBQVksR0FBRyxZQUFZLENBQUMsZUFBZSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQzNELElBQUksWUFBWSxLQUFLLFNBQVMsRUFBRTtZQUM5QixLQUFLLE1BQU0sZUFBZSxJQUFJLFlBQVksRUFBRTtnQkFDMUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxlQUFlLEVBQUUsQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsc0NBQXNDO2FBQ3pGO1NBQ0Y7UUFFRCxNQUFNLGVBQWUsR0FBRyxZQUFZLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDakUsSUFBSSxlQUFlLEtBQUssU0FBUyxFQUFFO1lBQ2pDLEtBQUssTUFBTSxXQUFXLElBQUksZUFBZSxFQUFFO2dCQUN6QyxNQUFNLENBQUMsVUFBVSxDQUFDLFdBQVcsRUFBRSxLQUFLLENBQUMsQ0FBQzthQUN2QztTQUNGO0tBQ0Y7SUFFRCx5REFBeUQ7SUFDekQsS0FBSyxNQUFNLE1BQU0sSUFBSSxZQUFZLEVBQUU7UUFDakMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQztLQUNoRDtJQUVELE9BQU8sbUJBQW1CLENBQUM7QUFDN0IsQ0FBQyJ9

package/functions/seeds.js

@@ -0,0 +1,18 @@
+import { game } from "../cachedClasses";
+import { newRNG } from "./rng";
+/** Alias for the `Seeds.GetStartSeedString` method. */
+export function getStartSeedString() {
+    const seeds = game.GetSeeds();
+    return seeds.GetStartSeedString();
+}
+/**
+ * Helper function to get the next seed value.
+ *
+ * This function is useful when you are working with seed values directly over RNG objects.
+ */
+export function nextSeed(seed) {
+    const rng = newRNG(seed);
+    rng.Next();
+    return rng.GetSeed();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VlZHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2Z1bmN0aW9ucy9zZWVkcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDeEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLE9BQU8sQ0FBQztBQUUvQix1REFBdUQ7QUFDdkQsTUFBTSxVQUFVLGtCQUFrQjtJQUNoQyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDOUIsT0FBTyxLQUFLLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztBQUNwQyxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxRQUFRLENBQUMsSUFBVTtJQUNqQyxNQUFNLEdBQUcsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDekIsR0FBRyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ1gsT0FBTyxHQUFHLENBQUMsT0FBTyxFQUFFLENBQUM7QUFDdkIsQ0FBQyJ9

package/functions/serialization.js

@@ -0,0 +1,52 @@
+import { SerializationType } from "../enums/SerializationType";
+import { ISAAC_API_CLASS_TYPE_TO_BRAND } from "../objects/isaacAPIClassTypeToBrand";
+import { ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION } from "../objects/isaacAPIClassTypeToCopyFunction";
+import { SERIALIZED_ISAAC_API_CLASS_TYPE_TO_IDENTITY_FUNCTION } from "../objects/serializedIsaacAPIClassTypeToIdentityFunction";
+import { getIsaacAPIClassName } from "./isaacAPIClass";
+import { isTable, isUserdata } from "./types";
+export function copyIsaacAPIClass(isaacAPIClass, serializationType) {
+    if (!isUserdata(isaacAPIClass)) {
+        error(`Failed to copy an Isaac API class since the provided object was of type: ${typeof isaacAPIClass}`);
+    }
+    const isaacAPIClassType = getIsaacAPIClassName(isaacAPIClass);
+    if (isaacAPIClassType === undefined) {
+        error("Failed to copy an Isaac API class since it does not have a class type.");
+    }
+    const copyableIsaacAPIClassType = isaacAPIClassType;
+    const copyFunction = ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION[copyableIsaacAPIClassType];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (copyFunction === undefined) {
+        error(`Failed to copy Isaac API class "${copyableIsaacAPIClassType}" since there is not a defined copy function for this class type.`);
+    }
+    return copyFunction(isaacAPIClass, serializationType);
+}
+/**
+ * Deserialization is a special case, so we make a dedicated function for this.
+ *
+ * There is no need for a corresponding "serializeIsaacAPIClass" function because the
+ * "copyIsaacAPIClass" function can handle all serialization types.
+ */
+export function deserializeIsaacAPIClass(serializedIsaacAPIClass) {
+    if (!isTable(serializedIsaacAPIClass)) {
+        error(`Failed to deserialize an Isaac API class since the provided object was of type: ${typeof serializedIsaacAPIClass}`);
+    }
+    const copyableIsaacAPIClassType = getSerializedTableType(serializedIsaacAPIClass);
+    if (copyableIsaacAPIClassType === undefined) {
+        error("Failed to deserialize an API class since a valid class type brand was not found.");
+    }
+    const copyFunction = ISAAC_API_CLASS_TYPE_TO_COPY_FUNCTION[copyableIsaacAPIClassType];
+    return copyFunction(serializedIsaacAPIClass, SerializationType.DESERIALIZE);
+}
+function getSerializedTableType(serializedIsaacAPIClass) {
+    for (const [copyableIsaacAPIClassType, serializationBrand] of Object.entries(ISAAC_API_CLASS_TYPE_TO_BRAND)) {
+        if (serializedIsaacAPIClass.has(serializationBrand)) {
+            return copyableIsaacAPIClassType;
+        }
+    }
+    return undefined;
+}
+export function isSerializedIsaacAPIClass(object) {
+    const identityFunctions = Object.values(SERIALIZED_ISAAC_API_CLASS_TYPE_TO_IDENTITY_FUNCTION);
+    return identityFunctions.some((identityFunction) => identityFunction(object));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/set.js

@@ -0,0 +1,99 @@
+import { getArrayCombinations, getRandomArrayElement } from "./array";
+import { getRandomSeed } from "./rng";
+/**
+ * Helper function to add all of the values in one set to another set. The first set passed will be
+ * modified in place.
+ *
+ * This function is variadic, meaning that you can specify N sets to add to the first set.
+ */
+export function addSetsToSet(mainSet, ...setsToAdd) {
+    for (const set of setsToAdd) {
+        for (const value of set.values()) {
+            mainSet.add(value);
+        }
+    }
+}
+/**
+ * Helper function to create a new set that is the composition of two or more sets.
+ *
+ * This function is variadic, meaning that you can specify N sets.
+ */
+export function combineSets(...sets) {
+    const newSet = new Set();
+    for (const set of sets) {
+        for (const value of set.values()) {
+            newSet.add(value);
+        }
+    }
+    return newSet;
+}
+/** Helper function to copy a set. (You can also use a Set constructor to accomplish this task.) */
+export function copySet(oldSet) {
+    const newSet = new Set();
+    for (const value of oldSet.values()) {
+        newSet.add(value);
+    }
+    return newSet;
+}
+/**
+ * Helper function to delete all of the values in one set from another set. The first set passed
+ * will be modified in place.
+ *
+ * This function is variadic, meaning that you can specify N sets to remove from the first set.
+ */
+export function deleteSetsFromSet(mainSet, ...setsToRemove) {
+    for (const set of setsToRemove) {
+        for (const value of set.values()) {
+            mainSet.delete(value);
+        }
+    }
+}
+/**
+ * Helper function to get a random element from the provided set.
+ *
+ * @param set The set to get an element from.
+ * @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 to skip over if selected.
+ */
+export function getRandomSetElement(set, seedOrRNG = getRandomSeed(), exceptions = []) {
+    const array = getSortedSetValues(set);
+    return getRandomArrayElement(array, seedOrRNG, exceptions);
+}
+/**
+ * Helper function to get all possible combinations of the given set. This includes the combination
+ * of an empty set.
+ *
+ * For example, if this function is provided a set containing 1, 2, and 3, then it will return an
+ * array containing the following sets:
+ *
+ * - [] (if `includeEmptyArray` is set to true)
+ * - [1]
+ * - [2]
+ * - [3]
+ * - [1, 2]
+ * - [1, 3]
+ * - [2, 3]
+ * - [1, 2, 3]
+ *
+ * @param set The set to get the combinations of.
+ * @param includeEmptyArray Whether or not to include an empty array in the combinations.
+ */
+export function getSetCombinations(set, includeEmptyArray) {
+    const values = getSortedSetValues(set);
+    const combinations = getArrayCombinations(values, includeEmptyArray);
+    return combinations.map((array) => new Set(array));
+}
+/**
+ * Helper function to get a sorted array based on the contents of a set.
+ *
+ * Normally, set values are returned in a random order, so use this function when the ordering of
+ * the contents is important.
+ */
+export function getSortedSetValues(set) {
+    const values = set.values();
+    const array = [...values];
+    array.sort();
+    return array;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/sound.js

@@ -0,0 +1,9 @@
+import { SoundEffect } from "isaac-typescript-definitions";
+import { sfxManager } from "../cachedClasses";
+import { getEnumValues } from "./enums";
+export function stopAllSoundEffects() {
+    for (const soundEffect of getEnumValues(SoundEffect)) {
+        sfxManager.Stop(soundEffect);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291bmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2Z1bmN0aW9ucy9zb3VuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0QsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFeEMsTUFBTSxVQUFVLG1CQUFtQjtJQUNqQyxLQUFLLE1BQU0sV0FBVyxJQUFJLGFBQWEsQ0FBQyxXQUFXLENBQUMsRUFBRTtRQUNwRCxVQUFVLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0tBQzlCO0FBQ0gsQ0FBQyJ9

package/functions/spawnCollectible.js

@@ -0,0 +1,66 @@
+import { CollectibleType, PickupVariant, PlayerType, } from "isaac-typescript-definitions";
+import { VectorZero } from "../constants";
+import { preventCollectibleRotation } from "../features/preventCollectibleRotation";
+import { areFeaturesInitialized } from "../featuresInitialized";
+import { setCollectibleEmpty } from "./collectibles";
+import { isQuestCollectible } from "./collectibleTag";
+import { spawnPickupWithSeed } from "./entitySpecific";
+import { anyPlayerIs } from "./player";
+import { getRandomSeed, isRNG } from "./rng";
+/**
+ * Helper function to spawn a collectible. Use this instead of the `Game.Spawn` method because it
+ * handles the cases of Tainted Keeper collectibles costing coins and preventing quest items from
+ * being rotated by Tainted Isaac's rotation mechanic. (Rotation prevention will only occur in
+ * upgraded mods.)
+ *
+ * @param collectibleType The collectible type to spawn.
+ * @param position The position to spawn the collectible at.
+ * @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 options Optional. Set to true to make the collectible a "There's Options" style
+ *                collectible. Default is false.
+ * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
+ *                      Tainted Keeper. Default is false.
+ * @param spawner Optional.
+ */
+export function spawnCollectible(collectibleType, position, seedOrRNG = getRandomSeed(), options = false, forceFreeItem = false, spawner) {
+    const seed = isRNG(seedOrRNG) ? seedOrRNG.Next() : seedOrRNG;
+    const collectible = spawnPickupWithSeed(PickupVariant.COLLECTIBLE, collectibleType, position, seed, VectorZero, spawner);
+    if (options) {
+        collectible.OptionsPickupIndex = 1;
+    }
+    if (anyPlayerIs(PlayerType.KEEPER_B) &&
+        !isQuestCollectible(collectibleType) &&
+        !forceFreeItem) {
+        // When playing Tainted Keeper, collectibles are supposed to have a price, and manually spawned
+        // items will not have a price, so we have to set it manually.
+        // Setting the shop item ID in this way prevents the bug where the item will sometimes change to
+        // 99 cents.
+        collectible.ShopItemId = -1;
+        // We can set the price to any arbitrary value; it will auto-update to the true price on the
+        // next frame.
+        collectible.Price = 15;
+    }
+    if (isQuestCollectible(collectibleType) && areFeaturesInitialized()) {
+        preventCollectibleRotation(collectible, collectibleType);
+    }
+    return collectible;
+}
+/**
+ * Helper function to spawn an empty collectible. Doing this is tricky since spawning a collectible
+ * with `CollectibleType.NULL` will result in spawning a collectible with a random type from the
+ * current room's item pool.
+ *
+ * Instead, this function arbitrarily spawns a collectible with `CollectibleType.SAD_ONION`, and
+ * then converts it to an empty pedestal afterward.
+ *
+ * @param position The position to spawn the empty collectible at.
+ * @param seedOrRNG 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 spawnEmptyCollectible(position, seedOrRNG = getRandomSeed()) {
+    const collectible = spawnCollectible(CollectibleType.SAD_ONION, position, seedOrRNG, false, true);
+    setCollectibleEmpty(collectible);
+    return collectible;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/sprite.js

@@ -0,0 +1,80 @@
+import { EMPTY_PNG_PATH, VectorZero } from "../constants";
+import { kColorEquals } from "./kColor";
+import { erange } from "./utils";
+/**
+ * Helper function to clear all layers or specific layers from a sprite.
+ *
+ * This function is variadic, so pass as many layer IDs as you want to clear. If no specific layers
+ * are passed, it will clear every layer.
+ *
+ * Since there is no official API method to "clear" a sprite, we can work around it by setting the
+ * spritesheet to a non-existent or completely transparent file. If the path to the spritesheet does
+ * not exist, then this function might cause spurious errors to appear in the "log.txt file". To
+ * silence these errors, create a transparent 1 pixel PNG file in your mod's resources folder at the
+ * path corresponding to the "EMPTY_PNG_PATH" constant.
+ */
+export function clearSprite(sprite, ...layerIDs) {
+    if (layerIDs.length === 0) {
+        const numLayers = sprite.GetLayerCount();
+        layerIDs = erange(numLayers);
+    }
+    for (const layerID of layerIDs) {
+        sprite.ReplaceSpritesheet(layerID, EMPTY_PNG_PATH);
+    }
+    sprite.LoadGraphics();
+}
+/**
+ * Helper function that returns the number of the final frame in a particular animation for a
+ * sprite. By default, it will use the currently playing animation, but you can also specify a
+ * specific animation to check.
+ *
+ * Note that this function is bugged with the Stop Watch or the Broken Watch, since using the
+ * `Sprite.SetFrame` method will reset the internal accumulator used to slow down the playback speed
+ * of the animation. (The `PlaybackSpeed` property of the sprite is not used.) Thus, it is only safe
+ * to use this function on animations that are not slowed down by Stop Watch or Broken Watch, such
+ * as player animations.
+ */
+export function getLastFrameOfAnimation(sprite, animation) {
+    // Record the current sprite status.
+    const currentAnimation = sprite.GetAnimation();
+    const currentFrame = sprite.GetFrame();
+    // Get the final frame.
+    if (animation !== undefined && animation !== currentAnimation) {
+        sprite.SetAnimation(animation);
+    }
+    sprite.SetLastFrame();
+    const finalFrame = sprite.GetFrame();
+    // Set the sprite back to the way it was.
+    if (animation !== undefined && animation !== currentAnimation) {
+        sprite.Play(currentAnimation, true);
+    }
+    sprite.SetFrame(currentFrame);
+    return finalFrame;
+}
+/**
+ * Helper function to check if two sprite layers have the same sprite sheet by using the
+ * `Sprite.GetTexel` method.
+ *
+ * Since checking every single texel in the entire sprite is very expensive, this function requires
+ * that you provide a range of specific texels to check.
+ */
+export function spriteEquals(sprite1, sprite2, layerID, xStart, xFinish, xIncrement, yStart, yFinish, yIncrement) {
+    // Iterate over N texels, checking for equality at each step. The center of the sprite is equal to
+    // the "pivot" point in the anm2 file.
+    for (let x = xStart; x <= xFinish; x += xIncrement) {
+        for (let y = yStart; y <= yFinish; y += yIncrement) {
+            const position = Vector(x, y);
+            if (!texelEquals(sprite1, sprite2, position, layerID)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/** Helper function to check if two texels on a sprite are equivalent to each other. */
+export function texelEquals(sprite1, sprite2, position, layerID) {
+    const kColor1 = sprite1.GetTexel(position, VectorZero, 1, layerID);
+    const kColor2 = sprite2.GetTexel(position, VectorZero, 1, layerID);
+    return kColorEquals(kColor1, kColor2);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ByaXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mdW5jdGlvbnMvc3ByaXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzFELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDeEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUVqQzs7Ozs7Ozs7Ozs7R0FXRztBQUNILE1BQU0sVUFBVSxXQUFXLENBQUMsTUFBYyxFQUFFLEdBQUcsUUFBZTtJQUM1RCxJQUFJLFFBQVEsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO1FBQ3pCLE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUN6QyxRQUFRLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0tBQzlCO0lBRUQsS0FBSyxNQUFNLE9BQU8sSUFBSSxRQUFRLEVBQUU7UUFDOUIsTUFBTSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxjQUFjLENBQUMsQ0FBQztLQUNwRDtJQUVELE1BQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQztBQUN4QixDQUFDO0FBRUQ7Ozs7Ozs7Ozs7R0FVRztBQUNILE1BQU0sVUFBVSx1QkFBdUIsQ0FDckMsTUFBYyxFQUNkLFNBQWtCO0lBRWxCLG9DQUFvQztJQUNwQyxNQUFNLGdCQUFnQixHQUFHLE1BQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUMvQyxNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsUUFBUSxFQUFFLENBQUM7SUFFdkMsdUJBQXVCO0lBQ3ZCLElBQUksU0FBUyxLQUFLLFNBQVMsSUFBSSxTQUFTLEtBQUssZ0JBQWdCLEVBQUU7UUFDN0QsTUFBTSxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsQ0FBQztLQUNoQztJQUNELE1BQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUN0QixNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsUUFBUSxFQUFFLENBQUM7SUFFckMseUNBQXlDO0lBQ3pDLElBQUksU0FBUyxLQUFLLFNBQVMsSUFBSSxTQUFTLEtBQUssZ0JBQWdCLEVBQUU7UUFDN0QsTUFBTSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxJQUFJLENBQUMsQ0FBQztLQUNyQztJQUNELE1BQU0sQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFDLENBQUM7SUFFOUIsT0FBTyxVQUFVLENBQUM7QUFDcEIsQ0FBQztBQUVEOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQzFCLE9BQWUsRUFDZixPQUFlLEVBQ2YsT0FBWSxFQUNaLE1BQVcsRUFDWCxPQUFZLEVBQ1osVUFBZSxFQUNmLE1BQVcsRUFDWCxPQUFZLEVBQ1osVUFBZTtJQUVmLGtHQUFrRztJQUNsRyxzQ0FBc0M7SUFDdEMsS0FBSyxJQUFJLENBQUMsR0FBRyxNQUFNLEVBQUUsQ0FBQyxJQUFJLE9BQU8sRUFBRSxDQUFDLElBQUksVUFBVSxFQUFFO1FBQ2xELEtBQUssSUFBSSxDQUFDLEdBQUcsTUFBTSxFQUFFLENBQUMsSUFBSSxPQUFPLEVBQUUsQ0FBQyxJQUFJLFVBQVUsRUFBRTtZQUNsRCxNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQzlCLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsT0FBTyxDQUFDLEVBQUU7Z0JBQ3JELE9BQU8sS0FBSyxDQUFDO2FBQ2Q7U0FDRjtLQUNGO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQsdUZBQXVGO0FBQ3ZGLE1BQU0sVUFBVSxXQUFXLENBQ3pCLE9BQWUsRUFDZixPQUFlLEVBQ2YsUUFBZ0IsRUFDaEIsT0FBWTtJQUVaLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLFVBQVUsRUFBRSxDQUFDLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDbkUsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsVUFBVSxFQUFFLENBQUMsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNuRSxPQUFPLFlBQVksQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDeEMsQ0FBQyJ9

package/functions/stage.js

@@ -0,0 +1,172 @@
+import { LevelStage, StageType } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { ROOM_TYPE_GOTO_PREFIXES } from "../objects/roomTypeGotoPrefixes";
+import { STAGE_TYPE_SUFFIXES } from "../objects/stageTypeSuffixes";
+import { STAGE_TYPE_TO_LETTER } from "../objects/stageTypeToLetter";
+/**
+ * Helper function that calculates what the stage type should be for the provided stage. This
+ * emulates what the game's internal code does.
+ */
+export function calculateStageType(stage) {
+    // The following is the game's internal code to determine the floor type. (This came directly from
+    // Spider.)
+    /*
+      u32 Seed = g_Game->GetSeeds().GetStageSeed(NextStage);
+      if (!g_Game->IsGreedMode()) {
+        StageType = ((Seed % 2) == 0 && (
+          ((NextStage == STAGE1_1 || NextStage == STAGE1_2) && gd.Unlocked(ACHIEVEMENT_CELLAR)) ||
+          ((NextStage == STAGE2_1 || NextStage == STAGE2_2) && gd.Unlocked(ACHIEVEMENT_CATACOMBS)) ||
+          ((NextStage == STAGE3_1 || NextStage == STAGE3_2) && gd.Unlocked(ACHIEVEMENT_NECROPOLIS)) ||
+          ((NextStage == STAGE4_1 || NextStage == STAGE4_2)))
+        ) ? STAGE_TYPE_WOTL : STAGE_TYPE_ORIGINAL;
+      if (Seed % 3 == 0 && NextStage < STAGE5)
+        StageType = STAGE_TYPE_AFTERBIRTH;
+    */
+    const seeds = game.GetSeeds();
+    const stageSeed = seeds.GetStageSeed(stage);
+    if (stageSeed % 2 === 0) {
+        return StageType.WRATH_OF_THE_LAMB;
+    }
+    if (stageSeed % 3 === 0) {
+        return StageType.AFTERBIRTH;
+    }
+    return StageType.ORIGINAL;
+}
+/**
+ * Helper function that calculates what the Repentance stage type should be for the provided stage.
+ * This emulates what the game's internal code does.
+ */
+export function calculateStageTypeRepentance(stage) {
+    // There is no alternate floor for Corpse.
+    if (stage === LevelStage.WOMB_1 || stage === LevelStage.WOMB_2) {
+        return StageType.REPENTANCE;
+    }
+    // This algorithm is from Kilburn. We add one because the alt path is offset by 1 relative to the
+    // normal path.
+    const seeds = game.GetSeeds();
+    const adjustedStage = (stage + 1);
+    const stageSeed = seeds.GetStageSeed(adjustedStage);
+    // Kilburn does not know why he divided the stage seed by 2 first.
+    const halfStageSeed = Math.floor(stageSeed / 2);
+    if (halfStageSeed % 2 === 0) {
+        return StageType.REPENTANCE_B;
+    }
+    return StageType.REPENTANCE;
+}
+/**
+ * Helper function to account for Repentance floors being offset by 1. For example, Downpour 2 is
+ * the third level of the run, but the game considers it to have a stage of 2. This function will
+ * consider Downpour 2 to have a stage of 3.
+ */
+export function getEffectiveStage() {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    if (onRepentanceStage()) {
+        return stage + 1; // eslint-disable-line isaacscript/strict-enums
+    }
+    return stage;
+}
+/**
+ * Helper function to get the corresponding "goto" console command that would correspond to the
+ * provided room type and room variant.
+ */
+export function getGotoCommand(roomType, roomVariant) {
+    const prefix = ROOM_TYPE_GOTO_PREFIXES[roomType];
+    return `goto ${prefix}.${roomVariant}`;
+}
+/** Alias for the `Level.GetStage` method. */
+export function getStage() {
+    const level = game.GetLevel();
+    return level.GetStage();
+}
+/** Alias for the `Level.GetStageType` method. */
+export function getStageType() {
+    const level = game.GetLevel();
+    return level.GetStageType();
+}
+/** Helper function to directly warp to a specific stage using the "stage" console command. */
+export function goToStage(stage, stageType) {
+    const stageTypeLetterSuffix = stageTypeToLetter(stageType);
+    const command = `stage ${stage}${stageTypeLetterSuffix}`;
+    Isaac.ExecuteCommand(command);
+}
+export function isRepentanceStage(stageType) {
+    return (stageType === StageType.REPENTANCE || stageType === StageType.REPENTANCE_B);
+}
+export function onCathedral() {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+    return (stage === LevelStage.SHEOL_CATHEDRAL &&
+        stageType === StageType.WRATH_OF_THE_LAMB);
+}
+export function onChest() {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+    return (stage === LevelStage.DARK_ROOM_CHEST &&
+        stageType === StageType.WRATH_OF_THE_LAMB);
+}
+export function onDarkRoom() {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+    return (stage === LevelStage.DARK_ROOM_CHEST && stageType === StageType.ORIGINAL);
+}
+/**
+ * Returns whether or not the player is on the "final floor" of the particular run. The final floor
+ * is defined as one that prevents the player from entering the I AM ERROR room on.
+ *
+ * For example, when using Undefined on The Chest, it has a 50% chance of teleporting the player to
+ * the Secret Room and a 50% chance of teleporting the player to the Super Secret Room, because the
+ * I AM ERROR room is never entered into the list of possibilities.
+ */
+export function onFinalFloor() {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    return (stage === LevelStage.DARK_ROOM_CHEST ||
+        stage === LevelStage.THE_VOID ||
+        stage === LevelStage.HOME ||
+        (stage === LevelStage.WOMB_2 && onRepentanceStage()) // Corpse 2
+    );
+}
+export function onRepentanceStage() {
+    const level = game.GetLevel();
+    const stageType = level.GetStageType();
+    return isRepentanceStage(stageType);
+}
+export function onSheol() {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+    return (stage === LevelStage.SHEOL_CATHEDRAL && stageType === StageType.ORIGINAL);
+}
+/**
+ * Helper function to warp to a new stage/level.
+ *
+ * @param stage The stage number to warp to.
+ * @param stageType The stage type to warp to.
+ * @param reseed Optional. Whether or not to reseed the floor upon arrival. Default is false. Set
+ *               this to true if you are warping to the same stage but a different stage type (or
+ *               else the floor layout will be identical to the old floor).
+ */
+export function setStage(stage, stageType, reseed = false) {
+    // Build the command that will take us to the next floor.
+    const stageTypeSuffix = STAGE_TYPE_SUFFIXES[stageType];
+    const command = `stage ${stage}${stageTypeSuffix}`;
+    Isaac.ExecuteCommand(command);
+    if (reseed) {
+        // Doing a "reseed" immediately after a "stage" command won't mess anything up.
+        Isaac.ExecuteCommand("reseed");
+    }
+}
+/**
+ * Helper function to convert a numerical `StageType` into the letter suffix supplied to the "stage"
+ * console command. For example, `StageType.REPENTANCE` is the stage type for Downpour, and the
+ * console command to go to Downpour is "stage 1c", so this function converts `StageType.REPENTANCE`
+ * to "c".
+ */
+export function stageTypeToLetter(stageType) {
+    return STAGE_TYPE_TO_LETTER[stageType];
+}
+//# sourceMappingURL=data:application/json;base64,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