libram 0.4.1 → 0.4.2

package/dist/diet/knapsack.d.ts

@@ -4,4 +4,4 @@
  * @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[]];
+export declare function knapsack<T>(values: [T, number, number, number?][], capacity: number): [number, [T, number][]];

package/dist/diet/knapsack.js

@@ -1,79 +1,80 @@
-"use strict";
-
-require("core-js/modules/es.symbol.js");
-
-require("core-js/modules/es.symbol.description.js");
-
-require("core-js/modules/es.object.to-string.js");
-
-require("core-js/modules/es.array.iterator.js");
-
-require("core-js/modules/es.array.slice.js");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.knapsack = knapsack;
-
-require("core-js/modules/es.array.sort.js");
-
-require("core-js/modules/es.array.concat.js");
-
-require("core-js/modules/es.array.map.js");
-
-require("core-js/modules/es.array.fill.js");
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
+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.
  */
-function knapsack(values, capacity) {
-  var _ref;
-
-  // Sort values by weight.
-  var valuesSorted = _toConsumableArray(values).sort((x, y) => x[2] - y[2]); // Convert the problem into 0/1 knapsack - just include as many copies as possible of each item.
-
-
-  var values01 = (_ref = []).concat.apply(_ref, _toConsumableArray(valuesSorted.map(_ref2 => {
-    var _ref3 = _slicedToArray(_ref2, 4),
-        thing = _ref3[0],
-        value = _ref3[1],
-        weight = _ref3[2],
-        maximum = _ref3[3];
-
-    var maxQuantity = maximum !== null && maximum !== void 0 ? maximum : Math.floor(capacity / weight);
-    return new Array(maxQuantity).fill([thing, value, weight]);
-  })));
-
-  var memoizationTable = new Array(values01.length);
-
-  for (var i = 0; i < values01.length; i++) {
-    memoizationTable[i] = new Array(capacity).fill(null);
-  }
-
-  return bestSolution(memoizationTable, values01, values01.length - 1, capacity);
+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.
@@ -83,34 +84,23 @@ function knapsack(values, capacity) {
  * @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, []];
-  var memoized = memoizationTable[currentIndex][remainingCapacity - 1];
-  if (memoized !== null) return memoized;
-
-  var _values$currentIndex = _slicedToArray(values[currentIndex], 3),
-      item = _values$currentIndex[0],
-      value = _values$currentIndex[1],
-      weight = _values$currentIndex[2];
-
-  var _bestSolution = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity - weight),
-      _bestSolution2 = _slicedToArray(_bestSolution, 2),
-      valueIncludeRest = _bestSolution2[0],
-      itemsInclude = _bestSolution2[1];
-
-  var valueInclude = valueIncludeRest + value;
-
-  var _bestSolution3 = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity),
-      _bestSolution4 = _slicedToArray(_bestSolution3, 2),
-      valueExclude = _bestSolution4[0],
-      itemsExclude = _bestSolution4[1]; // Pick the better of the two options between including/excluding.
-
-
-  var result = valueInclude > valueExclude ? [valueInclude, [].concat(_toConsumableArray(itemsInclude), [item])] : [valueExclude, itemsExclude];
-  memoizationTable[currentIndex][remainingCapacity - 1] = result;
-  return result;
-}
+    // 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>;

package/dist/dungeons/Dungeon.js

