isaacscript-common 84.0.0 → 84.1.0

package/dist/classes/features/other/StageHistory.js

@@ -0,0 +1,244 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageHistory = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../core/cachedClasses");
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const nextStage_1 = require("../../../functions/nextStage");
+const stage_1 = require("../../../functions/stage");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        stageHistory: [],
+    },
+};
+class StageHistory extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_LEVEL_REORDERED, this.postNewLevelReordered],
+        ];
+    }
+    // ModCallbackCustom.POST_NEW_LEVEL_REORDERED
+    postNewLevelReordered = () => {
+        const level = cachedClasses_1.game.GetLevel();
+        const stage = level.GetStage();
+        const stageType = level.GetStageType();
+        v.run.stageHistory.push({ stage, stageType });
+    };
+    /**
+     * Helper function to get the stage type that a trapdoor or heaven door would take the player to,
+     * based on the current stage, room, and game state flags.
+     *
+     * This function accounts for the previous floors that a player has visited thus far on the run so
+     * that the next stage type can be properly calculated on The Ascent (which makes it unlike the
+     * `getNextStageType` function).
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
+     *
+     * @param upwards Whether the player should go up to Cathedral in the case of being on Womb 2.
+     *                Default is false.
+     * @public
+     */
+    getNextStageTypeWithHistory(upwards = false) {
+        const backwardsPath = cachedClasses_1.game.GetStateFlag(isaac_typescript_definitions_1.GameStateFlag.BACKWARDS_PATH);
+        if (!backwardsPath) {
+            return (0, nextStage_1.getNextStageType)(upwards);
+        }
+        const level = cachedClasses_1.game.GetLevel();
+        const stage = level.GetStage();
+        const repentanceStage = (0, stage_1.onRepentanceStage)();
+        const visitedDownpour1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_1, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedDross1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_1, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        const visitedDownpour2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_2, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedDross2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_2, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        const visitedMines1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.CAVES_1, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedAshpit1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.CAVES_1, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        const visitedMines2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.DEPTHS_2, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedAshpit2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.DEPTHS_2, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        if (stage === isaac_typescript_definitions_1.LevelStage.BASEMENT_2 && repentanceStage) {
+            if (visitedDownpour1) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE;
+            }
+            if (visitedDross1) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE_B;
+            }
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.CAVES_1 && repentanceStage) {
+            if (visitedDownpour2) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE;
+            }
+            if (visitedDross2) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE_B;
+            }
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.CAVES_2 && !repentanceStage) {
+            if (visitedDownpour2) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE;
+            }
+            if (visitedDross2) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE_B;
+            }
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.CAVES_2 && repentanceStage) {
+            if (visitedMines1) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE;
+            }
+            if (visitedAshpit1) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE_B;
+            }
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_2 && !repentanceStage) {
+            if (visitedAshpit2) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE_B;
+            }
+            if (visitedMines2) {
+                return isaac_typescript_definitions_1.StageType.REPENTANCE;
+            }
+        }
+        const nextStage = this.getNextStageWithHistory();
+        return (0, stage_1.calculateStageType)(nextStage);
+    }
+    /**
+     * Helper function to get the stage that a trapdoor or heaven door would take the player to, based
+     * on the current stage, room, and game state flags.
+     *
+     * This function accounts for the previous floors that a player has visited thus far on the run so
+     * that the next stage can be properly calculated on The Ascent (which makes it unlike the
+     * `getNextStage` function).
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
+     */
+    getNextStageWithHistory() {
+        const backwardsPath = cachedClasses_1.game.GetStateFlag(isaac_typescript_definitions_1.GameStateFlag.BACKWARDS_PATH);
+        if (!backwardsPath) {
+            return (0, nextStage_1.getNextStage)();
+        }
+        const level = cachedClasses_1.game.GetLevel();
+        const stage = level.GetStage();
+        const repentanceStage = (0, stage_1.onRepentanceStage)();
+        const visitedDownpour1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_1, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedDross1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_1, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        const visitedDownpour2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_2, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedDross2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.BASEMENT_2, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        const visitedMines1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.CAVES_1, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedAshpit1 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.CAVES_1, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        const visitedMines2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.DEPTHS_2, isaac_typescript_definitions_1.StageType.REPENTANCE);
+        const visitedAshpit2 = this.hasVisitedStage(isaac_typescript_definitions_1.LevelStage.DEPTHS_2, isaac_typescript_definitions_1.StageType.REPENTANCE_B);
+        if (stage === isaac_typescript_definitions_1.LevelStage.BASEMENT_1) {
+            if (repentanceStage) {
+                // From Downpour 1 to Basement 1.
+                return isaac_typescript_definitions_1.LevelStage.BASEMENT_1;
+            }
+            // From Basement 1 to Home.
+            return isaac_typescript_definitions_1.LevelStage.HOME;
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.BASEMENT_2) {
+            if (repentanceStage) {
+                if (visitedDownpour1 || visitedDross1) {
+                    // From Downpour 2 to Downpour 1.
+                    return isaac_typescript_definitions_1.LevelStage.BASEMENT_1;
+                }
+                // From Downpour 2 to Basement 2.
+                return isaac_typescript_definitions_1.LevelStage.BASEMENT_2;
+            }
+            // From Basement 2 to Basement 1.
+            return isaac_typescript_definitions_1.LevelStage.BASEMENT_1;
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.CAVES_1) {
+            if (repentanceStage) {
+                if (visitedDownpour2 || visitedDross2) {
+                    // From Mines 1 to Downpour 1.
+                    return isaac_typescript_definitions_1.LevelStage.BASEMENT_2;
+                }
+                // From Mines 1 to Caves 1.
+                return isaac_typescript_definitions_1.LevelStage.CAVES_1;
+            }
+            // From Caves 1 to Basement 2.
+            return isaac_typescript_definitions_1.LevelStage.BASEMENT_2;
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.CAVES_2) {
+            if (repentanceStage) {
+                if (visitedMines1 || visitedAshpit1) {
+                    // From Mines 2 to Mines 1.
+                    return isaac_typescript_definitions_1.LevelStage.CAVES_1;
+                }
+                // From Mines 2 to Caves 2.
+                return isaac_typescript_definitions_1.LevelStage.CAVES_2;
+            }
+            // From Caves 2 to Caves 1.
+            return isaac_typescript_definitions_1.LevelStage.CAVES_1;
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_1) {
+            if (repentanceStage) {
+                if (visitedMines2 || visitedAshpit2) {
+                    // From Mausoleum 1 to Mines 2.
+                    return isaac_typescript_definitions_1.LevelStage.CAVES_2;
+                }
+                // From Mausoleum 1 to Depths 1.
+                return isaac_typescript_definitions_1.LevelStage.DEPTHS_1;
+            }
+            // From Depths 1 to Caves 2.
+            return isaac_typescript_definitions_1.LevelStage.CAVES_2;
+        }
+        if (stage === isaac_typescript_definitions_1.LevelStage.DEPTHS_2) {
+            if (repentanceStage) {
+                // From Mausoleum 2 to Depths 2.
+                return isaac_typescript_definitions_1.LevelStage.DEPTHS_2;
+            }
+            // From Depths 2 to Depths 1.
+            return isaac_typescript_definitions_1.LevelStage.DEPTHS_1;
+        }
+        return stage - 1;
+    }
+    /**
+     * Helper function to get all of the stages that a player has visited thus far on this run.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
+     *
+     * @public
+     */
+    getStageHistory() {
+        return v.run.stageHistory;
+    }
+    /**
+     * Helper function to check if a player has previous visited a particular stage (or stage + stage
+     * type combination) on this run.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
+     *
+     * @param stage The stage to check for.
+     * @param stageType Optional. If provided, will check for a specific stage and stage type
+     *                  combination.
+     */
+    hasVisitedStage(stage, stageType) {
+        if (stageType === undefined) {
+            return v.run.stageHistory.some((stageHistoryEntry) => stageHistoryEntry.stage === stage);
+        }
+        return v.run.stageHistory.some((stageHistoryEntry) => stageHistoryEntry.stage === stage &&
+            stageHistoryEntry.stageType === stageType);
+    }
+}
+exports.StageHistory = StageHistory;
+__decorate([
+    decorators_1.Exported
+], StageHistory.prototype, "getNextStageTypeWithHistory", null);
+__decorate([
+    decorators_1.Exported
+], StageHistory.prototype, "getNextStageWithHistory", null);
+__decorate([
+    decorators_1.Exported
+], StageHistory.prototype, "getStageHistory", null);
+__decorate([
+    decorators_1.Exported
+], StageHistory.prototype, "hasVisitedStage", null);

