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

package/functions/playerCenter.js

@@ -0,0 +1,50 @@
+import { Direction } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { NEW_FLOOR_STARTING_POSITION_GREED_MODE, NEW_FLOOR_STARTING_POSITION_NORMAL_MODE, } from "../constants";
+import { getPlayerFamiliars } from "./familiars";
+import { getCircleDiscretizedPoints } from "./math";
+import { getPlayers } from "./playerIndex";
+const CIRCLE_RADIUS_BETWEEN_PLAYERS = 50;
+/**
+ * Helper function to move all of the players to where they would normally go when arriving at a new
+ * floor. (In normal mode, this is the center of the room. In Greed Mode, this is below the top
+ * door.)
+ *
+ * If there is more than one player, they will be distributed around the center in a circle.
+ *
+ * This function emulates what happens in the vanilla game when you travel to a new floor.
+ */
+export function movePlayersToCenter() {
+    const isGreedMode = game.IsGreedMode();
+    const startingPosition = isGreedMode
+        ? NEW_FLOOR_STARTING_POSITION_GREED_MODE
+        : NEW_FLOOR_STARTING_POSITION_NORMAL_MODE;
+    const players = getPlayers();
+    const firstPlayer = players[0];
+    if (firstPlayer === undefined) {
+        return;
+    }
+    // If there is only one player, we can move them exactly to the center of the room.
+    if (players.length === 1) {
+        movePlayerAndTheirFamiliars(firstPlayer, startingPosition);
+        return;
+    }
+    // If there is more than one player, spread them out in a circle around the center of the room.
+    // (This is what happens in vanilla.)
+    const circlePoints = getCircleDiscretizedPoints(startingPosition, CIRCLE_RADIUS_BETWEEN_PLAYERS, players.length, 1, 1, Direction.LEFT);
+    for (let i = 0; i < players.length; i++) {
+        const player = players[i];
+        const circlePosition = circlePoints[i];
+        if (player !== undefined && circlePosition !== undefined) {
+            player.Position = circlePosition;
+        }
+    }
+}
+function movePlayerAndTheirFamiliars(player, position) {
+    player.Position = position;
+    const familiars = getPlayerFamiliars(player);
+    for (const familiar of familiars) {
+        familiar.Position = position;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/playerDataStructures.js

@@ -0,0 +1,114 @@
+import { getPlayerIndex } from "./playerIndex";
+/**
+ * Helper function to make using default maps with an index of `PlayerIndex` easier. Use this
+ * instead of the `DefaultMap.getAndSetDefault` method if you have a default map of this type.
+ *
+ * For example:
+ *
+ * ```ts
+ * const v = {
+ *   run: {
+ *     playersSpeedBoost: new DefaultMap<PlayerIndex, int>(0),
+ *   },
+ * };
+ *
+ * function evaluateCacheSpeed(player: EntityPlayer) {
+ *   player.MoveSpeed = defaultMapGetPlayer(v.run.playersSpeedBoost, player);
+ * }
+ * ```
+ */
+export function defaultMapGetPlayer(map, player, ...extraArgs) {
+    const playerIndex = getPlayerIndex(player);
+    return map.getAndSetDefault(playerIndex, ...extraArgs);
+}
+/**
+ * Helper function to make using maps with an index of `PlayerIndex` easier. Use this instead of the
+ * `Map.set` method if you have a map of this type.
+ *
+ * Since `Map` and `DefaultMap` set values in the same way, this function is simply an alias for the
+ * `mapSetPlayer` helper function.
+ */
+export function defaultMapSetPlayer(map, player, value) {
+    mapSetPlayer(map, player, value);
+}
+/**
+ * Helper function to make using maps with an index of `PlayerIndex` easier. Use this instead of the
+ * `Map.get` method if you have a map of this type.
+ *
+ * For example:
+ *
+ * ```ts
+ * const v = {
+ *   run: {
+ *     playersSpeedBoost: new Map<PlayerIndex, int>(),
+ *   },
+ * };
+ *
+ * function incrementSpeedBoost(player: EntityPlayer) {
+ *   const oldSpeedBoost = mapGetPlayer(v.run.playersSpeedBoost, player);
+ *   const newSpeedBoost = oldSpeedBoost + 0.1;
+ *   mapSetPlayer(v.run.playersSpeedBoost, player);
+ * }
+ * ```
+ */
+export function mapGetPlayer(map, player) {
+    const playerIndex = getPlayerIndex(player);
+    return map.get(playerIndex);
+}
+/**
+ * Helper function to make using maps with an index of `PlayerIndex` easier. Use this instead of the
+ * `Map.has` method if you have a map of this type.
+ */
+export function mapHasPlayer(map, player) {
+    const playerIndex = getPlayerIndex(player);
+    return map.has(playerIndex);
+}
+/**
+ * Helper function to make using maps with an index of `PlayerIndex` easier. Use this instead of the
+ * `Map.set` method if you have a map of this type.
+ *
+ * For example:
+ *
+ * ```ts
+ * const v = {
+ *   run: {
+ *     playersSpeedBoost: new Map<PlayerIndex, int>(),
+ *   },
+ * };
+ *
+ * function incrementSpeedBoost(player: EntityPlayer) {
+ *   const oldSpeedBoost = mapGetPlayer(v.run.playersSpeedBoost, player);
+ *   const newSpeedBoost = oldSpeedBoost + 0.1;
+ *   mapSetPlayer(v.run.playersSpeedBoost, player);
+ * }
+ * ```
+ */
+export function mapSetPlayer(map, player, value) {
+    const playerIndex = getPlayerIndex(player);
+    map.set(playerIndex, value);
+}
+/**
+ * Helper function to make using sets with an type of `PlayerIndex` easier. Use this instead of the
+ * `Set.add` method if you have a set of this type.
+ */
+export function setAddPlayer(set, player) {
+    const playerIndex = getPlayerIndex(player);
+    return set.add(playerIndex);
+}
+/**
+ * Helper function to make using sets with an type of `PlayerIndex` easier. Use this instead of the
+ * `Set.delete` method if you have a set of this type.
+ */
+export function setDeletePlayer(set, player) {
+    const playerIndex = getPlayerIndex(player);
+    return set.delete(playerIndex);
+}
+/**
+ * Helper function to make using sets with an type of `PlayerIndex` easier. Use this instead of the
+ * `Set.has` method if you have a set of this type.
+ */
+export function setHasPlayer(set, player) {
+    const playerIndex = getPlayerIndex(player);
+    return set.has(playerIndex);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/playerHealth.js

@@ -0,0 +1,321 @@
+import { ActiveSlot, CollectibleType, HeartSubType, PlayerType, } from "isaac-typescript-definitions";
+import { MAX_PLAYER_HEART_CONTAINERS } from "../constants";
+import { HealthType } from "../enums/HealthType";
+import { getTotalCharge } from "./charge";
+import { getEnumValues } from "./enums";
+import { getPlayerBlackHearts, getPlayerHearts, getPlayerSoulHearts, isCharacter, setActiveItem, } from "./player";
+export function addPlayerHealthType(player, healthType, numHearts) {
+    switch (healthType) {
+        case HealthType.RED: {
+            player.AddHearts(numHearts);
+            break;
+        }
+        case HealthType.SOUL: {
+            player.AddSoulHearts(numHearts);
+            break;
+        }
+        case HealthType.ETERNAL: {
+            player.AddEternalHearts(numHearts);
+            break;
+        }
+        case HealthType.BLACK: {
+            player.AddBlackHearts(numHearts);
+            break;
+        }
+        case HealthType.GOLDEN: {
+            player.AddGoldenHearts(numHearts);
+            break;
+        }
+        case HealthType.BONE: {
+            player.AddBoneHearts(numHearts);
+            break;
+        }
+        case HealthType.ROTTEN: {
+            player.AddRottenHearts(numHearts);
+            break;
+        }
+        case HealthType.BROKEN: {
+            player.AddBrokenHearts(numHearts);
+            break;
+        }
+        case HealthType.MAX_HEARTS: {
+            player.AddMaxHearts(numHearts, false);
+            break;
+        }
+    }
+}
+/**
+ * Helper function to get an object representing the player's health. You can use this in
+ * combination with the `setPlayerHealth` function to restore the player's health back to a certain
+ * configuration at a later time.
+ *
+ * This is based on the `REVEL.StoreHealth` function in the Revelations mod.
+ */
+export function getPlayerHealth(player) {
+    const character = player.GetPlayerType();
+    const soulHeartTypes = [];
+    let maxHearts = player.GetMaxHearts();
+    let hearts = getPlayerHearts(player); // We use the helper function to remove rotten hearts
+    let soulHearts = player.GetSoulHearts();
+    let boneHearts = player.GetBoneHearts();
+    const goldenHearts = player.GetGoldenHearts();
+    const eternalHearts = player.GetEternalHearts();
+    const rottenHearts = player.GetRottenHearts();
+    const brokenHearts = player.GetBrokenHearts();
+    const subPlayer = player.GetSubPlayer();
+    const soulCharges = player.GetEffectiveSoulCharge();
+    const bloodCharges = player.GetEffectiveBloodCharge();
+    // The Forgotten and The Soul has special health, so we need to account for this.
+    if (character === PlayerType.THE_FORGOTTEN && subPlayer !== undefined) {
+        // The Forgotten does not have red heart containers.
+        maxHearts = boneHearts * 2;
+        boneHearts = 0;
+        // The Forgotten will always have 0 soul hearts; we need to get the soul heart amount from the
+        // sub player.
+        soulHearts = subPlayer.GetSoulHearts();
+    }
+    else if (character === PlayerType.THE_SOUL && subPlayer !== undefined) {
+        // The Soul will always have 0 bone hearts; we need to get the bone heart amount from the sub
+        // player. We need to store it as "maxHearts" instead of "boneHearts".
+        maxHearts = subPlayer.GetBoneHearts() * 2;
+        hearts = subPlayer.GetHearts();
+    }
+    // This is the number of individual hearts shown in the HUD, minus heart containers.
+    const extraHearts = math.ceil(soulHearts / 2) + boneHearts;
+    // Since bone hearts can be inserted anywhere between soul hearts, we need a separate counter to
+    // track which soul heart we're currently at.
+    let currentSoulHeart = 0;
+    for (let i = 0; i < extraHearts; i++) {
+        let isBoneHeart = player.IsBoneHeart(i);
+        if (character === PlayerType.THE_FORGOTTEN && subPlayer !== undefined) {
+            isBoneHeart = subPlayer.IsBoneHeart(i);
+        }
+        if (isBoneHeart) {
+            soulHeartTypes.push(HeartSubType.BONE);
+        }
+        else {
+            // We need to add 1 here because only the second half of a black heart is considered black.
+            let isBlackHeart = player.IsBlackHeart(currentSoulHeart + 1);
+            if (character === PlayerType.THE_FORGOTTEN && subPlayer !== undefined) {
+                isBlackHeart = subPlayer.IsBlackHeart(currentSoulHeart + 1);
+            }
+            if (isBlackHeart) {
+                soulHeartTypes.push(HeartSubType.BLACK);
+            }
+            else {
+                soulHeartTypes.push(HeartSubType.SOUL);
+            }
+            // Move to the next heart.
+            currentSoulHeart += 2;
+        }
+    }
+    return {
+        maxHearts,
+        hearts,
+        eternalHearts,
+        soulHearts,
+        boneHearts,
+        goldenHearts,
+        rottenHearts,
+        brokenHearts,
+        soulCharges,
+        bloodCharges,
+        soulHeartTypes,
+    };
+}
+export function getPlayerHealthType(player, healthType) {
+    switch (healthType) {
+        // 5.10.1
+        case HealthType.RED: {
+            // We use the standard library helper function since the `EntityPlayer.GetHearts` method
+            // returns a value that includes rotten hearts.
+            return getPlayerHearts(player);
+        }
+        // 5.10.3
+        case HealthType.SOUL: {
+            // We use the standard library helper function since the `EntityPlayer.GetSoulHearts` method
+            // returns a value that includes black hearts.
+            return getPlayerSoulHearts(player);
+        }
+        // 5.10.4
+        case HealthType.ETERNAL: {
+            return player.GetEternalHearts();
+        }
+        // 5.10.6
+        case HealthType.BLACK: {
+            // We use the standard library helper function since the `EntityPlayer.GetBlackHearts` method
+            // returns a bit mask.
+            return getPlayerBlackHearts(player);
+        }
+        // 5.10.7
+        case HealthType.GOLDEN: {
+            return player.GetGoldenHearts();
+        }
+        // 5.10.11
+        case HealthType.BONE: {
+            return player.GetBoneHearts();
+        }
+        // 5.10.12
+        case HealthType.ROTTEN: {
+            return player.GetRottenHearts();
+        }
+        case HealthType.BROKEN: {
+            return player.GetBrokenHearts();
+        }
+        case HealthType.MAX_HEARTS: {
+            return player.GetMaxHearts();
+        }
+    }
+}
+/** Returns a `PlayerHealth` object with all 0s. */
+export function newPlayerHealth() {
+    return {
+        maxHearts: 0,
+        hearts: 0,
+        eternalHearts: 0,
+        soulHearts: 0,
+        boneHearts: 0,
+        goldenHearts: 0,
+        rottenHearts: 0,
+        brokenHearts: 0,
+        soulCharges: 0,
+        bloodCharges: 0,
+        soulHeartTypes: [],
+    };
+}
+export function playerConvertBlackHeartsToSoulHearts(player) {
+    const playerHealth = getPlayerHealth(player);
+    removeAllPlayerHealth(player);
+    playerHealth.soulHeartTypes = playerHealth.soulHeartTypes.map((soulHeartType) => soulHeartType === HeartSubType.BLACK ? HeartSubType.SOUL : soulHeartType);
+    setPlayerHealth(player, playerHealth);
+}
+export function playerConvertSoulHeartsToBlackHearts(player) {
+    const playerHealth = getPlayerHealth(player);
+    removeAllPlayerHealth(player);
+    playerHealth.soulHeartTypes = playerHealth.soulHeartTypes.map((soulHeartType) => soulHeartType === HeartSubType.SOUL ? HeartSubType.BLACK : soulHeartType);
+    setPlayerHealth(player, playerHealth);
+}
+/**
+ * Helper function to see if the player is out of health.
+ *
+ * Specifically, this function will return false if the player has 0 red hearts, 0 soul/black
+ * hearts, and 0 bone hearts.
+ */
+export function playerHasHealthLeft(player) {
+    const hearts = player.GetHearts();
+    const soulHearts = player.GetSoulHearts();
+    const boneHearts = player.GetBoneHearts();
+    return hearts > 0 || soulHearts > 0 || boneHearts > 0;
+}
+export function removeAllPlayerHealth(player) {
+    const goldenHearts = player.GetGoldenHearts();
+    const eternalHearts = player.GetEternalHearts();
+    const boneHearts = player.GetBoneHearts();
+    const brokenHearts = player.GetBrokenHearts();
+    // To avoid bugs, we have to remove the exact amount of certain types of hearts. We remove Golden
+    // Hearts first so that they don't break.
+    player.AddGoldenHearts(goldenHearts * -1);
+    player.AddEternalHearts(eternalHearts * -1);
+    player.AddBoneHearts(boneHearts * -1);
+    player.AddBrokenHearts(brokenHearts * -1);
+    player.AddMaxHearts(MAX_PLAYER_HEART_CONTAINERS * -2, true);
+    player.AddSoulHearts(MAX_PLAYER_HEART_CONTAINERS * -2);
+    // If we are The Soul, the `EntityPlayer.AddBoneHearts` method will not remove Forgotten's bone
+    // hearts, so we need to explicitly handle this.
+    if (isCharacter(player, PlayerType.THE_SOUL)) {
+        const forgotten = player.GetSubPlayer();
+        if (forgotten !== undefined) {
+            const forgottenBoneHearts = forgotten.GetBoneHearts();
+            forgotten.AddBoneHearts(forgottenBoneHearts * -1);
+        }
+    }
+}
+/**
+ * Helper function to set a player's health to a specific state. You can use this in combination
+ * with the `getPlayerHealth` function to restore the player's health back to a certain
+ * configuration at a later time.
+ *
+ * Based on the `REVEL.LoadHealth` function in the Revelations mod.
+ */
+export function setPlayerHealth(player, playerHealth) {
+    const character = player.GetPlayerType();
+    const subPlayer = player.GetSubPlayer();
+    removeAllPlayerHealth(player);
+    // Before we add any health, we have to take away Alabaster Box, if present.
+    const alabasterBoxes = [];
+    if (player.HasCollectible(CollectibleType.ALABASTER_BOX)) {
+        for (const activeSlot of getEnumValues(ActiveSlot)) {
+            const activeItem = player.GetActiveItem();
+            if (activeItem === CollectibleType.ALABASTER_BOX) {
+                const totalCharge = getTotalCharge(player, activeSlot);
+                setActiveItem(player, CollectibleType.NULL, activeSlot);
+                alabasterBoxes.push([activeSlot, totalCharge]);
+            }
+        }
+    }
+    // Add the red heart containers.
+    if (character === PlayerType.THE_SOUL && subPlayer !== undefined) {
+        // Adding health to The Soul is a special case.
+        subPlayer.AddMaxHearts(playerHealth.maxHearts, false);
+    }
+    else {
+        player.AddMaxHearts(playerHealth.maxHearts, false);
+    }
+    // Add the eternal hearts.
+    player.AddEternalHearts(playerHealth.eternalHearts);
+    // Add the soul / black / bone hearts.
+    let soulHeartsRemaining = playerHealth.soulHearts;
+    playerHealth.soulHeartTypes.forEach((heartType, i) => {
+        const isHalf = playerHealth.soulHearts + playerHealth.boneHearts * 2 < (i + 1) * 2;
+        let addAmount = 2;
+        if (isHalf || heartType === HeartSubType.BONE || soulHeartsRemaining < 2) {
+            // Fix the bug where a half soul heart to the left of a bone heart will be treated as a full
+            // soul heart.
+            addAmount = 1;
+        }
+        if (heartType === HeartSubType.SOUL) {
+            player.AddSoulHearts(addAmount);
+            soulHeartsRemaining -= addAmount;
+        }
+        else if (heartType === HeartSubType.BLACK) {
+            player.AddBlackHearts(addAmount);
+            soulHeartsRemaining -= addAmount;
+        }
+        else if (heartType === HeartSubType.BONE) {
+            player.AddBoneHearts(addAmount);
+        }
+    });
+    /**
+     * Fill in the red heart containers.
+     *
+     * (Rotten Hearts must be filled in first in order for this to work properly, since they conflict
+     * with half red hearts.)
+     *
+     * The `EntityPlayer.AddRottenHearts` method is not like actually picking up a rotten heart, since
+     * it will only grant one rotten heart to Tainted Magdalene (whereas picking up a rotten heart
+     * would grant two).
+     */
+    player.AddRottenHearts(playerHealth.rottenHearts);
+    if (character === PlayerType.MAGDALENE_B) {
+        // Adding 1 heart to Tainted Magdalene will actually add two hearts.
+        const effectiveHearts = playerHealth.hearts / 2;
+        player.AddHearts(effectiveHearts);
+    }
+    else {
+        player.AddHearts(playerHealth.hearts);
+    }
+    player.AddGoldenHearts(playerHealth.goldenHearts);
+    player.AddBrokenHearts(playerHealth.brokenHearts);
+    // Set the Bethany / Tainted Bethany charges.
+    if (character === PlayerType.BETHANY) {
+        player.SetSoulCharge(playerHealth.soulCharges);
+    }
+    else if (character === PlayerType.BETHANY_B) {
+        player.SetBloodCharge(playerHealth.bloodCharges);
+    }
+    // Re-add the Alabaster Box, if present.
+    for (const [activeSlot, totalCharge] of alabasterBoxes) {
+        setActiveItem(player, CollectibleType.ALABASTER_BOX, activeSlot, totalCharge);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"playerHealth.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/functions/playerHealth.ts"],"names":[],"mappings":"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"}