@@ -0,0 +1,99 @@
+import { getClanName, myId, toItem, visitUrl, xpath } from "kolmafia";
+import { $items } from "../template-string";
+import { Clan } from "../Clan";
+import { getPlayerFromIdOrName } from "../lib";
+import { countedMapToArray } from "../utils";
+/**
+ * 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 function distribute(dungeon, idOrName = myId(), loot = dungeon.loot, distributeAllOfAGivenItem = true) {
+    const player = getPlayerFromIdOrName(idOrName);
+    const lootList = loot instanceof Map
+        ? countedMapToArray(loot)
+        : Array.isArray(loot)
+            ? loot
+            : [loot];
+    const badLoot = lootList.find((lootItem) => !dungeon.loot.includes(lootItem));
+    if (badLoot) {
+        throw new Error(`${badLoot} is not a valid piece of dungeon loot`);
+    }
+    const pageText = visitUrl("clan_basement.php");
+    if (!pageText.match(new RegExp(player.name, "i"))) {
+        throw new Error(`${player.name} cannot be distributed loot from ${getClanName()}`);
+    }
+    const itemNames = xpath(pageText, "//tr/td[2]/b/text()");
+    const whichLoots = xpath(pageText, '//form[@action="clan_basement.php"]//input[@type="hidden"][@name="whichloot"]/@value');
+    itemNames.forEach((itemName, index) => {
+        if (lootList.includes(toItem(itemName))) {
+            visitUrl(`clan_basement.php?whichloot=${whichLoots[index]}&recipient=${player.id}`);
+            if (!distributeAllOfAGivenItem)
+                lootList.splice(lootList.indexOf(toItem(itemName)));
+        }
+    });
+}
+export function close(dungeon) {
+    visitUrl(`clan_basement.php?action=${dungeon.closeAction}&confirm=true`, true);
+    const pageText = visitUrl("clan_basement.php");
+    return pageText.includes(dungeon.closedImage);
+}
+/**
+ * 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 function open(dungeon, paymentPolicy = "Difference") {
+    const pageText = visitUrl("clan_basement.php");
+    if (pageText.includes(dungeon.openImage))
+        return true;
+    const clan = Clan.get();
+    if (paymentPolicy === "All") {
+        clan.putMeatInCoffer(dungeon.openCost);
+    }
+    else {
+        const stashMeat = clan.getMeatInCoffer();
+        const payDifference = dungeon.openCost - stashMeat;
+        if (payDifference > 0) {
+            if (paymentPolicy === "None")
+                return false;
+            clan.putMeatInCoffer(payDifference);
+        }
+    }
+    visitUrl(`clan_basement.php?action=${dungeon.openAction}`, true);
+    return visitUrl("clan_basement.php").includes(dungeon.openImage);
+}
+/**
+ * Creates dungeon object for managing clan dungeons
+ * @param name Name of the dungeon in question
+ * @param loot Distributable loot dropped by bosses in dungeon
+ * @param openAction String action used in form submission to open dungeon
+ * @param closeAction String action used in form submission to close dungeon
+ * @param openCost Meat cost of opening dungeon
+ * @param openImage Image text to search clan_basement.php for to check if dungeon is open
+ * @param closedImage Image text to search clan_basement.php for to check if dungeon is closed
+ */
+function createDungeon(name, loot, openAction, closeAction, openCost, openImage, closedImage) {
+    return {
+        name: name,
+        loot: loot,
+        openAction: openAction,
+        closeAction: closeAction,
+        openCost: openCost,
+        openImage: openImage,
+        closedImage: closedImage,
+    };
+}
+export const Dreadsylvania = createDungeon("Dreadsylvania", $items `Great Wolf's headband, Great Wolf's right paw, Great Wolf's left paw, Great Wolf's lice, Great Wolf's rocket launcher, Great Wolf's beastly trousers, Drapes-You-Regally, Warms-Your-Tush, Covers-Your-Head, Protects-Your-Junk, Quiets-Your-Steps, Helps-You-Sleep, Mayor Ghost's khakis, Mayor Ghost's cloak, Mayor Ghost's toupee, Mayor Ghost's scissors, Mayor Ghost's sash, Mayor Ghost's gavel, zombie mariachi hat, zombie accordion, zombie mariachi pants, HOA regulation book, HOA zombie eyes, HOA citation pad, Unkillable Skeleton's skullcap, Unkillable Skeleton's shinguards, Unkillable Skeleton's breastplate, Unkillable Skeleton's shield, Unkillable Skeleton's sawsword, Unkillable Skeleton's restless leg, skull capacitor, Thunkula's drinking cap, Drunkula's silky pants, Drunkula's cape, Drunkula's ring of haze, Drunkula's wineglass, Drunkula's bell, bottle of Bloodweiser, bottle of Bloodweiser, bottle of Bloodweiser, bottle of Bloodweiser, electric Kool-Aid, electric Kool-Aid, electric Kool-Aid, electric Kool-Aid, ghost pepper, ghost pepper, ghost pepper, ghost pepper, Gets-You-Drunk, Gets-You-Drunk, Gets-You-Drunk, Gets-You-Drunk, wriggling severed nose, wriggling severed nose, wriggling severed nose, wriggling severed nose, Hunger™ Sauce, Hunger™ Sauce, Hunger™ Sauce, Hunger™ Sauce`, "translatemap", "foldmap", 1000000, "dvmap.gif", "foldmap.gif");
+export const Hobopolis = createDungeon("Hobopolis", $items `Ol' Scratch's ash can, Ol' Scratch's ol' britches, Ol' Scratch's stovepipe hat, Ol' Scratch's infernal pitchfork, Ol' Scratch's manacles, Ol' Scratch's stove door, Frosty's carrot, Frosty's nailbat, Frosty's old silk hat, Frosty's arm, Frosty's iceball, Frosty's snowball sack, Oscus's dumpster waders, Oscus's pelt, Wand of Oscus, Oscus's flypaper pants, Oscus's garbage can lid, Oscus's neverending soda, Zombo's grievous greaves, Zombo's shield, Zombo's skullcap, Zombo's empty eye, Zombo's shoulder blade, Zombo's skull ring, Chester's bag of candy, Chester's cutoffs, Chester's moustache, Chester's Aquarius medallion, Chester's muscle shirt, Chester's sunglasses, Hodgman's bow tie, Hodgman's porkpie hat, Hodgman's lobsterskin pants, Hodgman's almanac, Hodgman's lucky sock, Hodgman's metal detector, Hodgman's varcolac paw, Hodgman's harmonica, Hodgman's garbage sticker, Hodgman's cane, Hodgman's whackin' stick, Hodgman's disgusting technicolor overcoat, Hodgman's imaginary hamster`, "cleansewer", "floodsewer", 1000000, "opengrate.gif", "sewergrate.gif");
+export const SlimeTube = createDungeon("The Slime Tube", $items `slime-soaked brain, slime-soaked hypophysis, slime-soaked sweat gland, squirming Slime larva, caustic slime nodule, caustic slime nodule, hardened slime belt, hardened slime hat, hardened slime pants`, "cleanspot", "sealtube", 250000, "slimehole.gif", "greasespot.gif");
+export function findLoot(dungeon) {
+    const returnValue = new Map();
+    const pageText = visitUrl("clan_basement.php");
+    for (const lootItem of dungeon.loot) {
+        returnValue.set(lootItem, pageText.match(new RegExp(lootItem.name, "g"))?.length ?? 0);
+    }
+    return returnValue;
+}