package/dist/classes/features/other/StartAmbush.js

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartAmbush = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const decorators_1 = require("../../../decorators");
+const ISCFeature_1 = require("../../../enums/ISCFeature");
+const entities_1 = require("../../../functions/entities");
+const pickupsSpecific_1 = require("../../../functions/pickupsSpecific");
+const Feature_1 = require("../../private/Feature");
+/** Hard-coding this makes it easier to clean up the pickups afterwards. */
+const SACK_SEED_THAT_SPAWNS_TWO_COINS = 6;
+class StartAmbush extends Feature_1.Feature {
+    runInNFrames;
+    /** @internal */
+    constructor(runInNFrames) {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.RUN_IN_N_FRAMES];
+        this.runInNFrames = runInNFrames;
+    }
+    /**
+     * Helper function to start a Challenge Room or the Boss Rush.
+     *
+     * Specifically, this is performed by spawning a sack on top of the player, waiting a game frame,
+     * and then removing the sack and the pickups that the sack dropped.
+     *
+     * In order to use this function, you must upgrade your mod with `ISCFeature.START_AMBUSH`.
+     *
+     * @public
+     */
+    startAmbush() {
+        const player = Isaac.GetPlayer();
+        const sack = (0, pickupsSpecific_1.spawnSackWithSeed)(isaac_typescript_definitions_1.SackSubType.NULL, player.Position, SACK_SEED_THAT_SPAWNS_TWO_COINS);
+        // The sack will play the "Appear" animation and the player will not be able to interact with it
+        // while this is occurring. By stopping the animation, it will transition to the "Idle"
+        // animation and be interactable on the next game frame.
+        const sprite = sack.GetSprite();
+        sprite.Stop();
+        const sackPtr = EntityPtr(sack);
+        this.runInNFrames.runNextGameFrame(() => {
+            const futureSack = sackPtr.Ref;
+            if (futureSack === undefined) {
+                return;
+            }
+            futureSack.Remove();
+            const sackPtrHash = GetPtrHash(futureSack);
+            const coins = (0, pickupsSpecific_1.getCoins)();
+            const coinsFromSack = coins.filter((pickup) => pickup.SpawnerEntity !== undefined &&
+                GetPtrHash(pickup.SpawnerEntity) === sackPtrHash);
+            (0, entities_1.removeEntities)(coinsFromSack);
+        });
+    }
+}
+exports.StartAmbush = StartAmbush;
+__decorate([
+    decorators_1.Exported
+], StartAmbush.prototype, "startAmbush", null);

