isaacscript-common 84.0.0 → 84.1.0

package/dist/functions/positionVelocity.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setEntityVelocities = exports.setEntityPositions = exports.getEntityVelocities = exports.getEntityPositions = exports.findFreePosition = exports.anyPlayerCloserThan = exports.anyEntityCloserThan = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const constants_1 = require("../core/constants");
+const entities_1 = require("./entities");
+const entitiesSpecific_1 = require("./entitiesSpecific");
+const playerIndex_1 = require("./playerIndex");
+const players_1 = require("./players");
+const MAX_FIND_FREE_POSITION_ATTEMPTS = 100;
+function anyEntityCloserThan(entities, position, distance) {
+    return entities.some((entity) => position.Distance(entity.Position) <= distance);
+}
+exports.anyEntityCloserThan = anyEntityCloserThan;
+/**
+ * Iterates over all players and checks if any player is close enough to the specified position.
+ *
+ * Note that this function does not consider players with a non-undefined parent, since they are not
+ * real players (e.g. the Strawman Keeper).
+ */
+function anyPlayerCloserThan(position, distance) {
+    const players = (0, playerIndex_1.getPlayers)();
+    return players.some((player) => player.Position.Distance(position) <= distance);
+}
+exports.anyPlayerCloserThan = anyPlayerCloserThan;
+/**
+ * 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.
+ * @param minimumDistance Optional. If specified, will ensure that the randomly generated position
+ *                        is equal to or greater than the distance provided.
+ */
+function findFreePosition(startingPosition, avoidActiveEntities = false, minimumDistance) {
+    const room = cachedClasses_1.game.GetRoom();
+    const heavenDoors = (0, entitiesSpecific_1.getEffects)(isaac_typescript_definitions_1.EffectVariant.HEAVEN_LIGHT_DOOR, isaac_typescript_definitions_1.HeavenLightDoorSubType.HEAVEN_DOOR);
+    for (let initialStep = 0; initialStep < MAX_FIND_FREE_POSITION_ATTEMPTS; initialStep++) {
+        const position = room.FindFreePickupSpawnPosition(startingPosition, initialStep, avoidActiveEntities);
+        const closePlayer = (0, players_1.getPlayerCloserThan)(position, constants_1.DISTANCE_OF_GRID_TILE);
+        if (closePlayer !== undefined) {
+            continue;
+        }
+        const isCloseHeavenDoor = anyEntityCloserThan(heavenDoors, position, constants_1.DISTANCE_OF_GRID_TILE);
+        if (isCloseHeavenDoor) {
+            continue;
+        }
+        if (minimumDistance !== undefined) {
+            const distance = startingPosition.Distance(position);
+            if (distance < minimumDistance) {
+                continue;
+            }
+        }
+        return position;
+    }
+    // We failed to find a free position in N iterations.
+    return room.FindFreePickupSpawnPosition(startingPosition);
+}
+exports.findFreePosition = findFreePosition;
+/**
+ * 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.
+ */
+function getEntityPositions(entities) {
+    if (entities === undefined) {
+        entities = (0, entities_1.getEntities)();
+    }
+    const entityPositions = new Map();
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        entityPositions.set(ptrHash, entity.Position);
+    }
+    return entityPositions;
+}
+exports.getEntityPositions = getEntityPositions;
+/**
+ * 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.
+ */
+function getEntityVelocities(entities) {
+    if (entities === undefined) {
+        entities = (0, entities_1.getEntities)();
+    }
+    const entityVelocities = new Map();
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        entityVelocities.set(ptrHash, entity.Velocity);
+    }
+    return entityVelocities;
+}
+exports.getEntityVelocities = getEntityVelocities;
+/**
+ * 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.
+ */
+function setEntityPositions(entityPositions, entities) {
+    if (entities === undefined) {
+        entities = (0, entities_1.getEntities)();
+    }
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        const entityPosition = entityPositions.get(ptrHash);
+        if (entityPosition !== undefined) {
+            entity.Position = entityPosition;
+        }
+    }
+}
+exports.setEntityPositions = setEntityPositions;
+/**
+ * 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.
+ */
+function setEntityVelocities(entityVelocities, entities) {
+    if (entities === undefined) {
+        entities = (0, entities_1.getEntities)();
+    }
+    for (const entity of entities) {
+        const ptrHash = GetPtrHash(entity);
+        const entityVelocity = entityVelocities.get(ptrHash);
+        if (entityVelocity !== undefined) {
+            entity.Velocity = entityVelocity;
+        }
+    }
+}
+exports.setEntityVelocities = setEntityVelocities;

