libram 0.5.3 → 0.5.7

package/dist/actions/ActionSource.d.ts

@@ -0,0 +1,116 @@
+import { Macro } from "../combat";
+import { Requirement } from "../maximize";
+export declare type FindActionSourceConstraints = {
+    /**
+     * Function returning true if we only accept familiar-based actions.
+     */
+    requireFamiliar?: () => boolean;
+    /**
+     * Function returning true if we only accept sources that are unlimited.
+     */
+    requireUnlimited?: () => boolean;
+    /**
+     * Function returning whether to disallow actions requiring familiar change.
+     */
+    noFamiliar?: () => boolean;
+    /**
+     * Function returning whether to disallow actions requiring equipment change.
+     */
+    noRequirements?: () => boolean;
+    /**
+     * Function returning whether to disallow actions requiring preparation.
+     */
+    noPreparation?: () => boolean;
+    /**
+     * Function returning maximum cost of allowed actions. If undefined, allow
+     * only actions that cost nothing.
+     */
+    maximumCost?: () => number;
+};
+export declare type ActionConstraints = {
+    /**
+     * Equipment requirements to have this action available.
+     */
+    equipmentRequirements?: () => Requirement;
+    /**
+     * Familiar required to be in use to have this action available.
+     */
+    familiar?: () => Familiar;
+    /**
+     * Miscellaneous preparation to ensure this action is available.
+     */
+    preparation?: () => boolean;
+    /**
+     * Cost in meat per usage of this action.
+     */
+    cost?: () => number;
+};
+/**
+ * A combat-based action resource in the game (e.g. a free run or free kill).
+ */
+export declare class ActionSource {
+    source: Item | Skill | Familiar;
+    potential: () => number;
+    macro: Macro;
+    constraints: ActionConstraints;
+    /**
+     * @param source Source of the action (e.g. item or skill needed).
+     * @param potential Function returning how many times this action can be used.
+     * @param macro Macro to execute this action in combat.
+     * @param constraints Constraints required for this action to be available.
+     */
+    constructor(source: Item | Skill | Familiar, potential: () => number, macro: Macro, constraints?: ActionConstraints);
+    /**
+     * @returns Name of the action source.
+     */
+    name(): string;
+    /**
+     * @returns Whether the action is available.
+     */
+    available(): boolean;
+    /**
+     * @returns Cost in meat per usage of the action.
+     */
+    cost(): number;
+    /**
+     * @returns Whether the action costs 0 meat to use.
+     */
+    isFree(): boolean;
+    /**
+     * @returns Whether unlimited uses of the action are available.
+     */
+    isUnlimited(): boolean;
+    /**
+     * Create a compound action source with merged constraints.
+     * @param others Other actions to have available.
+     * @returns Merged constraints, or null if they are inconsistent.
+     */
+    merge(...others: ActionSource[]): ActionSource | null;
+    /**
+     * Perform all preparation necessary to make this action available.
+     * @param otherRequirements Any other equipment requirements.
+     * @returns Whether preparation succeeded.
+     */
+    prepare(otherRequirements?: Requirement): boolean;
+    /**
+     * Perform all preparation necessary to make this action available.
+     * Throws an error if preparation fails.
+     * @param otherRequirements Any other equipment requirements.
+     */
+    ensure(otherRequirements?: Requirement): void;
+}
+/**
+ * Find an available action source subject to constraints.
+ * @param actions Action source list.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Available action source satisfying constraints, or null.
+ */
+export declare function findActionSource(actions: ActionSource[], constraints?: FindActionSourceConstraints): ActionSource | null;
+/**
+ * Count available action sources subject to constraints. Note that, if
+ * constraints.maximumCost is high enough, this will return Infinity.
+ * @param actions Action source list.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Count of available action sources.
+ */
+export declare function actionSourcesAvailable(actions: ActionSource[], constraints?: FindActionSourceConstraints): number;

package/dist/actions/ActionSource.js

