libram 0.3.2 → 0.4.2

package/dist/console.js

@@ -1,38 +1,15 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.error = exports.warn = exports.info = exports.log = void 0;
-
-require("core-js/modules/es.array.map.js");
-
-require("core-js/modules/es.object.to-string.js");
-
-require("core-js/modules/es.regexp.to-string.js");
-
-var _kolmafia = require("kolmafia");
-
+import { print } from "kolmafia";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-var logColor = color => function () {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-
-  var output = args.map(x => x.toString()).join(" ");
-
-  if (color) {
-    (0, _kolmafia.print)(output, color);
-  } else {
-    (0, _kolmafia.print)(output);
-  }
+const logColor = (color) => (...args) => {
+    const output = args.map((x) => x.toString()).join(" ");
+    if (color) {
+        print(output, color);
+    }
+    else {
+        print(output);
+    }
 };
-
-var log = logColor();
-exports.log = log;
-var info = logColor("blue");
-exports.info = info;
-var warn = logColor("red");
-exports.warn = warn;
-var error = logColor("red");
-exports.error = error;
+export const log = logColor();
+export const info = logColor("blue");
+export const warn = logColor("red");
+export const error = logColor("red");

package/dist/diet/index.d.ts

@@ -0,0 +1,31 @@
+declare type MenuItemOptions = {
+    organ?: Organ;
+    size?: number;
+    maximum?: number | "auto";
+    additionalValue?: number;
+    wishEffect?: Effect;
+};
+export declare class MenuItem {
+    item: Item;
+    organ?: Organ;
+    size: number;
+    maximum?: number;
+    additionalValue?: number;
+    wishEffect?: Effect;
+    static defaultOptions: Map<Item, MenuItemOptions>;
+    constructor(item: Item, options?: MenuItemOptions);
+    equals(other: MenuItem): boolean;
+    toString(): string;
+    price(): number;
+}
+declare const organs: readonly ["food", "booze", "spleen item"];
+declare type Organ = typeof organs[number];
+/**
+ * Plan out an optimal diet using a knapsack algorithm.
+ * @param mpa Meat per adventure value.
+ * @param menu Array of MenuItems to consider for diet purposes.
+ * @param organCapacities Optional override of each organ's capacity.
+ * @returns Array of [menu item and helpers, count].
+ */
+export declare function planDiet(mpa: number, menu: MenuItem[], organCapacities?: [Organ, number | null][]): [MenuItem[], number][];
+export {};

package/dist/diet/index.js

@@ -0,0 +1,333 @@
+import { fullnessLimit, getWorkshed, inebrietyLimit, itemType, mallPrice, mallPrices, myFullness, myPrimestat, mySpleenUse, npcPrice, spleenLimit, } from "kolmafia";
+import { knapsack } from "./knapsack";
+import { have } from "../lib";
+import { $effect, $item, $items, $skill, $stat } from "../template-string";
+import { sum } from "../utils";
+// TODO: Include other consumption modifiers - Salty Mouth?
+// TODO: Include Gar-ish etc.
+function expectedAdventures(item, modifiers) {
+    if (item.adventures === "")
+        return 0;
+    const [min, recordedMax] = item.adventures
+        .split(/[-–—]/)
+        .map((s) => parseInt(s));
+    const max = recordedMax ?? min;
+    const interpolated = [...new Array(max - min + 1).keys()].map((n) => n + min);
+    const forkMugMultiplier = (itemType(item) === "food" && item.notes?.includes("SALAD")) ||
+        (itemType(item) === "booze" && item.notes?.includes("BEER"))
+        ? 1.5
+        : 1.3;
+    const refinedPalate = modifiers.refinedPalate && item.notes?.includes("WINE");
+    const pinkyRing = modifiers.pinkyRing && item.notes?.includes("WINE");
+    return (sum(interpolated, (baseAdventures) => {
+        let adventures = baseAdventures;
+        if (modifiers.forkMug) {
+            adventures = Math.floor(adventures * forkMugMultiplier);
+        }
+        if (refinedPalate)
+            adventures = Math.floor(adventures * 1.25);
+        if (pinkyRing)
+            adventures = Math.round(adventures * 1.125);
+        if (item.notes?.includes("MARTINI") && modifiers.tuxedoShirt) {
+            adventures += 2;
+        }
+        if (have($skill `Saucemaven`) && item.notes?.includes("SAUCY")) {
+            adventures += myPrimestat() === $stat `Mysticality` ? 5 : 3;
+        }
+        if (itemType(item) === "food" && modifiers.seasoning)
+            adventures++;
+        if (itemType(item) === "food" && modifiers.mayoflex)
+            adventures++;
+        return adventures;
+    }) / interpolated.length);
+}
+export class MenuItem {
+    constructor(item, options = {}) {
+        const { size, organ, maximum, additionalValue, wishEffect } = {
+            ...options,
+            ...(MenuItem.defaultOptions.get(item) ?? {}),
+        };
+        this.item = item;
+        this.maximum = maximum === "auto" ? item.dailyusesleft : maximum;
+        this.additionalValue = additionalValue;
+        this.wishEffect = wishEffect;
+        const typ = itemType(this.item);
+        this.organ = organ ?? (isOrgan(typ) ? typ : undefined);
+        this.size =
+            size ??
+                (this.organ === "food"
+                    ? this.item.fullness
+                    : this.organ === "booze"
+                        ? this.item.inebriety
+                        : this.organ === "spleen item"
+                            ? this.item.spleen
+                            : 0);
+    }
+    equals(other) {
+        return this.item === other.item && this.wishEffect === other.wishEffect;
+    }
+    toString() {
+        return this.item.toString();
+    }
+    price() {
+        return npcPrice(this.item) > 0 ? npcPrice(this.item) : mallPrice(this.item);
+    }
+}
+MenuItem.defaultOptions = new Map([
+    [$item `Mr. Burnsger`, { maximum: "auto" }],
+    [
+        $item `distention pill`,
+        {
+            organ: "food",
+            maximum: "auto",
+            size: -1,
+        },
+    ],
+    [
+        $item `synthetic dog hair pill`,
+        { organ: "booze", maximum: "auto", size: -1 },
+    ],
+    [$item `cuppa Voraci tea`, { organ: "food", maximum: "auto", size: -1 }],
+    [$item `cuppa Sobrie tea`, { organ: "booze", maximum: "auto", size: -1 }],
+    [$item `mojo filter`, { organ: "spleen item", maximum: "auto", size: -1 }],
+]);
+const organs = ["food", "booze", "spleen item"];
+function isOrgan(x) {
+    return organs.includes(x);
+}
+class DietPlanner {
+    constructor(mpa, menu) {
+        this.spleenValue = 0;
+        this.mpa = mpa;
+        this.fork = menu.find((item) => item.item === $item `Ol' Scratch's salad fork`);
+        this.mug = menu.find((item) => item.item === $item `Frosty's frosty mug`);
+        this.seasoning = menu.find((item) => item.item === $item `Special Seasoning`);
+        this.mayoflex =
+            getWorkshed() === $item `portable Mayo Clinic`
+                ? menu.find((item) => item.item === $item `Mayoflex`)
+                : undefined;
+        this.pinkyRing = have($item `mafia pinky ring`);
+        this.tuxedoShirt = have($item `tuxedo shirt`);
+        this.menu = menu.filter((item) => item.organ);
+        if (menu.length > 100) {
+            mallPrices("food");
+            mallPrices("booze");
+        }
+        const spleenItems = menu.filter((item) => itemType(item.item) === "spleen item");
+        spleenItems.sort((x, y) => -(this.consumptionValue(x) / x.item.spleen -
+            this.consumptionValue(y) / y.item.spleen));
+        if (spleenItems.length > 0) {
+            this.spleenValue =
+                this.consumptionValue(spleenItems[0]) / spleenItems[0].item.spleen;
+        }
+    }
+    consumptionValue(menuItem) {
+        return this.consumptionHelpersAndValue(menuItem, {})[1];
+    }
+    consumptionHelpersAndValue(menuItem, overrideModifiers) {
+        const helpers = [];
+        if (this.seasoning &&
+            itemType(menuItem.item) === "food" &&
+            this.mpa > mallPrice($item `Special Seasoning`)) {
+            helpers.push(this.seasoning);
+        }
+        if (this.mayoflex &&
+            itemType(menuItem.item) === "food" &&
+            this.mpa > npcPrice($item `Mayoflex`)) {
+            helpers.push(this.mayoflex);
+        }
+        const defaultModifiers = {
+            forkMug: false,
+            seasoning: this.seasoning ? helpers.includes(this.seasoning) : false,
+            mayoflex: this.mayoflex ? helpers.includes(this.mayoflex) : false,
+            refinedPalate: false,
+            pinkyRing: this.pinkyRing,
+            tuxedoShirt: this.tuxedoShirt,
+            ...overrideModifiers,
+        };
+        const forkMug = itemType(menuItem.item) === "food"
+            ? this.fork
+            : itemType(menuItem.item) === "booze"
+                ? this.mug
+                : null;
+        const forkMugPrice = forkMug ? forkMug.price() : Infinity;
+        const baseCost = menuItem.price() + sum(helpers, (item) => item.price());
+        const valueRaw = expectedAdventures(menuItem.item, defaultModifiers) * this.mpa -
+            baseCost +
+            (menuItem.additionalValue ?? 0);
+        const valueForkMug = expectedAdventures(menuItem.item, {
+            ...defaultModifiers,
+            forkMug: true,
+        }) *
+            this.mpa -
+            baseCost -
+            forkMugPrice +
+            (menuItem.additionalValue ?? 0);
+        const valueSpleen = $items `jar of fermented pickle juice, extra-greasy slider`.includes(menuItem.item)
+            ? 5 * this.spleenValue
+            : 0;
+        return forkMug && valueForkMug > valueRaw
+            ? [[...helpers, forkMug, menuItem], valueForkMug + valueSpleen]
+            : [[...helpers, menuItem], valueRaw + valueSpleen];
+    }
+    planOrgan(organ, capacity, overrideModifiers = {}) {
+        // print(`Plan ${organ} < ${capacity}`);
+        const submenu = this.menu.filter((item) => item.organ === organ);
+        const knapsackValues = submenu.map((menuItem) => [
+            ...this.consumptionHelpersAndValue(menuItem, overrideModifiers),
+            menuItem.size,
+            menuItem.maximum,
+        ]);
+        return knapsack(knapsackValues, capacity);
+        // print(
+        //   `Items: ${itemList.length} ${([] as Item[])
+        //     .concat(...itemList)
+        //     .map((item) => item.name)
+        //     .join(", ")}`
+        // );
+    }
+    planOrgans(organCapacities, overrideModifiers = {}) {
+        const valuePlans = organCapacities.map(([organ, capacity]) => this.planOrgan(organ, capacity, overrideModifiers));
+        return [
+            sum(valuePlans, ([value]) => value),
+            [].concat(...valuePlans.map(([, plan]) => plan)),
+        ];
+    }
+    planOrgansWithTrials(organCapacities, trialItems, overrideModifiers = {}) {
+        if (trialItems.length === 0) {
+            return this.planOrgans(organCapacities, overrideModifiers);
+        }
+        const organCapacitiesWithMap = new Map(organCapacities);
+        const [trialItem, organSizes] = trialItems[0];
+        // print(`TRYING ${trialItem.item.name}`);
+        for (const [organ, size] of organSizes) {
+            const current = organCapacitiesWithMap.get(organ);
+            if (current !== undefined) {
+                organCapacitiesWithMap.set(organ, current - size);
+            }
+        }
+        const organCapacitiesWith = [...organCapacitiesWithMap];
+        const isRefinedPalate = trialItem.item === $item `pocket wish` &&
+            trialItem.wishEffect === $effect `Refined Palate`;
+        const [valueWithout, planWithout] = this.planOrgansWithTrials(organCapacities, trialItems.slice(1), overrideModifiers);
+        const [valueWith, planWith] = this.planOrgansWithTrials(organCapacitiesWith, trialItems.slice(1), isRefinedPalate
+            ? { ...overrideModifiers, refinedPalate: true }
+            : overrideModifiers);
+        const [helpersAndItem, value] = this.consumptionHelpersAndValue(trialItem, {});
+        // print(
+        //   `${new Array(trialItems.length).join(">")} ${
+        //     valueWithout > valueWith + value ? "WITHOUT" : "WITH"
+        //   } ${trialItem.item} ${trialItem.wishEffect ?? ""} ${value.toFixed(
+        //     0
+        //   )}: ${valueWithout.toFixed(0)} vs. ${(valueWith + value).toFixed(0)}`
+        // );
+        return valueWithout > valueWith + value
+            ? [valueWithout, planWithout]
+            : [valueWith, [...planWith, [helpersAndItem, 1]]];
+    }
+}
+/**
+ * Because the knapsack solver is one-dimensional only, any items that touch
+ * multiple organs have to be treated specially. What we do is run the knapsack
+ * solver multiple times, trying with + without each interacting item.
+ */
+const interactingItems = [
+    [
+        $item `spice melange`,
+        [
+            ["food", -3],
+            ["booze", -3],
+        ],
+    ],
+    [
+        $item `Ultra Mega Sour Ball`,
+        [
+            ["food", -3],
+            ["booze", -3],
+        ],
+    ],
+    [
+        $item `The Plumber's mushroom stew`,
+        [
+            ["food", 3],
+            ["booze", -1],
+        ],
+    ],
+    [
+        $item `The Mad Liquor`,
+        [
+            ["food", -1],
+            ["booze", 3],
+        ],
+    ],
+    [
+        $item `Doc Clock's thyme cocktail`,
+        [
+            ["food", -2],
+            ["booze", 4],
+        ],
+    ],
+    [
+        $item `Mr. Burnsger`,
+        [
+            ["food", 4],
+            ["booze", -2],
+        ],
+    ],
+];
+/**
+ * Plan out an optimal diet using a knapsack algorithm.
+ * @param mpa Meat per adventure value.
+ * @param menu Array of MenuItems to consider for diet purposes.
+ * @param organCapacities Optional override of each organ's capacity.
+ * @returns Array of [menu item and helpers, count].
+ */
+export function planDiet(mpa, menu, organCapacities = [
+    ["food", null],
+    ["booze", null],
+    ["spleen item", null],
+]) {
+    const dietPlanner = new DietPlanner(mpa, menu);
+    // print("MENU:");
+    for (const menuItem of menu) {
+        const [helpers, value] = dietPlanner.consumptionHelpersAndValue(menuItem, {});
+        // print(`${menuItem.item.name}: ${helpers.join(", ")} ${value}`);
+    }
+    const resolvedOrganCapacities = organCapacities.map(([organ, size]) => [
+        organ,
+        size ??
+            (organ === "food"
+                ? fullnessLimit() -
+                    myFullness() +
+                    (have($item `distention pill`) ? 1 : 0)
+                : organ === "booze"
+                    ? inebrietyLimit() + (have($item `synthetic dog hair pill`) ? 1 : 0)
+                    : organ === "spleen item"
+                        ? spleenLimit() - mySpleenUse()
+                        : 0),
+    ]);
+    const allItems = new Map(menu.map((menuItem) => [menuItem.item, menuItem]));
+    const includedInteractingItems = interactingItems
+        .map(([item, sizes]) => [allItems.get(item), sizes])
+        .filter(([menuItem]) => menuItem);
+    // print(
+    //   `included interacting: ${includedInteractingItems
+    //     .map(([menuItem]) => menuItem.item.name)
+    //     .join(", ")}`
+    // );
+    // TODO: support toasted brie.
+    // Refined Palate must also be treated as an interacting item, as it's a one-time cost.
+    const palateWish = menu.find((menuItem) => menuItem.item === $item `pocket wish` &&
+        menuItem.wishEffect === $effect `Refined Palate`);
+    if (palateWish) {
+        includedInteractingItems.push([palateWish, []]);
+    }
+    const [, planFoodBooze] = dietPlanner.planOrgansWithTrials(resolvedOrganCapacities.filter(([organ]) => ["food", "booze"].includes(organ)), includedInteractingItems);
+    // Count sliders and pickle juice, figure out how much extra spleen we got.
+    const additionalSpleen = sum(planFoodBooze, ([items, number]) => items.some((menuItem) => $items `jar of fermented pickle juice, extra-greasy slider`.includes(menuItem.item))
+        ? 5 * number
+        : 0);
+    const [, availableSpleen] = resolvedOrganCapacities.find(([organ]) => organ === "spleen item") ?? ["spleen item", 0];
+    const [, planSpleen] = dietPlanner.planOrgan("spleen item", availableSpleen + additionalSpleen);
+    return [...planFoodBooze, ...planSpleen];
+}

package/dist/diet/knapsack.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Solve the knapsack problem.
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param capacity Capacity of knapsack.
+ * @returns Tuple {[totalValue, items]} of selected items and total value of those items.
+ */
+export declare function knapsack<T>(values: [T, number, number, number?][], capacity: number): [number, [T, number][]];

package/dist/diet/knapsack.js

@@ -0,0 +1,106 @@
+import { sum } from "../utils";
+class Not {
+    constructor(thing) {
+        this.thing = thing;
+    }
+}
+// Assuming list is already sorted, count adjacent items.
+// Effectively run-length encoding.
+function aggregate(list, isEqual) {
+    const aggregatedList = [];
+    for (const item of list) {
+        if (aggregatedList.length === 0) {
+            aggregatedList.push([item, 1]);
+        }
+        else {
+            const last = aggregatedList[aggregatedList.length - 1];
+            const [lastItem] = last;
+            if (isEqual ? isEqual(item, lastItem) : item === lastItem) {
+                last[1]++;
+            }
+            else {
+                aggregatedList.push([item, 1]);
+            }
+        }
+    }
+    return aggregatedList;
+}
+/**
+ * Solve the knapsack problem.
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param capacity Capacity of knapsack.
+ * @returns Tuple {[totalValue, items]} of selected items and total value of those items.
+ */
+export function knapsack(values, capacity) {
+    // Invert negative values into a fake value for not using it.
+    const valuesInverted = values.map(([thing, value, weight, maximum]) => (weight < 0 && maximum
+        ? [new Not(thing), -value, -weight, maximum]
+        : [thing, value, weight, maximum]));
+    const capacityAdjustment = sum(values, ([, , weight, maximum]) => weight < 0 && maximum ? -weight * maximum : 0);
+    const adjustedCapacity = capacity + capacityAdjustment;
+    // Sort values by weight.
+    const valuesSorted = [...valuesInverted].sort((x, y) => x[2] - y[2]);
+    // Convert the problem into 0/1 knapsack - just include as many copies as possible of each item.
+    const values01 = [].concat(...valuesSorted.map(([thing, value, weight, maximum]) => {
+        const maxQuantity = maximum ?? Math.floor(adjustedCapacity / weight);
+        return new Array(maxQuantity).fill([
+            thing,
+            value,
+            weight,
+        ]);
+    }));
+    const memoizationTable = new Array(values01.length);
+    for (let i = 0; i < values01.length; i++) {
+        memoizationTable[i] = new Array(adjustedCapacity).fill(null);
+    }
+    const [value, invertedSolution] = bestSolution(memoizationTable, values01, values01.length - 1, adjustedCapacity);
+    // Still need to replace Not<T>s with right quantity of T's.
+    const aggregatedSolution = aggregate(invertedSolution);
+    const countMap = new Map(aggregatedSolution);
+    let valueAdjustment = 0;
+    const solution = aggregatedSolution.filter(([thingOrNot]) => !(thingOrNot instanceof Not));
+    for (const [thingOrNot, value, , maximum] of valuesSorted) {
+        if (thingOrNot instanceof Not) {
+            const notCount = countMap.get(thingOrNot) ?? 0;
+            if (maximum === undefined) {
+                throw new Error(`Cannot find maximum for item ${thingOrNot.thing}.`);
+            }
+            if (notCount > maximum) {
+                throw new Error(`Somehow picked ${notCount} more than the maximum ${notCount} for item ${thingOrNot.thing}.`);
+            }
+            if (notCount < maximum) {
+                solution.push([thingOrNot.thing, maximum - notCount]);
+            }
+            valueAdjustment -= maximum * value;
+        }
+    }
+    return [value + valueAdjustment, solution];
+}
+/**
+ * Find the best solution to a knapsack subproblem.
+ * @param memoizationTable Memoization table for dynamic programming approach.
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param currentIndex Current index into values array - only add items before this index.
+ * @param remainingCapacity Remaining capacity of knapsack.
+ * @returns
+ */
+function bestSolution(memoizationTable, values, currentIndex, remainingCapacity) {
+    // If we've used all our capacity, this solution is no good.
+    if (remainingCapacity < 0)
+        return [-Infinity, []];
+    if (remainingCapacity === 0 || currentIndex < 0)
+        return [0, []];
+    const memoized = memoizationTable[currentIndex][remainingCapacity - 1];
+    if (memoized !== null)
+        return memoized;
+    const [item, value, weight] = values[currentIndex];
+    const [valueIncludeRest, itemsInclude] = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity - weight);
+    const valueInclude = valueIncludeRest + value;
+    const [valueExclude, itemsExclude] = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity);
+    // Pick the better of the two options between including/excluding.
+    const result = valueInclude > valueExclude
+        ? [valueInclude, [...itemsInclude, item]]
+        : [valueExclude, itemsExclude];
+    memoizationTable[currentIndex][remainingCapacity - 1] = result;
+    return result;
+}