package/dist/dungeons/Hobopolis.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/Hobopolis.js

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

package/dist/dungeons/SlimeTube.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/SlimeTube.js

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

package/dist/freerun.d.ts

@@ -1,11 +1,23 @@
 import { Macro } from "./combat";
 import { Requirement } from "./maximize";
+export declare type AdventureOptions = {
+    equipmentRequirements?: () => Requirement;
+    preparation?: () => boolean;
+    location?: () => Location;
+    macro?: () => Macro;
+    familiar?: () => Familiar;
+    available?: () => boolean;
+};
+export declare type FreeRunOptions = {
+    equipmentRequirements?: () => Requirement;
+    preparation?: () => boolean;
+    familiar?: () => Familiar;
+};
 export declare class FreeRun {
     name: string;
     available: () => boolean;
     macro: Macro;
-    requirement?: Requirement;
-    prepare?: () => void;
-    constructor(name: string, available: () => boolean, macro: Macro, requirement?: Requirement, prepare?: () => void);
+    options?: FreeRunOptions;
+    constructor(name: string, available: () => boolean, macro: Macro, options?: FreeRunOptions);
 }
-export default function findFreeRun(useFamiliar?: boolean, buyStuff?: boolean): FreeRun | undefined;
+export declare function findFreeRun(useFamiliar?: boolean, buyStuff?: boolean): FreeRun | undefined;