@@ -0,0 +1,156 @@
+import { useFamiliar } from "kolmafia";
+import { Macro } from "../combat";
+import { Requirement } from "../maximize";
+import { sum } from "../utils";
+function mergeConstraints(...allConstraints) {
+    const familiars = allConstraints
+        .map((constraints) => constraints.familiar)
+        .filter((familiar) => familiar);
+    if (familiars.length > 1) {
+        // Inconsistent requirements.
+        return null;
+    }
+    return {
+        equipmentRequirements: () => Requirement.merge([
+            ...allConstraints.map((constraints) => constraints.equipmentRequirements?.() ?? new Requirement([], {})),
+        ]),
+        preparation: () => {
+            let success = true;
+            for (const constraints of allConstraints) {
+                success =
+                    success && (!constraints.preparation || constraints.preparation());
+            }
+            return success;
+        },
+        familiar: familiars.find((familiar) => familiar),
+        cost: () => sum(allConstraints, (constraints) => constraints.cost?.() ?? 0),
+    };
+}
+/**
+ * A combat-based action resource in the game (e.g. a free run or free kill).
+ */
+export class ActionSource {
+    source;
+    potential; // Infinity: unlimited
+    macro;
+    constraints;
+    /**
+     * @param source Source of the action (e.g. item or skill needed).
+     * @param potential Function returning how many times this action can be used.
+     * @param macro Macro to execute this action in combat.
+     * @param constraints Constraints required for this action to be available.
+     */
+    constructor(source, potential, macro, constraints = {}) {
+        this.source = source;
+        this.potential = potential;
+        this.macro = macro;
+        this.constraints = constraints;
+    }
+    /**
+     * @returns Name of the action source.
+     */
+    name() {
+        return this.source.toString();
+    }
+    /**
+     * @returns Whether the action is available.
+     */
+    available() {
+        return this.potential() > 0;
+    }
+    /**
+     * @returns Cost in meat per usage of the action.
+     */
+    cost() {
+        return this.constraints.cost ? this.constraints.cost() : 0;
+    }
+    /**
+     * @returns Whether the action costs 0 meat to use.
+     */
+    isFree() {
+        return !this.cost || this.cost() === 0;
+    }
+    /**
+     * @returns Whether unlimited uses of the action are available.
+     */
+    isUnlimited() {
+        return this.potential() === Infinity;
+    }
+    /**
+     * Create a compound action source with merged constraints.
+     * @param others Other actions to have available.
+     * @returns Merged constraints, or null if they are inconsistent.
+     */
+    merge(...others) {
+        const actions = [this, ...others];
+        const constraints = mergeConstraints(...actions.map((action) => action.constraints));
+        if (constraints === null) {
+            // Inconsistent constraints - no path forward here.
+            return null;
+        }
+        return new ActionSource(this.source, () => sum(actions, (action) => action.potential()), Macro.step(...actions.map((action) => action.macro)), constraints);
+    }
+    /**
+     * Perform all preparation necessary to make this action available.
+     * @param otherRequirements Any other equipment requirements.
+     * @returns Whether preparation succeeded.
+     */
+    prepare(otherRequirements) {
+        if (this.constraints.familiar?.()) {
+            if (!useFamiliar(this.constraints.familiar()))
+                return false;
+        }
+        if (this.constraints.equipmentRequirements) {
+            const requirement = otherRequirements
+                ? otherRequirements.merge(this.constraints.equipmentRequirements())
+                : this.constraints.equipmentRequirements();
+            if (!requirement.maximize())
+                return false;
+        }
+        if (this.constraints.preparation)
+            return this.constraints.preparation();
+        return true;
+    }
+    /**
+     * Perform all preparation necessary to make this action available.
+     * Throws an error if preparation fails.
+     * @param otherRequirements Any other equipment requirements.
+     */
+    ensure(otherRequirements) {
+        if (!this.prepare(otherRequirements)) {
+            throw new Error(`Failed to prepare action ${this.name()}.`);
+        }
+    }
+}
+function filterAction(action, constraints) {
+    return (action.available() &&
+        !(constraints.requireFamiliar?.() && !action.constraints.familiar) &&
+        !(constraints.requireUnlimited?.() && !action.isUnlimited()) &&
+        !(constraints.noFamiliar?.() && action.constraints.familiar) &&
+        !(constraints.noRequirements?.() && action.constraints.equipmentRequirements) &&
+        !(constraints.noPreparation?.() && action.constraints.preparation) &&
+        action.cost() <= (constraints.maximumCost?.() ?? 0));
+}
+/**
+ * Find an available action source subject to constraints.
+ * @param actions Action source list.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Available action source satisfying constraints, or null.
+ */
+export function findActionSource(actions, constraints = {}) {
+    return (actions
+        .filter((actions) => filterAction(actions, constraints))
+        .sort((a, b) => a.cost() - b.cost())
+        .find((action) => action) ?? null);
+}
+/**
+ * Count available action sources subject to constraints. Note that, if
+ * constraints.maximumCost is high enough, this will return Infinity.
+ * @param actions Action source list.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Count of available action sources.
+ */
+export function actionSourcesAvailable(actions, constraints = {}) {
+    // TODO: This will overcount if any Actions share a counter
+    return sum(actions.filter((action) => filterAction(action, constraints ?? {})), (action) => action.potential());
+}

