libram 0.4.3 → 0.4.7

package/dist/Clan.js

@@ -9,6 +9,7 @@ import { getFoldGroup } from "./lib";
 import logger from "./logger";
 import { arrayToCountedMap, countedMapToArray, countedMapToString, notNull, parseNumber, } from "./utils";
 export class ClanError extends Error {
+    reason;
     constructor(message, reason) {
         super(message);
         this.reason = reason;
@@ -38,10 +39,8 @@ const toPlayerId = (player) => typeof player === "string" ? getPlayerId(player)
 const LOG_FAX_PATTERN = /(\d{2}\/\d{2}\/\d{2}, \d{2}:\d{2}(?:AM|PM): )<a [^>]+>([^<]+)<\/a>(?: faxed in a (?<monster>.*?))<br>/;
 const WHITELIST_DEGREE_PATTERN = /(?<name>.*?) \(°(?<degree>\d+)\)/;
 export class Clan {
-    constructor(id, name) {
-        this.id = id;
-        this.name = name;
-    }
+    id;
+    name;
     static _join(id) {
         const result = visitUrl(`showclan.php?recruiter=1&whichclan=${id}&pwd&whichclan=${id}&action=joinclan&apply=Apply+to+this+Clan&confirm=on`);
         if (!result.includes("clanhalltop.gif")) {
@@ -143,6 +142,10 @@ export class Clan {
             return new Clan(id, name);
         });
     }
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
     /**
      * Join clan
      */

package/dist/Copier.js

@@ -1,6 +1,10 @@
 export class Copier {
+    couldCopy;
+    prepare;
+    canCopy;
+    copiedMonster;
+    fightCopy = null;
     constructor(couldCopy, prepare, canCopy, copiedMonster, fightCopy) {
-        this.fightCopy = null;
         this.couldCopy = couldCopy;
         this.prepare = prepare;
         this.canCopy = canCopy;

package/dist/Kmail.js

@@ -2,18 +2,12 @@ import "core-js/modules/es.object.entries";
 import { extractItems, extractMeat, isGiftable, toInt, visitUrl, } from "kolmafia";
 import { arrayToCountedMap, chunk } from "./utils";
 export default class Kmail {
-    constructor(rawKmail) {
-        const date = new Date(rawKmail.localtime);
-        // Date come from KoL formatted with YY and so will be parsed 19YY, which is wrong.
-        // We can safely add 100 because if 19YY was a leap year, 20YY will be too!
-        date.setFullYear(date.getFullYear() + 100);
-        this.id = Number(rawKmail.id);
-        this.date = date;
-        this.type = rawKmail.type;
-        this.senderId = Number(rawKmail.fromid);
-        this.senderName = rawKmail.fromname;
-        this.rawMessage = rawKmail.message;
-    }
+    id;
+    date;
+    type;
+    senderId;
+    senderName;
+    rawMessage;
     /**
      * Parses a kmail from KoL's native format
      *
@@ -99,6 +93,18 @@ export default class Kmail {
         const baseUrl = `town_sendgift.php?action=Yep.&pwd&fromwhere=0&note=${message}&insidenote=${insideNote}&towho=${to}`;
         return Kmail._genericSend(to, message, items, meat, 3, (m, itemsQuery, chunkSize) => `${baseUrl}&whichpackage=${chunkSize}${itemsQuery ? `&${itemsQuery}` : ""}&sendmeat=${m}`, ">Package sent.</");
     }
+    constructor(rawKmail) {
+        const date = new Date(rawKmail.localtime);
+        // Date come from KoL formatted with YY and so will be parsed 19YY, which is wrong.
+        // We can safely add 100 because if 19YY was a leap year, 20YY will be too!
+        date.setFullYear(date.getFullYear() + 100);
+        this.id = Number(rawKmail.id);
+        this.date = date;
+        this.type = rawKmail.type;
+        this.senderId = Number(rawKmail.fromid);
+        this.senderName = rawKmail.fromname;
+        this.rawMessage = rawKmail.message;
+    }
     /**
      * Delete the kmail
      *

package/dist/Path.js

@@ -1,5 +1,14 @@
 import { $classes } from "./template-string";
 export class Path {
+    name;
+    id;
+    hasAllPerms; //here, we define avatar-ness around being its own class
+    hasCampground;
+    hasTerrarium;
+    stomachSize;
+    liverSize; //Defined as the lowest inebriety that makes you unable to drink more, just to make it fifteens across the board
+    spleenSize;
+    classes;
     /**
      *
      * @param name Name of path

package/dist/combat.d.ts

@@ -120,9 +120,10 @@ export declare class Macro {
      * Create a new macro with a condition evaluated at the time of building the macro.
      * @param condition The JS condition.
      * @param ifTrue Continuation to add if the condition is true.
+     * @param ifFalse Optional input to turn this into an if...else statement.
      * @returns {Macro} This object itself.
      */
-    static externalIf<T extends Macro>(this: Constructor<T>, condition: boolean, ifTrue: string | Macro): T;
+    static externalIf<T extends Macro>(this: Constructor<T>, condition: boolean, ifTrue: string | Macro, ifFalse?: string | Macro): T;
     /**
      * Add a repeat step to the macro.
      * @returns {Macro} This object itself.
@@ -198,6 +199,26 @@ export declare class Macro {
      * @returns {Macro} This object itself.
      */
     static attack<T extends Macro>(this: Constructor<T>): T;
+    /**
+     * Create an if_ statement based on what holiday of loathing it currently is. On non-holidays, returns the original macro, unmutated.
+     * @param macro The macro to place in the if_ statement
+     */
+    ifHolidayWanderer(macro: Macro): this;
+    /**
+     * Create a new macro starting with an ifHolidayWanderer step.
+     * @param macro The macro to place inside the if_ statement
+     */
+    static ifHolidayWanderer<T extends Macro>(this: Constructor<T>, macro: Macro): T;
+    /**
+     * Create an if_ statement based on what holiday of loathing it currently is. On non-holidays, returns the original macro, with the input macro appended.
+     * @param macro The macro to place in the if_ statement.
+     */
+    ifNotHolidayWanderer(macro: Macro): this;
+    /**
+     * Create a new macro starting with an ifNotHolidayWanderer step.
+     * @param macro The macro to place inside the if_ statement
+     */
+    static ifNotHolidayWanderer<T extends Macro>(this: Constructor<T>, macro: Macro): T;
 }
 /**
  * Adventure in a location and handle all combats with a given macro.

package/dist/combat.js

@@ -1,6 +1,7 @@
 import { adv1, choiceFollowsFight, getAutoAttack, inMultiFight, removeProperty, runCombat, setAutoAttack, toInt, urlEncode, visitUrl, xpath, } from "kolmafia";
 import { $items, $skills } from "./template-string";
 import { get, set } from "./property";
+import { getTodaysHolidayWanderers } from "./lib";
 const MACRO_NAME = "Script Autoattack Macro";
 /**
  * Get the KoL native ID of the macro with name Script Autoattack Macro.
@@ -68,9 +69,10 @@ export class InvalidMacroError extends Error {
  * For example, you can do `Macro.skill('Saucestorm').attack()`.
  */
 export class Macro {
-    constructor() {
-        this.components = [];
-    }
+    static SAVED_MACRO_PROPERTY = "libram_savedMacro";
+    static cachedMacroId = null;
+    static cachedAutoAttack = null;
+    components = [];
     /**
      * Convert macro to string.
      */
@@ -256,10 +258,11 @@ export class Macro {
      * Create a new macro with a condition evaluated at the time of building the macro.
      * @param condition The JS condition.
      * @param ifTrue Continuation to add if the condition is true.
+     * @param ifFalse Optional input to turn this into an if...else statement.
      * @returns {Macro} This object itself.
      */
-    static externalIf(condition, ifTrue) {
-        return new this().externalIf(condition, ifTrue);
+    static externalIf(condition, ifTrue, ifFalse) {
+        return new this().externalIf(condition, ifTrue, ifFalse);
     }
     /**
      * Add a repeat step to the macro.
@@ -372,10 +375,41 @@ export class Macro {
     static attack() {
         return new this().attack();
     }
+    /**
+     * Create an if_ statement based on what holiday of loathing it currently is. On non-holidays, returns the original macro, unmutated.
+     * @param macro The macro to place in the if_ statement
+     */
+    ifHolidayWanderer(macro) {
+        const todaysWanderers = getTodaysHolidayWanderers();
+        if (todaysWanderers.length === 0)
+            return this;
+        return this.if_(todaysWanderers.map((monster) => `monsterid ${monster.id}`).join(" || "), macro);
+    }
+    /**
+     * Create a new macro starting with an ifHolidayWanderer step.
+     * @param macro The macro to place inside the if_ statement
+     */
+    static ifHolidayWanderer(macro) {
+        return new this().ifHolidayWanderer(macro);
+    }
+    /**
+     * Create an if_ statement based on what holiday of loathing it currently is. On non-holidays, returns the original macro, with the input macro appended.
+     * @param macro The macro to place in the if_ statement.
+     */
+    ifNotHolidayWanderer(macro) {
+        const todaysWanderers = getTodaysHolidayWanderers();
+        if (todaysWanderers.length === 0)
+            return this.step(macro);
+        return this.if_(todaysWanderers.map((monster) => `!monsterid ${monster.id}`).join(" && "), macro);
+    }
+    /**
+     * Create a new macro starting with an ifNotHolidayWanderer step.
+     * @param macro The macro to place inside the if_ statement
+     */
+    static ifNotHolidayWanderer(macro) {
+        return new this().ifNotHolidayWanderer(macro);
+    }
 }
-Macro.SAVED_MACRO_PROPERTY = "libram_savedMacro";
-Macro.cachedMacroId = null;
-Macro.cachedAutoAttack = null;
 /**
  * Adventure in a location and handle all combats with a given macro.
  * To use this function you will need to create a consult script that runs Macro.load().submit() and a CCS that calls that consult script.

package/dist/diet/index.d.ts

@@ -13,6 +13,15 @@ export declare class MenuItem {
     additionalValue?: number;
     wishEffect?: Effect;
     static defaultOptions: Map<Item, MenuItemOptions>;
+    /**
+     * Construct a new menu item, possibly with extra properties. Items in MenuItem.defaultOptions have intelligent defaults.
+     * @param item Item to add to menu.
+     * @param options.organ Designate item as belonging to a specific organ.
+     * @param options.size Override item organ size. Necessary for any non-food/booze/spleen item.
+     * @param options.maximum Maximum uses remaining today, or "auto" to check dailyusesleft Mafia property.
+     * @param options.additionalValue Additional value (positive) or cost (negative) to consider with item, e.g. from buffs.
+     * @param options.wishEffect If item is a pocket wish, effect to wish for.
+     */
     constructor(item: Item, options?: MenuItemOptions);
     equals(other: MenuItem): boolean;
     toString(): string;

package/dist/diet/index.js

@@ -1,11 +1,15 @@
-import { fullnessLimit, getWorkshed, inebrietyLimit, itemType, mallPrice, mallPrices, myFullness, myPrimestat, mySpleenUse, npcPrice, spleenLimit, } from "kolmafia";
+import { canEquip, fullnessLimit, getWorkshed, inebrietyLimit, itemType, mallPrice, mallPrices, myFullness, myInebriety, myLevel, myPrimestat, mySpleenUse, npcPrice, spleenLimit, } from "kolmafia";
 import { knapsack } from "./knapsack";
 import { have } from "../lib";
+import { get as getModifier } from "../modifier";
 import { get } from "../property";
 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 isMonday() {
+    // Checking Tuesday's ruby is a hack to see if it's Monday in Arizona.
+    return getModifier("Muscle Percent", $item `Tuesday's ruby`) > 0;
+}
+// TODO: Include Salty Mouth and potentially other modifiers.
 function expectedAdventures(item, modifiers) {
     if (item.adventures === "")
         return 0;
@@ -18,6 +22,7 @@ function expectedAdventures(item, modifiers) {
         (itemType(item) === "booze" && item.notes?.includes("BEER"))
         ? 1.5
         : 1.3;
+    const garish = modifiers.garish && item.notes?.includes("LASAGNA") && !isMonday();
     const refinedPalate = modifiers.refinedPalate && item.notes?.includes("WINE");
     const pinkyRing = modifiers.pinkyRing && item.notes?.includes("WINE");
     return (sum(interpolated, (baseAdventures) => {
@@ -25,6 +30,11 @@ function expectedAdventures(item, modifiers) {
         if (modifiers.forkMug) {
             adventures = Math.floor(adventures * forkMugMultiplier);
         }
+        if (item.notes?.includes("SAUCY") && modifiers.saucemaven) {
+            adventures += myPrimestat() === $stat `Mysticality` ? 5 : 3;
+        }
+        if (garish)
+            adventures += 5;
         if (refinedPalate)
             adventures = Math.floor(adventures * 1.25);
         if (pinkyRing)
@@ -32,17 +42,81 @@ function expectedAdventures(item, modifiers) {
         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++;
+        if (itemType(item) === "food" && modifiers.seasoning)
+            adventures++;
         return adventures;
     }) / interpolated.length);
 }
 export class MenuItem {
+    item;
+    organ;
+    size;
+    maximum;
+    additionalValue;
+    wishEffect;
+    static defaultOptions = new Map([
+        [
+            $item `distention pill`,
+            {
+                organ: "food",
+                maximum: !have($item `distention pill`) || get("_distentionPillUsed") ? 0 : 1,
+                size: -1,
+            },
+        ],
+        [
+            $item `synthetic dog hair pill`,
+            {
+                organ: "booze",
+                maximum: !have($item `synthetic dog hair pill`) ||
+                    get("_syntheticDogHairPillUsed")
+                    ? 0
+                    : 1,
+                size: -1,
+            },
+        ],
+        [
+            $item `cuppa Voraci tea`,
+            { organ: "food", maximum: get("_voraciTeaUsed") ? 0 : 1, size: -1 },
+        ],
+        [
+            $item `cuppa Sobrie tea`,
+            { organ: "booze", maximum: get("_sobrieTeaUsed") ? 0 : 1, size: -1 },
+        ],
+        [
+            $item `mojo filter`,
+            {
+                organ: "spleen item",
+                maximum: 3 - get("currentMojoFilters"),
+                size: -1,
+            },
+        ],
+        [$item `spice melange`, { maximum: get("spiceMelangeUsed") ? 0 : 1 }],
+        [
+            $item `Ultra Mega Sour Ball`,
+            { maximum: get("_ultraMegaSourBallUsed") ? 0 : 1 },
+        ],
+        [
+            $item `The Plumber's mushroom stew`,
+            { maximum: get("_plumbersMushroomStewEaten") ? 0 : 1 },
+        ],
+        [$item `The Mad Liquor`, { maximum: get("_madLiquorDrunk") ? 0 : 1 }],
+        [
+            $item `Doc Clock's thyme cocktail`,
+            { maximum: get("_docClocksThymeCocktailDrunk") ? 0 : 1 },
+        ],
+        [$item `Mr. Burnsger`, { maximum: get("_mrBurnsgerEaten") ? 0 : 1 }],
+    ]);
+    /**
+     * Construct a new menu item, possibly with extra properties. Items in MenuItem.defaultOptions have intelligent defaults.
+     * @param item Item to add to menu.
+     * @param options.organ Designate item as belonging to a specific organ.
+     * @param options.size Override item organ size. Necessary for any non-food/booze/spleen item.
+     * @param options.maximum Maximum uses remaining today, or "auto" to check dailyusesleft Mafia property.
+     * @param options.additionalValue Additional value (positive) or cost (negative) to consider with item, e.g. from buffs.
+     * @param options.wishEffect If item is a pocket wish, effect to wish for.
+     */
     constructor(item, options = {}) {
         const { size, organ, maximum, additionalValue, wishEffect } = {
             ...options,
@@ -74,38 +148,19 @@ export class MenuItem {
         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: 3 - get("currentMojoFilters"),
-            size: -1,
-        },
-    ],
-]);
 const organs = ["food", "booze", "spleen item"];
 function isOrgan(x) {
     return organs.includes(x);
 }
 class DietPlanner {
+    mpa;
+    menu;
+    fork;
+    mug;
+    seasoning;
+    mayoflex;
+    spleenValue = 0;
     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`);
@@ -114,8 +169,6 @@ class DietPlanner {
             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");
@@ -129,9 +182,20 @@ class DietPlanner {
                 this.consumptionValue(spleenItems[0]) / spleenItems[0].item.spleen;
         }
     }
+    /**
+     * Determine the value of consuming a menu item with any profitable helpers.
+     * @param menuItem Menu item to check.
+     * @returns Value for consuming that menu item.
+     */
     consumptionValue(menuItem) {
         return this.consumptionHelpersAndValue(menuItem, {})[1];
     }
+    /**
+     * Determine which helpers will be used with a menu item and its resulting value.
+     * @param menuItem Menu item to check.
+     * @param overrideModifiers Overrides for consumption modifiers, if any.
+     * @returns Pair [array of helpers and base menu item, value].
+     */
     consumptionHelpersAndValue(menuItem, overrideModifiers) {
         const helpers = [];
         if (this.seasoning &&
@@ -148,9 +212,11 @@ class DietPlanner {
             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,
+            refinedPalate: have($effect `Refined Palate`),
+            garish: have($effect `Gar-ish`),
+            saucemaven: have($skill `Saucemaven`),
+            pinkyRing: have($item `mafia pinky ring`) && canEquip($item `mafia pinky ring`),
+            tuxedoShirt: have($item `tuxedo shirt`) && canEquip($item `tuxedo shirt`),
             ...overrideModifiers,
         };
         const forkMug = itemType(menuItem.item) === "food"
@@ -178,8 +244,14 @@ class DietPlanner {
             ? [[...helpers, forkMug, menuItem], valueForkMug + valueSpleen]
             : [[...helpers, menuItem], valueRaw + valueSpleen];
     }
+    /**
+     * Plan an individual organ.
+     * @param capacity Organ capacity.
+     * @param overrideModifiers Overrides for consumption modifiers, if any.
+     * @returns Pair of [value, menu items and quantities].
+     */
     planOrgan(organ, capacity, overrideModifiers = {}) {
-        const submenu = this.menu.filter((item) => item.organ === organ);
+        const submenu = this.menu.filter((menuItem) => menuItem.organ === organ && myLevel() >= menuItem.item.levelreq);
         const knapsackValues = submenu.map((menuItem) => [
             ...this.consumptionHelpersAndValue(menuItem, overrideModifiers),
             menuItem.size,
@@ -187,6 +259,12 @@ class DietPlanner {
         ]);
         return knapsack(knapsackValues, capacity);
     }
+    /**
+     * Plan organs.
+     * @param organCapacities Organ capacities.
+     * @param overrideModifiers Overrides for consumption modifiers, if any.
+     * @returns Pair of [value, menu items and quantities].
+     */
     planOrgans(organCapacities, overrideModifiers = {}) {
         const valuePlans = organCapacities.map(([organ, capacity]) => this.planOrgan(organ, capacity, overrideModifiers));
         return [
@@ -194,12 +272,23 @@ class DietPlanner {
             [].concat(...valuePlans.map(([, plan]) => plan)),
         ];
     }
-    planOrgansWithTrials(organCapacities, trialItems, overrideModifiers = {}) {
+    /**
+     * Plan organs, retrying with and without each trial item. Runtime is
+     * proportional to 2 ^ trialItems.length.
+     * @param organCapacities Organ capacities.
+     * @param trialItems Items to rerun solver with and without.
+     * @param overrideModifiers Overrides for consumption modifiers, if any.
+     * @returns Pair of [value, menu items and quantities].
+     */
+    planOrgansWithTrials(organCapacities, trialItems, overrideModifiers) {
         if (trialItems.length === 0) {
             return this.planOrgans(organCapacities, overrideModifiers);
         }
-        const organCapacitiesWithMap = new Map(organCapacities);
         const [trialItem, organSizes] = trialItems[0];
+        if (trialItem.maximum !== undefined && trialItem.maximum <= 0) {
+            return this.planOrgansWithTrials(organCapacities, trialItems.slice(1), overrideModifiers);
+        }
+        const organCapacitiesWithMap = new Map(organCapacities);
         for (const [organ, size] of organSizes) {
             const current = organCapacitiesWithMap.get(organ);
             if (current !== undefined) {
@@ -207,12 +296,18 @@ class DietPlanner {
             }
         }
         const organCapacitiesWith = [...organCapacitiesWithMap];
-        const isRefinedPalate = trialItem.item === $item `pocket wish` &&
-            trialItem.wishEffect === $effect `Refined Palate`;
+        const isRefinedPalate = (trialItem.item === $item `pocket wish` &&
+            trialItem.wishEffect === $effect `Refined Palate`) ||
+            trialItem.item === $item `toasted brie`;
+        const isGarish = (trialItem.item === $item `pocket wish` &&
+            trialItem.wishEffect === $effect `Gar-ish`) ||
+            trialItem.item === $item `potion of the field gar`;
         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 [valueWith, planWith] = this.planOrgansWithTrials(organCapacitiesWith, trialItems.slice(1), {
+            ...overrideModifiers,
+            ...(isRefinedPalate ? { refinedPalate: true } : {}),
+            ...(isGarish ? { garish: true } : {}),
+        });
         const [helpersAndItem, value] = this.consumptionHelpersAndValue(trialItem, {});
         return valueWithout > valueWith + value
             ? [valueWithout, planWithout]
@@ -267,6 +362,10 @@ const interactingItems = [
             ["booze", -2],
         ],
     ],
+    [$effect `Refined Palate`, []],
+    [$item `toasted brie`, [["food", 2]]],
+    [$effect `Gar-ish`, []],
+    [$item `potion of the field gar`, []],
 ];
 /**
  * Plan out an optimal diet using a knapsack algorithm.
@@ -280,37 +379,58 @@ export function planDiet(mpa, menu, organCapacities = [
     ["booze", null],
     ["spleen item", null],
 ]) {
-    const dietPlanner = new DietPlanner(mpa, menu);
+    // FIXME: Figure out a better way to handle overfull organs (e.g. coming out of Ed).
     const resolvedOrganCapacities = organCapacities.map(([organ, size]) => [
         organ,
         size ??
             (organ === "food"
-                ? fullnessLimit() -
-                    myFullness() +
-                    (have($item `distention pill`) ? 1 : 0)
+                ? fullnessLimit() - myFullness()
                 : organ === "booze"
-                    ? inebrietyLimit() + (have($item `synthetic dog hair pill`) ? 1 : 0)
+                    ? inebrietyLimit() - myInebriety()
                     : 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);
-    // 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, []]);
+    /**
+     * Per above description, separate out items with cross-organ interaction
+     * ("interacting items") for special treatment. These will be checked by
+     * running the solver several times.
+     */
+    const includedInteractingItems = menu
+        .map((menuItem) => {
+        const interacting = interactingItems.find(([itemOrEffect]) => menuItem.item === itemOrEffect ||
+            (menuItem.item === $item `pocket wish` &&
+                menuItem.wishEffect === itemOrEffect));
+        if (interacting) {
+            const [, organSizes] = interacting;
+            return [menuItem, organSizes];
+        }
+        else {
+            return null;
+        }
+    })
+        .filter((value) => value !== null);
+    // Filter out interacting items from natural consideration.
+    const dietPlanner = new DietPlanner(mpa, menu.filter((menuItem) => !includedInteractingItems.some(([interacting]) => interacting === menuItem)));
+    /**
+     * Because our knapsack solver is one-dimensional, we have to consider
+     * each organ separately. Since there are no spleen items that affect
+     * stomach/liver, we consider those two first, with an approximation of the
+     * value of spleen-cleaning. Afterwards, we see how much spleen we have and
+     * plan that.
+     */
+    const [, planFoodBooze] = dietPlanner.planOrgansWithTrials(resolvedOrganCapacities.filter(([organ, capacity]) => ["food", "booze"].includes(organ) && capacity >= 0), includedInteractingItems, {});
+    const spleenCapacity = resolvedOrganCapacities.find(([organ]) => organ === "spleen item");
+    if (spleenCapacity) {
+        // 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] = spleenCapacity;
+        const [, planSpleen] = dietPlanner.planOrgan("spleen item", availableSpleen + additionalSpleen);
+        return [...planFoodBooze, ...planSpleen];
+    }
+    else {
+        return planFoodBooze;
     }
-    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.js

@@ -1,5 +1,6 @@
 import { sum } from "../utils";
 class Not {
+    thing;
     constructor(thing) {
         this.thing = thing;
     }
@@ -32,17 +33,30 @@ function aggregate(list, isEqual) {
  * @returns Tuple {[totalValue, items]} of selected items and total value of those items.
  */
 export function knapsack(values, capacity) {
+    if (!Number.isFinite(capacity)) {
+        throw new Error("Invalid capacity.");
+    }
     // Invert negative values into a fake value for not using it.
-    const valuesInverted = values.map(([thing, value, weight, maximum]) => (weight < 0 && maximum
+    const valuesInverted = values.map(([thing, value, weight, maximum]) => (weight < 0 && maximum !== undefined
         ? [new Not(thing), -value, -weight, maximum]
         : [thing, value, weight, maximum]));
-    const capacityAdjustment = sum(values, ([, , weight, maximum]) => weight < 0 && maximum ? -weight * maximum : 0);
+    const capacityAdjustment = sum(values, ([, , weight, maximum]) => weight < 0 && maximum !== undefined ? -weight * maximum : 0);
     const adjustedCapacity = capacity + capacityAdjustment;
+    if (adjustedCapacity < 0) {
+        // We don't have enough cleaners to create any space, so can't fit anything.
+        return [-Infinity, []];
+    }
     // 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]) => {
+        if (!Number.isFinite(weight) || weight < 0) {
+            throw new Error(`Invalid weight ${weight} for ${thing instanceof Not ? `not ${thing.thing}` : thing}`);
+        }
         const maxQuantity = maximum ?? Math.floor(adjustedCapacity / weight);
+        if (maxQuantity < 0) {
+            throw new Error(`Invalid max quantity ${maxQuantity} for ${thing instanceof Not ? `not ${thing.thing}` : thing}`);
+        }
         return new Array(maxQuantity).fill([
             thing,
             value,