package/dist/functions/pressurePlate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllPressurePlatesPushed = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const gridEntitiesSpecific_1 = require("./gridEntitiesSpecific");
+/**
+ * Helper function to check if all of the pressure plates in the room are pushed.
+ *
+ * In this context, "pressure plates" refers to the grid entities that you have to press down in
+ * order for the room to be cleared. This function ignores other types of pressure plates, such as
+ * the ones that you press to get a reward, the ones that you press to start a Greed Mode wave, and
+ * so on.
+ *
+ * Returns true if there are no pressure plates in the room.
+ */
+function isAllPressurePlatesPushed() {
+    const room = cachedClasses_1.game.GetRoom();
+    const hasPressurePlates = room.HasTriggerPressurePlates();
+    if (!hasPressurePlates) {
+        return true;
+    }
+    const pressurePlates = (0, gridEntitiesSpecific_1.getPressurePlates)(isaac_typescript_definitions_1.PressurePlateVariant.PRESSURE_PLATE);
+    return pressurePlates.every((pressurePlate) => pressurePlate.State === isaac_typescript_definitions_1.PressurePlateState.PRESSURE_PLATE_PRESSED);
+}
+exports.isAllPressurePlatesPushed = isAllPressurePlatesPushed;

package/dist/functions/projectiles.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fireProjectilesInCircle = exports.fireProjectiles = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const entities_1 = require("./entities");
+const entitiesSpecific_1 = require("./entitiesSpecific");
+/**
+ * Helper function to make an NPC fire one or more projectiles. Returns the fired projectile(s).
+ *
+ * Use this function instead of the `EntityNPC.FireProjectiles` method if you need to modify or
+ * access the `EntityProjectile` objects after they are fired, since this function returns the
+ * objects in an array.
+ *
+ * @param npc The NPC to fire the projectile(s) from. You can also pass undefined if you do not want
+ *            the projectile(s) to come from anything in particular.
+ * @param position The staring position of the projectile(s).
+ * @param velocity The starting velocity of the projectile(s).
+ * @param projectilesMode Optional. The mode of the projectile(s). Default is
+ *                        `ProjectilesMode.ONE_PROJECTILE`.
+ * @param projectileParams Optional. The parameters of the projectile(s). Default is
+ *                         `ProjectileParams()`.
+ * @returns The fired projectile(s).
+ */
+function fireProjectiles(npc, position, velocity, projectilesMode = isaac_typescript_definitions_1.ProjectilesMode.ONE_PROJECTILE, projectileParams = ProjectileParams()) {
+    const oldProjectiles = (0, entitiesSpecific_1.getProjectiles)(projectileParams.Variant);
+    let spawnedFly = false;
+    if (npc === undefined) {
+        // Since the `EntityNPC.FireProjectiles` method is not static, we arbitrarily spawn a fly.
+        spawnedFly = true;
+        npc = (0, entitiesSpecific_1.spawnNPC)(isaac_typescript_definitions_1.EntityType.FLY, 0, 0, position);
+        npc.Visible = false;
+        npc.ClearEntityFlags(isaac_typescript_definitions_1.EntityFlag.APPEAR);
+    }
+    npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
+    const newProjectiles = (0, entitiesSpecific_1.getProjectiles)(projectileParams.Variant);
+    if (spawnedFly) {
+        npc.Remove();
+    }
+    return (0, entities_1.getFilteredNewEntities)(oldProjectiles, newProjectiles);
+}
+exports.fireProjectiles = fireProjectiles;
+/**
+ * Helper function to spawn projectiles in a circle around a position. Under the hood, this
+ * leverages `ProjectileMode.N_PROJECTILES_IN_CIRCLE`.
+ *
+ * @param npc The NPC to fire the projectile(s) from. You can also pass undefined if you do not want
+ *            the projectile(s) to come from anything in particular.
+ * @param position The staring position of the projectile(s).
+ * @param speed The speed of the projectile(s).
+ * @param numProjectiles The amount of projectiles to spawn.
+ * @returns The fired projectile(s).
+ */
+function fireProjectilesInCircle(npc, position, speed, numProjectiles) {
+    const velocity = Vector(speed, numProjectiles);
+    return fireProjectiles(npc, position, velocity, isaac_typescript_definitions_1.ProjectilesMode.N_PROJECTILES_IN_CIRCLE);
+}
+exports.fireProjectilesInCircle = fireProjectilesInCircle;