package/dist/classes/features/other/TaintedLazarusPlayers.js

@@ -0,0 +1,115 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaintedLazarusPlayers = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const decorators_1 = require("../../../decorators");
+const log_1 = require("../../../functions/log");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        queuedTaintedLazarus: [],
+        queuedDeadTaintedLazarus: [],
+        /**
+         * The `POST_PLAYER_INIT` callback fires for Dead Tainted Lazarus at the beginning of the run.
+         * However, the player index for the Dead Tainted Lazarus player object at that time does not
+         * actually correspond to the player index for the real player once Flip has been used. Thus, we
+         * revert to using PtrHash as an index for our map, which is consistent between the Dead Tainted
+         * Lazarus object in the `POST_PLAYER_INIT` callback and the "real" Dead Tainted Lazarus.
+         *
+         * We use `EntityPlayer` as the value for the map instead of `EntityPtr` because using the
+         * pointer does not work for some reason. (When we unwrap it after one or more flips have been
+         * used, the pointers no longer point to the original objects, even if we manually update the
+         * pointers in the `POST_FLIP` callback.)
+         */
+        subPlayerMap: new Map(),
+    },
+};
+/**
+ * This feature provides a way for end-users to get the `EntityPlayer` object for the other Tainted
+ * Lazarus.
+ */
+class TaintedLazarusPlayers extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    vConditionalFunc = () => false;
+    /** @internal */
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 9
+            [isaac_typescript_definitions_1.ModCallback.POST_PLAYER_INIT, this.postPlayerInit],
+        ];
+    }
+    // ModCallback.POST_PLAYER_INIT (9)
+    postPlayerInit = (player) => {
+        const character = player.GetPlayerType();
+        if (character === isaac_typescript_definitions_1.PlayerType.LAZARUS_B) {
+            v.run.queuedTaintedLazarus.push(player);
+        }
+        else if (character === isaac_typescript_definitions_1.PlayerType.LAZARUS_2_B) {
+            v.run.queuedDeadTaintedLazarus.push(player);
+        }
+        else {
+            return;
+        }
+        this.checkDequeue();
+    };
+    /**
+     * Indexes are the `PtrHash`, values are the `EntityPtr` of the *other* Lazarus.
+     *
+     * When starting a run, the `POST_PLAYER_INIT` callback will fire first for Dead Tainted Lazarus,
+     * then for Tainted Lazarus. When continuing a run, the `POST_PLAYER_INIT` callback will fire
+     * first for the character that is currently active. Thus, since the order of the characters is
+     * not certain, we insert each of their pointers into a queue, and then only populate the map when
+     * we have one Tainted Lazarus and one Dead Tainted Lazarus.
+     */
+    checkDequeue() {
+        if (v.run.queuedTaintedLazarus.length === 0 ||
+            v.run.queuedDeadTaintedLazarus.length === 0) {
+            return;
+        }
+        const taintedLazarus = v.run.queuedTaintedLazarus.shift();
+        const deadTaintedLazarus = v.run.queuedDeadTaintedLazarus.shift();
+        if (taintedLazarus === undefined || deadTaintedLazarus === undefined) {
+            return;
+        }
+        const taintedLazarusPtrHash = GetPtrHash(taintedLazarus);
+        const deadTaintedLazarusPtrHash = GetPtrHash(deadTaintedLazarus);
+        if (taintedLazarusPtrHash === deadTaintedLazarusPtrHash) {
+            (0, log_1.logError)("Failed to cache the Tainted Lazarus player objects, since the hash for Tainted Lazarus and Dead Tainted Lazarus were the same.");
+            return;
+        }
+        v.run.subPlayerMap.set(taintedLazarusPtrHash, deadTaintedLazarus);
+        v.run.subPlayerMap.set(deadTaintedLazarusPtrHash, taintedLazarus);
+    }
+    /**
+     * Helper function to get the other version of Tainted Lazarus.
+     *
+     * - On Tainted Lazarus, returns the player object for Dead Tainted Lazarus.
+     * - On Dead Tainted Lazarus, returns the player object for Tainted Lazarus.
+     * - Returns undefined if player object retrieval failed for any reason.
+     *
+     * If you call the `EntityPlayer.Exists` method on the returned object, it will return false.
+     * However, you can still call the other methods like you normally would (e.g.
+     * `EntityPlayer.AddCollectible`).
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.CHARACTER_HEALTH_CONVERSION`.
+     *
+     * @public
+     */
+    getTaintedLazarusSubPlayer(player) {
+        const ptrHash = GetPtrHash(player);
+        return v.run.subPlayerMap.get(ptrHash);
+    }
+}
+exports.TaintedLazarusPlayers = TaintedLazarusPlayers;
+__decorate([
+    decorators_1.Exported
+], TaintedLazarusPlayers.prototype, "getTaintedLazarusSubPlayer", null);