package/dist/dungeons/Dreadsylvania.d.ts

@@ -0,0 +1,4 @@
+export declare function close(): boolean;
+export declare function open(paymentPolicy?: "None" | "All" | "Difference"): boolean;
+export declare function distribute(idOrName?: number | string, loot?: Item | Item[] | Map<Item, number>, distributeAllOfAGivenItem?: boolean): void;
+export declare function findLoot(): Map<Item, number>;

package/dist/dungeons/Dreadsylvania.js

@@ -0,0 +1,14 @@
+import { myId } from "kolmafia";
+import { close as closeDungeon, distribute as distributeDungeon, Dreadsylvania, findLoot as findLootDungeon, open as openDungeon, } from "./Dungeon";
+export function close() {
+    return closeDungeon(Dreadsylvania);
+}
+export function open(paymentPolicy = "Difference") {
+    return openDungeon(Dreadsylvania, paymentPolicy);
+}
+export function distribute(idOrName = myId(), loot = Dreadsylvania.loot, distributeAllOfAGivenItem = true) {
+    distributeDungeon(Dreadsylvania, idOrName, loot, distributeAllOfAGivenItem);
+}
+export function findLoot() {
+    return findLootDungeon(Dreadsylvania);
+}

package/dist/dungeons/Dungeon.d.ts