package/dist/functions/random.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomInt = exports.getRandomFloat = exports.getRandom = void 0;
+const ReadonlySet_1 = require("../types/ReadonlySet");
+const rng_1 = require("./rng");
+/**
+ * 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.)
+ *
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
+ */
+function getRandom(seedOrRNG) {
+    const rng = (0, rng_1.isRNG)(seedOrRNG) ? seedOrRNG : (0, rng_1.newRNG)(seedOrRNG);
+    return rng.RandomFloat();
+}
+exports.getRandom = getRandom;
+/**
+ * Returns a random float between min and max.
+ *
+ * For example:
+ *
+ * ```ts
+ * const realNumberBetweenOneAndThree = getRandomFloat(1, 3, undefined);
+ * ```
+ *
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param min The lower bound for the random number (inclusive).
+ * @param max The upper bound for the random number (exclusive).
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
+ */
+function getRandomFloat(min, max, seedOrRNG) {
+    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);
+}
+exports.getRandomFloat = getRandomFloat;
+/**
+ * Returns a random integer between min and max. It is inclusive on both ends.
+ *
+ * For example:
+ *
+ * ```ts
+ * const oneTwoOrThree = getRandomInt(1, 3);
+ * ```
+ *
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param min The lower bound for the random number (inclusive).
+ * @param max The upper bound for the random number (inclusive).
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
+ * @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.
+ */
+function getRandomInt(min, max, seedOrRNG, exceptions = []) {
+    const rng = (0, rng_1.isRNG)(seedOrRNG) ? seedOrRNG : (0, rng_1.newRNG)(seedOrRNG);
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    if (min > max) {
+        const oldMin = min;
+        const oldMax = max;
+        min = oldMax;
+        max = oldMin;
+    }
+    const exceptionsSet = new ReadonlySet_1.ReadonlySet(exceptions);
+    let randomInt;
+    do {
+        randomInt = rng.RandomInt(max - min + 1) + min;
+    } while (exceptionsSet.has(randomInt));
+    return randomInt;
+}
+exports.getRandomInt = getRandomInt;

package/dist/functions/readOnly.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newReadonlyVector = exports.newReadonlyKColor = exports.newReadonlyColor = void 0;
+/**
+ * Helper function to create a read-only `Color` object. (Otherwise, you would have to manually
+ * specify both the type and the constructor.)
+ *
+ * Note that read-only colors will be writable at run-time.
+ */
+function newReadonlyColor(r, g, b, a, ro, go, bo) {
+    return Color(r, g, b, a, ro, go, bo);
+}
+exports.newReadonlyColor = newReadonlyColor;
+/**
+ * Helper function to create a read-only `KColor` object. (Otherwise, you would have to manually
+ * specify both the type and the constructor.)
+ *
+ * Note that read-only colors will be writable at run-time.
+ */
+function newReadonlyKColor(r, g, b, a) {
+    return KColor(r, g, b, a);
+}
+exports.newReadonlyKColor = newReadonlyKColor;
+/**
+ * Helper function to create a read-only `Vector` object. (Otherwise, you would have to manually
+ * specify both the type and the constructor.)
+ *
+ * Note that read-only vectors will be writable at run-time.
+ */
+function newReadonlyVector(x, y) {
+    return Vector(x, y);
+}
+exports.newReadonlyVector = newReadonlyVector;

package/dist/functions/render.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTextOnEntity = exports.renderScaledTextOnEntity = exports.isReflectionRender = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+/**
+ * Helper function to see if the current render callback is rendering a water reflection.
+ *
+ * When the player is in a room with water, things will be rendered twice: once for the normal
+ * rendering, and once for the reflecting rendering. Thus, any mod code in a render callback will
+ * run twice per frame in these situations, which may be unexpected or cause bugs.
+ *
+ * This function is typically used to early return from a render function if it returns true.
+ */
+function isReflectionRender() {
+    const room = cachedClasses_1.game.GetRoom();
+    const renderMode = room.GetRenderMode();
+    return renderMode === isaac_typescript_definitions_1.RenderMode.WATER_REFLECT;
+}
+exports.isReflectionRender = isReflectionRender;
+function renderScaledTextOnEntity(entity, text, scaleX, scaleY) {
+    if (isReflectionRender()) {
+        return;
+    }
+    const position = Isaac.WorldToScreen(entity.Position);
+    Isaac.RenderScaledText(text, position.X, position.Y, scaleX, scaleY, 1, 1, 1, 1);
+}
+exports.renderScaledTextOnEntity = renderScaledTextOnEntity;
+function renderTextOnEntity(entity, text) {
+    if (isReflectionRender()) {
+        return;
+    }
+    const position = Isaac.WorldToScreen(entity.Position);
+    Isaac.RenderText(text, position.X, position.Y, 1, 1, 1, 1);
+}
+exports.renderTextOnEntity = renderTextOnEntity;