package/dist/actions/FreeKill.d.ts

@@ -0,0 +1,14 @@
+import { ActionSource, FindActionSourceConstraints } from "./ActionSource";
+/**
+ * Find an available free kill source subject to constraints.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free kill source satisfying constraints, or null.
+ */
+export declare function tryFindFreeKill(constraints?: FindActionSourceConstraints): ActionSource | null;
+/**
+ * Ensure an available free kill source subject to constraints.
+ * Throws an error if no source can be found.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free kill source satisfying constraints.
+ */
+export declare function ensureFreeKill(constraints?: FindActionSourceConstraints): ActionSource;

package/dist/actions/FreeKill.js

@@ -0,0 +1,88 @@
+import { mallPrice, myLightning, restoreMp, retrieveItem, use } from "kolmafia";
+import { Macro } from "../combat";
+import { have } from "../lib";
+import { Requirement } from "../maximize";
+import { get } from "../property";
+import { $familiar, $item, $items, $skill } from "../template-string";
+import { ActionSource, findActionSource, } from "./ActionSource";
+import * as AsdonMartin from "../resources/2017/AsdonMartin";
+const freeKillSources = [
+    // Free limited sources
+    new ActionSource($skill `Gingerbread Mob Hit`, () => !get("_gingerbreadMobHitUsed") && have($skill `Gingerbread Mob Hit`)
+        ? 1
+        : 0, Macro.skill($skill `Gingerbread Mob Hit`), {
+        preparation: () => restoreMp(30),
+    }),
+    new ActionSource($skill `Shattering Punch`, () => have($skill `Shattering Punch`) ? 3 - get("_shatteringPunchUsed") : 0, Macro.skill($skill `Shattering Punch`), {
+        preparation: () => restoreMp(30),
+    }),
+    new ActionSource($item `replica bat-oomerang`, () => have($item `replica bat-oomerang`)
+        ? 3 - get("_usedReplicaBatoomerang")
+        : 0, Macro.item($item `replica bat-oomerang`)),
+    new ActionSource($item `The Jokester's gun`, () => !get("_firedJokestersGun") && have($item `The Jokester's gun`) ? 1 : 0, Macro.skill($skill `Fire the Jokester's Gun`), {
+        equipmentRequirements: () => new Requirement([], {
+            forceEquip: $items `The Jokester's gun`,
+        }),
+    }),
+    new ActionSource($item `Lil' Doctor™ bag`, () => (have($item `Lil' Doctor™ bag`) ? 3 - get("_chestXRayUsed") : 0), Macro.skill($skill `Chest X-Ray`), {
+        equipmentRequirements: () => new Requirement([], {
+            forceEquip: $items `Lil' Doctor™ bag`,
+        }),
+    }),
+    new ActionSource($skill `Asdon Martin: Missile Launcher`, () => (!get("_missileLauncherUsed") && AsdonMartin.installed() ? 1 : 0), Macro.skill($skill `Asdon Martin: Missile Launcher`), {
+        preparation: () => AsdonMartin.fillTo(100),
+    }),
+    // Heavy Rains
+    new ActionSource($skill `Lightning Strike`, () => (have($skill `Lightning Strike`) ? Math.floor(myLightning() / 20) : 0), Macro.skill($skill `Lightning Strike`)),
+    // Expensive limited sources
+    new ActionSource($item `powdered madness`, () => 5 - get("_powderedMadnessUses"), Macro.item($item `powdered madness`), {
+        preparation: () => retrieveItem($item `powdered madness`),
+        cost: () => mallPrice($item `powdered madness`),
+    }),
+    new ActionSource($familiar `Puck Man`, () => (have($familiar `Puck Man`) ? 20 - get("_powerPillUses") : 0), Macro.item($item `power pill`), {
+        familiar: () => $familiar `Puck Man`,
+        preparation: () => retrieveItem($item `power pill`),
+        cost: () => mallPrice($item `power pill`),
+    }),
+    new ActionSource($familiar `Ms. Puck Man`, () => (have($familiar `Ms. Puck Man`) ? 20 - get("_powerPillUses") : 0), Macro.item($item `power pill`), {
+        familiar: () => $familiar `Ms. Puck Man`,
+        preparation: () => retrieveItem($item `power pill`),
+        cost: () => mallPrice($item `power pill`),
+    }),
+    // Expensive unlimited sources
+    new ActionSource($skill `Shocking Lick`, () => Infinity, Macro.skill($skill `Shocking Lick`), {
+        preparation: () => {
+            if (get("shockingLickCharges") === 0 &&
+                retrieveItem($item `battery (9-Volt)`)) {
+                use($item `battery (9-Volt)`);
+            }
+            return get("shockingLickCharges") > 0;
+        },
+        cost: () => mallPrice($item `battery (AAA)`) * 4,
+    }),
+    ...$items `Daily Affirmation: Think Win-Lose, superduperheated metal`.map((item) => new ActionSource(item, () => Infinity, Macro.item(item), {
+        preparation: () => retrieveItem(item),
+        cost: () => mallPrice(item),
+    })),
+];
+/**
+ * Find an available free kill source subject to constraints.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free kill source satisfying constraints, or null.
+ */
+export function tryFindFreeKill(constraints) {
+    return findActionSource(freeKillSources, constraints);
+}
+/**
+ * Ensure an available free kill source subject to constraints.
+ * Throws an error if no source can be found.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free kill source satisfying constraints.
+ */
+export function ensureFreeKill(constraints) {
+    const source = tryFindFreeKill(constraints);
+    if (!source) {
+        throw new Error("Failed to ensure Free Kill source");
+    }
+    return source;
+}