@@ -0,0 +1,28 @@
+export declare type Dungeon = {
+    name: string;
+    loot: Item[];
+    openAction: string;
+    closeAction: string;
+    openCost: number;
+    openImage: string;
+    closedImage: string;
+};
+/**
+ * Distributes loot from given dungeon
+ * @param dungeon The dungeon to distribute loot from
+ * @param idOrName The player you're trying to distribute to, either as a username or a player ID. Defaults to self.
+ * @param loot The loot you're looking to distribute, specific to this dungeon
+ * @param distributeAllOfAGivenItem For items that you can get multiple of in a dungeon. When true, this will give everything of that ilk to your chosen player.
+ */
+export declare function distribute(dungeon: Dungeon, idOrName?: number | string, loot?: Item | Item[] | Map<Item, number>, distributeAllOfAGivenItem?: boolean): void;
+export declare function close(dungeon: Dungeon): boolean;
+/**
+ * Opens clan dungeon and, if relevant, pays meat to do so
+ * @param dungeon The Dungeon to open
+ * @param paymentPolicy "None", "All", or "Difference". Difference pays into the stash the exact amount needed to open the dungeon.
+ */
+export declare function open(dungeon: Dungeon, paymentPolicy?: "None" | "All" | "Difference"): boolean;
+export declare const Dreadsylvania: Dungeon;
+export declare const Hobopolis: Dungeon;
+export declare const SlimeTube: Dungeon;
+export declare function findLoot(dungeon: Dungeon): Map<Item, number>;