package/dist/functions/revive.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.willReviveFromSpiritShackles = exports.willReviveFromHeartbreak = exports.willPlayerRevive = exports.willMysteriousPaperRevive = exports.isDamageToPlayerFatal = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const constants_1 = require("../core/constants");
+const MysteriousPaperEffect_1 = require("../enums/MysteriousPaperEffect");
+const characters_1 = require("./characters");
+const frames_1 = require("./frames");
+const playerHealth_1 = require("./playerHealth");
+const players_1 = require("./players");
+const sprites_1 = require("./sprites");
+const trinketGive_1 = require("./trinketGive");
+const trinkets_1 = require("./trinkets");
+/**
+ * Uses the player's current health and other miscellaneous things to determine if incoming damage
+ * will be fatal.
+ */
+function isDamageToPlayerFatal(player, amount, source, lastDamageGameFrame) {
+    const character = player.GetPlayerType();
+    const effects = player.GetEffects();
+    const isBerserk = effects.HasCollectibleEffect(isaac_typescript_definitions_1.CollectibleType.BERSERK);
+    // If we are Tainted Jacob and the damage source is Dark Esau, this will not be fatal damage
+    // (because we will transform into Tainted Jacob's lost form).
+    if (character === isaac_typescript_definitions_1.PlayerType.JACOB_B &&
+        source.Type === isaac_typescript_definitions_1.EntityType.DARK_ESAU) {
+        return false;
+    }
+    // If we are berserk, no damage is fatal. (The death is deferred until the end of the berserk
+    // effect.)
+    if (isBerserk) {
+        return false;
+    }
+    // If we are playing Tainted Samson and the incoming hit will cause us to become Berserk, then
+    // this will not be fatal damage.
+    const berserkChargeAfterHit = player.SamsonBerserkCharge +
+        constants_1.TAINTED_SAMSON_BERSERK_CHARGE_FROM_TAKING_DAMAGE;
+    if (character === isaac_typescript_definitions_1.PlayerType.SAMSON_B &&
+        berserkChargeAfterHit >= constants_1.MAX_TAINTED_SAMSON_BERSERK_CHARGE) {
+        return false;
+    }
+    // If Spirit Shackles is activated, no damage is fatal.
+    if (willReviveFromSpiritShackles(player)) {
+        return false;
+    }
+    // If we are Tainted Jacob in the Lost Form, we may have plenty of health left, but we will still
+    // die in one hit to anything.
+    if (character === isaac_typescript_definitions_1.PlayerType.JACOB_2_B) {
+        return true;
+    }
+    // If we are in the "Lost Curse" form from touching a white fire, all damage will be fatal.
+    if ((0, players_1.hasLostCurse)(player)) {
+        return true;
+    }
+    const playerNumAllHearts = (0, players_1.getPlayerNumHitsRemaining)(player);
+    if (amount < playerNumAllHearts) {
+        return false;
+    }
+    // This will not be fatal damage if the player has Heartbreak and two slots open for broken
+    // hearts.
+    if (willReviveFromHeartbreak(player)) {
+        return false;
+    }
+    // This will not be fatal damage if we have Glass Cannon and this is the second time we are taking
+    // damage on the same frame.
+    if (player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.BROKEN_GLASS_CANNON) &&
+        (0, frames_1.onGameFrame)(lastDamageGameFrame)) {
+        return false;
+    }
+    // This will not be fatal damage if we have two different kinds of hearts. For example, a bomb
+    // explosion deals 2 damage, but if the player has one half soul heart and one half red heart, the
+    // game will only remove the soul heart.
+    const hearts = player.GetHearts();
+    const eternalHearts = player.GetEternalHearts();
+    const soulHearts = player.GetSoulHearts();
+    const boneHearts = player.GetBoneHearts();
+    if ((hearts > 0 && soulHearts > 0) ||
+        (hearts > 0 && boneHearts > 0) ||
+        (soulHearts > 0 && boneHearts > 0) ||
+        (soulHearts > 0 && eternalHearts > 0) ||
+        boneHearts >= 2 // Two bone hearts and nothing else should not result in a death
+    ) {
+        return false;
+    }
+    return true;
+}
+exports.isDamageToPlayerFatal = isDamageToPlayerFatal;
+/**
+ * Assuming that we are on the frame of fatal damage, this function returns whether Mysterious Paper
+ * would rotate to Missing Poster on the frame that the "Game Over" screen would appear (which would
+ * subsequently save the player from fatal damage).
+ *
+ * Mysterious Paper rotates between the 4 items on every frame, in order. The formula for whether
+ * Mysterious Paper be Missing Power is: `gameFrameCount % 4 === 3`
+ */
+function willMysteriousPaperRevive(player) {
+    const sprite = player.GetSprite();
+    // We want to explicitly check the length of the death animation because we might be playing on a
+    // modded character that has a custom death animation.
+    const character = player.GetPlayerType();
+    const animation = (0, characters_1.getCharacterDeathAnimationName)(character);
+    const deathAnimationFrames = (0, sprites_1.getLastFrameOfAnimation)(sprite, animation);
+    const frameOfDeath = player.FrameCount + deathAnimationFrames;
+    const mysteriousPaperEffect = (0, trinkets_1.getMysteriousPaperEffectForFrame)(player, frameOfDeath);
+    if (mysteriousPaperEffect === undefined) {
+        return false;
+    }
+    return mysteriousPaperEffect === MysteriousPaperEffect_1.MysteriousPaperEffect.MISSING_POSTER;
+}
+exports.willMysteriousPaperRevive = willMysteriousPaperRevive;
+/**
+ * The `EntityPlayer.WillPlayerRevive` method does not properly account for Mysterious Paper, so use
+ * this helper function instead for more robust revival detection.
+ */
+function willPlayerRevive(player) {
+    const trinketSituation = (0, trinketGive_1.temporarilyRemoveTrinket)(player, isaac_typescript_definitions_1.TrinketType.MYSTERIOUS_PAPER);
+    const willRevive = player.WillPlayerRevive() ||
+        (trinketSituation !== undefined && willMysteriousPaperRevive(player));
+    (0, trinketGive_1.giveTrinketsBack)(player, trinketSituation);
+    return willRevive;
+}
+exports.willPlayerRevive = willPlayerRevive;
+/**
+ * Helper function to determine if the player will be revived by the Heartbreak collectible if they
+ * take fatal damage. This is contingent on the character that they are playing as and the amount of
+ * broken hearts that they already have.
+ */
+function willReviveFromHeartbreak(player) {
+    if (!player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.HEARTBREAK)) {
+        return false;
+    }
+    const maxHeartContainers = (0, playerHealth_1.getPlayerMaxHeartContainers)(player);
+    const numBrokenHeartsThatWillBeAdded = (0, players_1.isKeeper)(player) ? 1 : 2;
+    const brokenHearts = player.GetBrokenHearts();
+    const numBrokenHeartsAfterRevival = numBrokenHeartsThatWillBeAdded + brokenHearts;
+    return maxHeartContainers > numBrokenHeartsAfterRevival;
+}
+exports.willReviveFromHeartbreak = willReviveFromHeartbreak;
+/**
+ * Helper function to determine if the Spirit Shackles item is in an enabled state. (It can be
+ * either enabled or disabled.)
+ */
+function willReviveFromSpiritShackles(player) {
+    if (!player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.SPIRIT_SHACKLES)) {
+        return false;
+    }
+    const effects = player.GetEffects();
+    const spiritShacklesEnabled = !effects.HasNullEffect(isaac_typescript_definitions_1.NullItemID.SPIRIT_SHACKLES_DISABLED);
+    const playerInSoulForm = effects.HasNullEffect(isaac_typescript_definitions_1.NullItemID.SPIRIT_SHACKLES_SOUL);
+    return spiritShacklesEnabled && !playerInSoulForm;
+}
+exports.willReviveFromSpiritShackles = willReviveFromSpiritShackles;