package/dist/actions/FreeRun.d.ts

@@ -0,0 +1,14 @@
+import { ActionSource, FindActionSourceConstraints } from "./ActionSource";
+/**
+ * Find an available free run source subject to constraints.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free run source satisfying constraints, or null.
+ */
+export declare function tryFindFreeRun(constraints?: FindActionSourceConstraints): ActionSource | null;
+/**
+ * Ensure an available free run source subject to constraints.
+ * Throws an error if no source can be found.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free run source satisfying constraints.
+ */
+export declare function ensureFreeRun(constraints?: FindActionSourceConstraints): ActionSource;

package/dist/actions/FreeRun.js

@@ -0,0 +1,149 @@
+import { cliExecute, mallPrice, myTurncount, restoreMp, retrieveItem, visitUrl, } from "kolmafia";
+import { Macro } from "../combat";
+import { ensureEffect, getFoldGroup, getSongCount, getSongLimit, have, } from "../lib";
+import { Requirement } from "../maximize";
+import { get } from "../property";
+import { $effect, $item, $items, $skill } from "../template-string";
+import { ActionSource, findActionSource, } from "./ActionSource";
+import * as Bandersnatch from "../resources/2009/Bandersnatch";
+import * as StompingBoots from "../resources/2011/StompingBoots";
+import * as AsdonMartin from "../resources/2017/AsdonMartin";
+// Value of _lastCombatStarted the last time we updated scrapbook charges.
+let scrapbookChargesLastUpdated = get("_lastCombatStarted");
+// Free unlimited source every 30 turns.
+// Does not work on special monsters so needs a backup, see tryFindFreeRun.
+// banishedMonsters isn't updated if the free run succeeds on an unbanishable monster
+const asdonMartinSource = new ActionSource($skill `Asdon Martin: Spring-Loaded Front Bumper`, () => {
+    if (!AsdonMartin.installed())
+        return 0;
+    const banishes = get("banishedMonsters").split(":");
+    const bumperIndex = banishes
+        .map((string) => string.toLowerCase())
+        .indexOf("spring-loaded front bumper");
+    if (bumperIndex === -1)
+        return 1;
+    return myTurncount() - parseInt(banishes[bumperIndex + 1]) > 30 ? 1 : 0;
+}, Macro.trySkill($skill `Asdon Martin: Spring-Loaded Front Bumper`), {
+    preparation: () => AsdonMartin.fillTo(50),
+});
+const freeRunSources = [
+    // Free limited sources
+    new ActionSource(Bandersnatch.familiar, () => (have($effect `Ode to Booze`) || getSongCount() < getSongLimit()) &&
+        Bandersnatch.couldRunaway()
+        ? Bandersnatch.getRemainingRunaways()
+        : 0, Macro.step("runaway"), {
+        equipmentRequirements: () => new Requirement(["Familiar Weight"], {}),
+        preparation: () => {
+            ensureEffect($effect `Ode to Booze`);
+            return have($effect `Ode to Booze`);
+        },
+        familiar: () => Bandersnatch.familiar,
+    }),
+    new ActionSource(StompingBoots.familiar, () => StompingBoots.couldRunaway() ? StompingBoots.getRemainingRunaways() : 0, Macro.step("runaway"), {
+        equipmentRequirements: () => new Requirement(["Familiar Weight"], {}),
+        familiar: () => StompingBoots.familiar,
+    }),
+    new ActionSource($skill `Snokebomb`, () => (have($skill `Snokebomb`) ? 3 - get("_snokebombUsed") : 0), Macro.skill($skill `Snokebomb`), {
+        preparation: () => restoreMp(50),
+    }),
+    new ActionSource($skill `Emotionally Chipped`, () => (have($skill `Emotionally Chipped`) ? 3 - get("_feelHatredUsed") : 0), Macro.skill($skill `Feel Hatred`)),
+    new ActionSource($item `Kremlin's Greatest Briefcase`, () => have($item `Kremlin's Greatest Briefcase`)
+        ? 3 - get("_kgbTranquilizerDartUses")
+        : 0, Macro.skill($skill `KGB tranquilizer dart`), {
+        equipmentRequirements: () => new Requirement([], {
+            forceEquip: $items `Kremlin's Greatest Briefcase`,
+        }),
+    }),
+    new ActionSource($item `latte lovers member's mug`, () => have($item `latte lovers member's mug`) && !get("_latteBanishUsed")
+        ? 1
+        : 0, Macro.skill($skill `Throw Latte on Opponent`), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `latte lovers member's mug` }),
+    }),
+    new ActionSource($item `Lil' Doctor™ bag`, () => (have($item `Lil' Doctor™ bag`) ? 3 - get("_reflexHammerUsed") : 0), Macro.skill($skill `Reflex Hammer`), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `Lil' Doctor™ bag` }),
+    }),
+    new ActionSource($item `mafia middle finger ring`, () => have($item `mafia middle finger ring`) &&
+        !get("_mafiaMiddleFingerRingUsed")
+        ? 1
+        : 0, Macro.skill($skill `Show them your ring`), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `mafia middle finger ring` }),
+    }),
+    new ActionSource($item `V for Vivala mask`, () => have($item `V for Vivala mask`) && !get("_vmaskBanisherUsed") ? 1 : 0, Macro.skill($skill `Creepy Grin`), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `V for Vivala mask` }),
+        preparation: () => restoreMp(30),
+    }),
+    new ActionSource($item `stinky cheese eye`, () => getFoldGroup($item `stinky cheese eye`).some((item) => have(item)) &&
+        !get("_stinkyCheeseBanisherUsed")
+        ? 1
+        : 0, Macro.skill($skill `Give Your Opponent the Stinkeye`), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `stinky cheese eye` }),
+        preparation: () => {
+            if (!have($item `stinky cheese eye`)) {
+                cliExecute(`fold stinky cheese eye`);
+            }
+            return have($item `stinky cheese eye`);
+        },
+    }),
+    new ActionSource($item `navel ring of navel gazing`, () => have($item `navel ring of navel gazing`)
+        ? Math.max(0, 3 - get("_navelRunaways"))
+        : 0, Macro.step("runaway"), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `navel ring of navel gazing` }),
+    }),
+    new ActionSource($item `Greatest American Pants`, () => have($item `Greatest American Pants`)
+        ? Math.max(0, 3 - get("_navelRunaways"))
+        : 0, Macro.step("runaway"), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `Greatest American Pants` }),
+    }),
+    new ActionSource($skill `Show your boring familiar pictures`, () => {
+        if (have($item `familiar scrapbook`)) {
+            if (scrapbookChargesLastUpdated !== get("_lastCombatStarted")) {
+                visitUrl("desc_item.php?whichitem=463063785");
+                scrapbookChargesLastUpdated = get("_lastCombatStarted");
+            }
+            return Math.floor(get("scrapbookCharges") / 100);
+        }
+        return 0;
+    }, Macro.skill($skill `Show your boring familiar pictures`), {
+        equipmentRequirements: () => new Requirement([], { forceEquip: $items `familiar scrapbook` }),
+    }),
+    new ActionSource($item `peppermint parasol`, () => Math.max(0, 3 - get("_navelRunaways")), Macro.item($item `peppermint parasol`), {
+        preparation: () => retrieveItem($item `peppermint parasol`),
+        cost: () => Math.min(mallPrice($item `peppermint sprout`) * 5, mallPrice($item `peppermint parasol`)) / 10, // Breaks after 10 successful runaways.
+    }),
+    new ActionSource($item `human musk`, () => Math.max(0, 3 - get("_humanMuskUses")), Macro.item($item `human musk`), {
+        preparation: () => retrieveItem($item `human musk`),
+        cost: () => mallPrice($item `human musk`),
+    }),
+    // Expensive unlimited sources
+    ...$items `Louder Than Bomb, divine champagne popper, tennis ball`.map((item) => new ActionSource(item, () => Infinity, Macro.item(item), {
+        preparation: () => retrieveItem(item),
+        cost: () => mallPrice(item),
+    })),
+];
+/**
+ * Find an available free run source subject to constraints.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free run source satisfying constraints, or null.
+ */
+export function tryFindFreeRun(constraints) {
+    let source = findActionSource(freeRunSources, constraints);
+    // Always try to use Asdon Martin: Spring-Loaded Front Bumper first,
+    // but only if another source has been found.
+    if (source && asdonMartinSource.available()) {
+        source = asdonMartinSource.merge(source);
+    }
+    return source;
+}
+/**
+ * Ensure an available free run source subject to constraints.
+ * Throws an error if no source can be found.
+ * @param constraints Preexisting constraints that restrict possible sources.
+ * @returns Free run source satisfying constraints.
+ */
+export function ensureFreeRun(constraints) {
+    const source = tryFindFreeRun(constraints);
+    if (!source) {
+        throw new Error("Failed to ensure Free Run source");
+    }
+    return source;
+}

