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

package/features/deployJSONRoom.js

@@ -0,0 +1,532 @@
+// Basement Renovator can create custom rooms that are saved to XML files. These XML files can be
+// converted to JSON so that they can be imported by TypeScript code. Then, existing rooms can be
+// manually replaced with a custom room by manually removing everything in the room and rebuilding
+// it from scratch based on the JSON data.
+import { CollectibleType, EffectVariant, EntityCollisionClass, EntityFlag, EntityGridCollisionClass, EntityType, GridEntityType, ModCallback, PickupVariant, PitfallVariant, RoomType, } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { emptyArray } from "../functions/array";
+import { getEntityIDFromConstituents, removeAllMatchingEntities, spawn, spawnWithSeed, } from "../functions/entity";
+import { getNPCs, removeAllBombs, removeAllPickups, } from "../functions/entitySpecific";
+import { convertXMLGridEntityType, getAllGridIndexes, getGridEntities, getGridEntityIDFromConstituents, removeAllGridExcept, removeGrid, setGridEntityInvisible, spawnGridWithVariant, } from "../functions/gridEntity";
+import { getRandomJSONRoom } from "../functions/jsonRoom";
+import { log } from "../functions/log";
+import { getRandomSeed, isRNG, newRNG } from "../functions/rng";
+import { getRoomListIndex } from "../functions/roomData";
+import { gridCoordinatesToWorldPosition } from "../functions/roomGrid";
+import { setRoomCleared, setRoomUncleared } from "../functions/rooms";
+import { spawnCollectible } from "../functions/spawnCollectible";
+import { runNextGameFrame } from "./runInNFrames";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "deployJSONRoom";
+const NPC_TYPES_TO_NOT_REMOVE = new Set([
+    EntityType.DARK_ESAU,
+]);
+const PERSISTENT_ENTITY_TYPES = new Set([
+    EntityType.WALL_HUGGER,
+]);
+const v = {
+    level: {
+        deployedRoomListIndexes: new Set(),
+        /** Indexed by room list index. */
+        roomToPersistentEntitiesMap: new DefaultMap(() => []),
+        /** Indexed by room list index. */
+        roomToDecorationGridIndexesMap: new DefaultMap(() => []),
+    },
+    room: {
+        manuallyUsingShovel: false,
+    },
+};
+/** @internal */
+export function deployJSONRoomInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.PRE_USE_ITEM, preUseItemWeNeedToGoDeeper, CollectibleType.WE_NEED_TO_GO_DEEPER); // 23
+    mod.AddCallbackCustom(ModCallbackCustom.POST_NEW_ROOM_REORDERED, postNewRoomReordered);
+}
+// ModCallback.PRE_USE_ITEM (23)
+// CollectibleType.WE_NEED_TO_GO_DEEPER (84)
+function preUseItemWeNeedToGoDeeper(_collectibleType, _rng, player) {
+    if (v.room.manuallyUsingShovel) {
+        return undefined;
+    }
+    const roomListIndex = getRoomListIndex();
+    if (!v.level.deployedRoomListIndexes.has(roomListIndex)) {
+        return undefined;
+    }
+    // If the player uses the shovel in a JSON room, then it will always reveal a crawl space. This is
+    // because the room is filled with invisible decorations to prevent any grid entities from
+    // respawning. In order to restore the normal shovel functionality, we cancel the shovel use,
+    // remove all the decorations, wait a frame, manually use the shovel again, and then respawn the
+    // decorations. (We can't do it all on this frame because updating the room causes two invocations
+    // of the shovel to happen.)
+    const decorations = getGridEntities(GridEntityType.DECORATION);
+    for (const decoration of decorations) {
+        removeGrid(decoration, false);
+    }
+    const playerPtr = EntityPtr(player);
+    runNextGameFrame(() => {
+        const futureEntity = playerPtr.Ref;
+        if (futureEntity === undefined) {
+            return;
+        }
+        const futurePlayer = futureEntity.ToPlayer();
+        if (futurePlayer === undefined) {
+            return;
+        }
+        v.room.manuallyUsingShovel = true;
+        futurePlayer.UseActiveItem(CollectibleType.WE_NEED_TO_GO_DEEPER);
+        v.room.manuallyUsingShovel = false;
+        const decorationGridIndexes = v.level.roomToDecorationGridIndexesMap.getAndSetDefault(roomListIndex);
+        emptyArray(decorationGridIndexes);
+        fillRoomWithDecorations();
+    });
+    // Cancel the effect.
+    return true;
+}
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+    const roomListIndex = getRoomListIndex();
+    if (!v.level.deployedRoomListIndexes.has(roomListIndex)) {
+        return;
+    }
+    setDecorationsInvisible();
+    respawnPersistentEntities();
+}
+/**
+ * Every time we re-enter a deployed room, the sprites for all of the decorations will come back, so
+ * we have to remove them again.
+ */
+function setDecorationsInvisible() {
+    const room = game.GetRoom();
+    const roomListIndex = getRoomListIndex();
+    const decorationGridIndexes = v.level.roomToDecorationGridIndexesMap.getAndSetDefault(roomListIndex);
+    for (const gridIndex of decorationGridIndexes) {
+        const gridEntity = room.GetGridEntity(gridIndex);
+        if (gridEntity !== undefined) {
+            // Other grid entities may have spawned, like trapdoors or crawl spaces. Thus, only make
+            // decorations invisible.
+            const gridEntityType = gridEntity.GetType();
+            if (gridEntityType === GridEntityType.DECORATION) {
+                setGridEntityInvisible(gridEntity);
+            }
+        }
+    }
+}
+/** Some entities must be manually respawned every time the player re-enters the room. */
+function respawnPersistentEntities() {
+    const room = game.GetRoom();
+    const roomListIndex = getRoomListIndex();
+    const persistentEntities = v.level.roomToPersistentEntitiesMap.getAndSetDefault(roomListIndex);
+    for (const persistentEntity of persistentEntities) {
+        const position = room.GetGridPosition(persistentEntity.gridIndex);
+        spawn(persistentEntity.entityType, persistentEntity.variant, persistentEntity.subType, position);
+    }
+}
+/**
+ * Helper function to deconstruct a vanilla room and set up a custom room in its place.
+ * Specifically, this will clear the current room of all entities and grid entities, and then spawn
+ * all of the entries and grid entities in the provided JSON room.
+ *
+ * This function is meant to be used in the PostNewRoom callback.
+ *
+ * For example:
+ *
+ * ```ts
+ *
+ * import customRooms from "./customRooms";
+ *
+ * const firstJSONRoom = customRooms.rooms.room[0];
+ * deployJSONRoom(firstJSONRoom);
+ * ```
+ *
+ * @param jsonRoom The JSON room to deploy. *
+ * @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 verbose Optional. If specified, will write entries to the "log.txt" file that describe
+ *                what the function is doing. Default is false.
+ */
+export function deployJSONRoom(jsonRoom, seedOrRNG = getRandomSeed(), verbose = false) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
+    if (verbose) {
+        log("Starting to empty the room of entities and grid entities.");
+    }
+    emptyRoom(false);
+    if (verbose) {
+        log("Finished emptying the room of entities and grid entities.");
+    }
+    if (verbose) {
+        log("Starting to spawn all of the new entities and grid entities.");
+    }
+    spawnAllEntities(jsonRoom, rng, verbose);
+    if (verbose) {
+        log("Finished spawning all of the new entities and grid entities.");
+    }
+    fixPitGraphics();
+    fillRoomWithDecorations();
+}
+/**
+ * Helper function to deconstruct a vanilla room and set up a custom room in its place.
+ * Specifically, this will clear the current room of all entities and grid entities, and then spawn
+ * all of the entries and grid entities in one of the provided JSON rooms.
+ *
+ * This function is meant to be used in the PostNewRoom callback.
+ *
+ * Note that this function does not simply choose a random element in the provided array; it will
+ * properly account for each room weight using the algorithm from:
+ * https://stackoverflow.com/questions/1761626/weighted-random-numbers
+ *
+ * For example:
+ *
+ * ```ts
+ * import customRooms from "./customRooms";
+ *
+ * const jsonRooms = customRooms.rooms.room;
+ * deployRandomJSONRoom(jsonRooms);
+ * ```
+ *
+ * @param jsonRooms An array of JSON rooms to randomly select from. In practice, this will be
+ *                  something like.
+ * @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 verbose Optional. If specified, will write entries to the "log.txt" file that describe
+ *                what the function is doing. Default is false.
+ */
+export function deployRandomJSONRoom(jsonRooms, seedOrRNG = getRandomSeed(), verbose = false) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
+    const randomJSONRoom = getRandomJSONRoom(jsonRooms, rng, verbose);
+    if (verbose) {
+        log(`Randomly chose JSON room ${randomJSONRoom.$.type}.${randomJSONRoom.$.variant}.${randomJSONRoom.$.subtype} with name: ${randomJSONRoom.$.name}`);
+    }
+    return deployJSONRoom(randomJSONRoom, rng, verbose);
+}
+/**
+ * Helper function to remove all naturally spawning entities and grid entities from a room. Notably,
+ * this will not remove players (1), tears (2), familiars (3), lasers (7), knives (8), projectiles
+ * (9), blacklisted NPCs such as Dark Esau, charmed NPCs, friendly NPCs, persistent NPCs, most
+ * effects (1000), doors, and walls.
+ *
+ * @param fillWithDecorations Optional. Set to true to fill every grid tile with an invisible
+ *                            decoration, which prevents vanilla entities in the room from
+ *                            respawning the next time that the player enters. Default is false.
+ */
+export function emptyRoom(fillWithDecorations) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    const roomListIndex = getRoomListIndex();
+    v.level.deployedRoomListIndexes.add(roomListIndex);
+    removeAllBombs(); // 4
+    removeAllPickups(); // 5
+    removeAllMatchingEntities(EntityType.SLOT); // 6
+    removeSpecificNPCs();
+    removeAllMatchingEntities(EntityType.EFFECT, EffectVariant.DEVIL);
+    removeAllMatchingEntities(EntityType.EFFECT, EffectVariant.ANGEL);
+    removeAllGridExcept(GridEntityType.WALL, // 15
+    GridEntityType.DOOR);
+    setRoomCleared();
+    if (fillWithDecorations) {
+        fillRoomWithDecorations();
+    }
+}
+/**
+ * We remove entities in the PostNewRoom callback instead of in the PreRoomEntitySpawn callback so
+ * that they will not re-appear when we re-enter the room.
+ */
+function removeSpecificNPCs() {
+    const room = game.GetRoom();
+    for (const npc of getNPCs()) {
+        if (NPC_TYPES_TO_NOT_REMOVE.has(npc.Type)) {
+            continue;
+        }
+        if (npc.HasEntityFlags(EntityFlag.CHARM) ||
+            npc.HasEntityFlags(EntityFlag.FRIENDLY) ||
+            npc.HasEntityFlags(EntityFlag.PERSISTENT)) {
+            continue;
+        }
+        npc.ClearEntityFlags(EntityFlag.APPEAR);
+        npc.Remove();
+        // When fire places are removed, they will leave behind a "path" that will prevent future grid
+        // entities from being spawned on the same tile. Thus, reset the path for this tile if this is a
+        // fire place.
+        if (npc.Type === EntityType.FIREPLACE) {
+            const gridIndex = room.GetGridIndex(npc.Position);
+            room.SetGridPath(gridIndex, 0);
+        }
+    }
+}
+/**
+ * We removed most normal entities, which should prevent them from respawning when the player
+ * re-enters the room. However, this is not the case for grid entities; even if they are removed,
+ * they will come back when the player re-enters the room.
+ *
+ * In order to prevent this from happening, we can spawn a grid entity on every tile that does not
+ * already have a grid entity. The natural grid entity to choose for this purpose is a decoration,
+ * since it is non-interacting.
+ *
+ * Another option besides decorations would be to use a pressure plates with a state of 1, which is
+ * a state that is normally unused by the game and makes it invisible & persistent. However, pickups
+ * will not be able to spawn on pressure plates, which lead to various bugs (e.g. pickups spawning
+ * on top of pits). Thus, we use a decoration and remove its sprite to make it invisible.
+ *
+ * Yet another option is to replace the room data with that of an empty room. However, the room data
+ * must exactly match the room type, the room shape, and the doors, so this is not possible to do in
+ * a robust way without adding empty rooms to the mod's `content` folder to draw the data from.
+ */
+function fillRoomWithDecorations() {
+    const room = game.GetRoom();
+    const roomListIndex = getRoomListIndex();
+    const decorationGridIndexes = v.level.roomToDecorationGridIndexesMap.getAndSetDefault(roomListIndex);
+    for (const gridIndex of getAllGridIndexes()) {
+        const existingGridEntity = room.GetGridEntity(gridIndex);
+        if (existingGridEntity !== undefined) {
+            continue;
+        }
+        const position = room.GetGridPosition(gridIndex);
+        const decoration = Isaac.GridSpawn(GridEntityType.DECORATION, 0, position);
+        if (decoration !== undefined) {
+            setGridEntityInvisible(decoration);
+        }
+        decorationGridIndexes.push(gridIndex);
+    }
+}
+function spawnAllEntities(jsonRoom, rng, verbose = false) {
+    let shouldUnclearRoom = false;
+    for (const jsonSpawn of jsonRoom.spawn) {
+        const xString = jsonSpawn.$.x;
+        const x = tonumber(xString);
+        if (x === undefined) {
+            error(`Failed to convert the following x coordinate to a number (for a spawn): ${xString}`);
+        }
+        const yString = jsonSpawn.$.y;
+        const y = tonumber(yString);
+        if (y === undefined) {
+            error(`Failed to convert the following y coordinate to a number (for a spawn): ${yString}`);
+        }
+        if (jsonSpawn.entity.length > 1) {
+            error("Stacked entities are not implemented for JSON rooms.");
+        }
+        const firstXMLEntity = jsonSpawn.entity[0];
+        if (firstXMLEntity === undefined) {
+            error('Failed to get the first JSON entity from an "entity" array.');
+        }
+        const entityTypeString = firstXMLEntity.$.type;
+        const entityType = tonumber(entityTypeString);
+        if (entityType === undefined) {
+            error(`Failed to convert the entity type to a number: ${entityTypeString}`);
+        }
+        const variantString = firstXMLEntity.$.variant;
+        const variant = tonumber(variantString);
+        if (variant === undefined) {
+            error(`Failed to convert the entity variant to a number: ${variant}`);
+        }
+        const subTypeString = firstXMLEntity.$.subtype;
+        const subType = tonumber(subTypeString);
+        if (subType === undefined) {
+            error(`Failed to convert the entity sub-type to a number: ${subType}`);
+        }
+        // Note that XML entity type 1000 is a rock, not an effect.
+        if (entityType >= 1000) {
+            if (verbose) {
+                const gridEntityID = getGridEntityIDFromConstituents(entityType, variant);
+                log(`Spawning grid entity ${gridEntityID} at: (${x}, ${y})`);
+            }
+            spawnGridEntityForJSONRoom(entityType, variant, x, y);
+        }
+        else {
+            if (verbose) {
+                const entityID = getEntityIDFromConstituents(entityType, variant, subType);
+                log(`Spawning normal entity ${entityID} at: (${x}, ${y})`);
+            }
+            const entity = spawnNormalEntityForJSONRoom(entityType, variant, subType, x, y, rng);
+            const npc = entity.ToNPC();
+            if (npc !== undefined && npc.CanShutDoors) {
+                shouldUnclearRoom = true;
+            }
+        }
+    }
+    // After emptying the room, we manually cleared the room. However, if the room layout contains an
+    // battle NPC, then we need to reset the clear state and close the doors again.
+    if (shouldUnclearRoom) {
+        if (verbose) {
+            log("Setting the room to be uncleared since there were one or more battle NPCs spawned.");
+        }
+        setRoomUncleared();
+    }
+    else if (verbose) {
+        log("Leaving the room cleared since there were no battle NPCs spawned.");
+    }
+}
+function spawnGridEntityForJSONRoom(gridEntityXMLType, gridEntityXMLVariant, x, y) {
+    const room = game.GetRoom();
+    const gridEntityTuple = convertXMLGridEntityType(gridEntityXMLType, gridEntityXMLVariant);
+    if (gridEntityTuple === undefined) {
+        return undefined;
+    }
+    const [gridEntityType, variant] = gridEntityTuple;
+    const position = gridCoordinatesToWorldPosition(x, y);
+    const gridIndex = room.GetGridIndex(position);
+    const gridEntity = spawnGridWithVariant(gridEntityType, variant, gridIndex);
+    if (gridEntity === undefined) {
+        return gridEntity;
+    }
+    // Prevent poops from playing an appear animation, since that is not supposed to normally happen
+    // when entering a new room.
+    if (gridEntityType === GridEntityType.POOP) {
+        const sprite = gridEntity.GetSprite();
+        sprite.Play("State1", true);
+        sprite.SetLastFrame();
+    }
+    return gridEntity;
+}
+function spawnNormalEntityForJSONRoom(entityType, variant, subType, x, y, rng) {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const position = gridCoordinatesToWorldPosition(x, y);
+    const seed = rng.Next();
+    let entity;
+    if (entityType === EntityType.PICKUP &&
+        variant === PickupVariant.COLLECTIBLE) {
+        const options = roomType === RoomType.ANGEL;
+        entity = spawnCollectible(subType, position, seed, options);
+    }
+    else {
+        entity = spawnWithSeed(entityType, variant, subType, position, seed);
+    }
+    // For some reason, Pitfalls do not spawn with the correct collision classes.
+    if (entityType === EntityType.PITFALL &&
+        variant === PitfallVariant.PITFALL) {
+        entity.EntityCollisionClass = EntityCollisionClass.ENEMIES;
+        entity.GridCollisionClass = EntityGridCollisionClass.WALLS;
+    }
+    storePersistentEntity(entity);
+    return entity;
+}
+/**
+ * Some entities must be manually respawned every time the player re-enters the room. If we just
+ * spawned one such entity, then record it for later.
+ */
+function storePersistentEntity(entity) {
+    if (!PERSISTENT_ENTITY_TYPES.has(entity.Type)) {
+        return;
+    }
+    const room = game.GetRoom();
+    const gridIndex = room.GetGridIndex(entity.Position);
+    const roomListIndex = getRoomListIndex();
+    const persistentEntity = {
+        gridIndex,
+        entityType: entity.Type,
+        variant: entity.Variant,
+        subType: entity.SubType,
+    };
+    const persistentEntities = v.level.roomToPersistentEntitiesMap.getAndSetDefault(roomListIndex);
+    persistentEntities.push(persistentEntity);
+}
+/**
+ * By default, when spawning multiple pits next to each other, the graphics will not "meld"
+ * together. Thus, now that all of the entities in the room are spawned, we must iterate over the
+ * pits in the room and manually fix their sprites, if necessary.
+ */
+function fixPitGraphics() {
+    const room = game.GetRoom();
+    const gridWidth = room.GetGridWidth();
+    const pitMap = getPitMap();
+    for (const [gridIndex, gridEntity] of pitMap.entries()) {
+        const gridIndexLeft = gridIndex - 1;
+        const L = pitMap.has(gridIndexLeft);
+        const gridIndexRight = gridIndex + 1;
+        const R = pitMap.has(gridIndexRight);
+        const gridIndexUp = gridIndex - gridWidth;
+        const U = pitMap.has(gridIndexUp);
+        const gridIndexDown = gridIndex + gridWidth;
+        const D = pitMap.has(gridIndexDown);
+        const gridIndexUpLeft = gridIndex - gridWidth - 1;
+        const UL = pitMap.has(gridIndexUpLeft);
+        const gridIndexUpRight = gridIndex - gridWidth + 1;
+        const UR = pitMap.has(gridIndexUpRight);
+        const gridIndexDownLeft = gridIndex + gridWidth - 1;
+        const DL = pitMap.has(gridIndexDownLeft);
+        const gridIndexDownRight = gridIndex + gridWidth + 1;
+        const DR = pitMap.has(gridIndexDownRight);
+        const pitFrame = getPitFrame(L, R, U, D, UL, UR, DL, DR);
+        const sprite = gridEntity.GetSprite();
+        sprite.SetFrame(pitFrame);
+    }
+}
+function getPitMap() {
+    const pitMap = new Map();
+    for (const gridEntity of getGridEntities(GridEntityType.PIT)) {
+        const gridIndex = gridEntity.GetGridIndex();
+        pitMap.set(gridIndex, gridEntity);
+    }
+    return pitMap;
+}
+/** The logic in this function is copied from Basement Renovator. */
+function getPitFrame(L, R, U, D, UL, UR, DL, DR) {
+    let F = 0;
+    // First, check for bitwise frames. (It works for all combinations of just left/up/right/down.)
+    if (L) {
+        F |= 1;
+    }
+    if (U) {
+        F |= 2;
+    }
+    if (R) {
+        F |= 4;
+    }
+    if (D) {
+        F |= 8;
+    }
+    // Then, check for other combinations.
+    if (U && L && !UL && !R && !D) {
+        F = 17;
+    }
+    if (U && R && !UR && !L && !D) {
+        F = 18;
+    }
+    if (L && D && !DL && !U && !R) {
+        F = 19;
+    }
+    if (R && D && !DR && !L && !U) {
+        F = 20;
+    }
+    if (L && U && R && D && !UL) {
+        F = 21;
+    }
+    if (L && U && R && D && !UR) {
+        F = 22;
+    }
+    if (U && R && D && !L && !UR) {
+        F = 25;
+    }
+    if (L && U && D && !R && !UL) {
+        F = 26;
+    }
+    if (L && U && R && D && !DL && !DR) {
+        F = 24;
+    }
+    if (L && U && R && D && !UR && !UL) {
+        F = 23;
+    }
+    if (L && U && R && UL && !UR && !D) {
+        F = 27;
+    }
+    if (L && U && R && UR && !UL && !D) {
+        F = 28;
+    }
+    if (L && U && R && !D && !UR && !UL) {
+        F = 29;
+    }
+    if (L && R && D && DL && !U && !DR) {
+        F = 30;
+    }
+    if (L && R && D && DR && !U && !DL) {
+        F = 31;
+    }
+    if (L && R && D && !U && !DL && !DR) {
+        F = 32;
+    }
+    return F;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployJSONRoom.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/features/deployJSONRoom.ts"],"names":[],"mappings":"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"}

package/features/disableAllSound.js

@@ -0,0 +1,63 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { musicManager } from "../cachedClasses";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { stopAllSoundEffects } from "../functions/sound";
+import { saveDataManager } from "./saveDataManager/exports";
+const FEATURE_NAME = "disableAllSound";
+let musicWasEnabled = false;
+const v = {
+    run: {
+        disableSoundSet: new Set(),
+    },
+};
+/** @internal */
+export function disableAllSoundInit(mod) {
+    saveDataManager(FEATURE_NAME, v);
+    mod.AddCallback(ModCallback.POST_RENDER, postRender);
+}
+// ModCallback.POST_RENDER (2)
+function postRender() {
+    if (v.run.disableSoundSet.size === 0) {
+        return;
+    }
+    stopAllSoundEffects();
+}
+/**
+ * Helper function to stop muting all sound effects and music.
+ *
+ * Use this function to set things back to normal after having used `disableAllSounds`.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function enableAllSound(key) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    if (!v.run.disableSoundSet.has(key)) {
+        return;
+    }
+    v.run.disableSoundSet.delete(key);
+    if (v.run.disableSoundSet.size === 0 && musicWasEnabled) {
+        musicManager.Enable();
+    }
+    // Stop all sound effects that were initialized prior to enabling sounds (in case there was a
+    // sound played played previously on this render frame).
+    stopAllSoundEffects();
+}
+/**
+ * Helper function to disable all sound effects and music (by constantly musting them).
+ *
+ * Use the `enableAllSounds` helper function to set things back to normal.
+ *
+ * @param key The name of the mod feature that is requesting the enable/disable. This is needed so
+ *            that multiple mod features can work in tandem.
+ */
+export function disableAllSound(key) {
+    errorIfFeaturesNotInitialized(FEATURE_NAME);
+    if (v.run.disableSoundSet.size === 0) {
+        musicWasEnabled = musicManager.IsEnabled();
+    }
+    v.run.disableSoundSet.add(key);
+    // Stop all sound effects that were initialized prior to disabling sounds.
+    stopAllSoundEffects();
+}
+//# sourceMappingURL=data:application/json;base64,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