package/dist/classes/features/other/UnlockAchievementsDetection.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnlockAchievementsDetection = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const constants_1 = require("../../../core/constants");
+const decorators_1 = require("../../../decorators");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const entitiesSpecific_1 = require("../../../functions/entitiesSpecific");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        canRunUnlockAchievements: true,
+    },
+};
+class UnlockAchievementsDetection extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    /** @internal */
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_GAME_STARTED_REORDERED,
+                this.postGameStartedReordered,
+            ],
+        ];
+    }
+    // ModCallbackCustom.POST_GAME_STARTED_REORDERED
+    postGameStartedReordered = () => {
+        const greedDonationMachine = (0, entitiesSpecific_1.spawnSlot)(isaac_typescript_definitions_1.SlotVariant.GREED_DONATION_MACHINE, 0, constants_1.VectorZero);
+        v.run.canRunUnlockAchievements = greedDonationMachine.Exists();
+        greedDonationMachine.Remove();
+    };
+    /**
+     * Helper function to see if the current run can unlock achievements. For example, if playing on a
+     * set seed or in a victory lap, achievements are disabled.
+     *
+     * Under the hood, this is determined by spawning a Greed Donation Machine at the beginning of the
+     * run and then seeing if it exists before removing it. (The results are cached for the entire
+     * run.)
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.UNLOCK_ACHIEVEMENTS_DETECTION`.
+     *
+     * @public
+     */
+    canRunUnlockAchievements() {
+        return v.run.canRunUnlockAchievements;
+    }
+}
+exports.UnlockAchievementsDetection = UnlockAchievementsDetection;
+__decorate([
+    decorators_1.Exported
+], UnlockAchievementsDetection.prototype, "canRunUnlockAchievements", null);