package/dist/actions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ActionSource";
+export * from "./FreeKill";
+export * from "./FreeRun";

package/dist/actions/index.js

@@ -0,0 +1,3 @@
+export * from "./ActionSource";
+export * from "./FreeKill";
+export * from "./FreeRun";

package/dist/ascend.js

@@ -84,7 +84,7 @@ export function ascend(path, playerClass, lifestyle, moon, consumable = $item `a
     if (moonId < 1 || moonId > 9)
         throw `Invalid moon ${moon}`;
     if (consumable &&
-        !$items `astral six-pack, astral hot dog dinner`.includes(consumable))
+        !$items `astral six-pack, astral hot dog dinner, carton of astral energy drinks`.includes(consumable))
         throw `Invalid consumable ${consumable}`;
     if (pet &&
         !$items `astral bludgeon, astral shield, astral chapeau, astral bracer, astral longbow, astral shorts, astral mace, astral ring, astral statuette, astral pistol, astral mask, astral pet sweater, astral shirt, astral belt`.includes(pet))

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./actions";
 export * from "./ascend";
 export * from "./Clan";
 export * from "./combat";
@@ -18,7 +19,6 @@ export * from "./utils";
 export { get, PropertiesManager, set, setProperties, withProperties, withProperty, withChoices, withChoice, } from "./property";
 export { get as getModifier } from "./modifier";
 export { Modifiers } from "./modifier";
-export * from "./freerun";
 export * as Dreadsylvania from "./dungeons/Dreadsylvania";
 export * as Hobopolis from "./dungeons/Hobopolis";
 export * as SlimeTube from "./dungeons/SlimeTube";

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from "./actions";
 export * from "./ascend";
 export * from "./Clan";
 export * from "./combat";
@@ -17,7 +18,6 @@ export * as property from "./property";
 export * from "./utils";
 export { get, PropertiesManager, set, setProperties, withProperties, withProperty, withChoices, withChoice, } from "./property";
 export { get as getModifier } from "./modifier";
-export * from "./freerun";
 export * as Dreadsylvania from "./dungeons/Dreadsylvania";
 export * as Hobopolis from "./dungeons/Hobopolis";
 export * as SlimeTube from "./dungeons/SlimeTube";

package/dist/modifier.d.ts

@@ -1,3 +1,4 @@
+import "core-js/modules/es.object.values";
 import { BooleanModifier, ClassModifier, EffectModifier, MonsterModifier, NumericModifier, SkillModifier, StatModifier, StringModifier } from "./modifierTypes";
 export declare function get(name: BooleanModifier, subject?: string | Item | Effect): boolean;
 export declare function get(name: ClassModifier, subject: string | Item): Class;

package/dist/modifier.js

@@ -1,3 +1,4 @@
+import "core-js/modules/es.object.values";
 import { booleanModifier, classModifier, effectModifier, monsterModifier, numericModifier, skillModifier, statModifier, stringModifier, } from "kolmafia";
 import { arrayContains } from "./utils";
 import { booleanModifiers, classModifiers, effectModifiers, monsterModifiers, numericModifiers, skillModifiers, statModifiers, stringModifiers, } from "./modifierTypes";

package/dist/mood.d.ts

@@ -1,3 +1,4 @@
+import "core-js/modules/es.object.values";
 export declare abstract class MpSource {
     usesRemaining(): number | null;
     abstract availableMpMin(): number;

package/dist/mood.js

@@ -1,3 +1,4 @@
+import "core-js/modules/es.object.values";
 import { availableAmount, buy, cliExecute, eat, effectModifier, haveEffect, haveSkill, hpCost, itemAmount, mallPrice, mpCost, myHp, myMaxmp, myMp, numericModifier, retrieveItem, toEffect, toSkill, turnsPerCast, use, useSkill, } from "kolmafia";
 import { getActiveSongs, have, isSong } from "./lib";
 import { get } from "./property";
@@ -130,13 +131,25 @@ class PotionMoodElement extends MoodElement {
         if (mallPrice(this.potion) > this.maxPricePerTurn * turnsPerUse) {
             return false;
         }
+        //integer part
         if (effectTurns < ensureTurns) {
-            const uses = (ensureTurns - effectTurns) / turnsPerUse;
+            const uses = Math.floor((ensureTurns - effectTurns) / turnsPerUse);
             const quantityToBuy = clamp(uses - availableAmount(this.potion), 0, 100);
-            buy(quantityToBuy, this.potion, this.maxPricePerTurn * turnsPerUse);
+            buy(quantityToBuy, this.potion, Math.floor(this.maxPricePerTurn * turnsPerUse));
             const quantityToUse = clamp(uses, 0, availableAmount(this.potion));
             use(quantityToUse, this.potion);
         }
+        //fractional part
+        const remainingDifference = ensureTurns - haveEffect(effect);
+        if (remainingDifference > 0) {
+            const price = this.maxPricePerTurn * remainingDifference;
+            if (price <= mallPrice(this.potion)) {
+                if (availableAmount(this.potion) ||
+                    buy(1, this.potion, Math.floor(price))) {
+                    use(1, this.potion);
+                }
+            }
+        }
         return haveEffect(effect) >= ensureTurns;
     }
 }