libram 0.8.28 → 0.8.30

package/dist/resources/2010/CrownOfThrones.js

@@ -0,0 +1,418 @@
+import { Familiar, myFamiliar, numericModifier } from "kolmafia";
+import { have } from "../../lib";
+import { get } from "../../property";
+import { $familiar, $item, $items } from "../../template-string";
+import { sum } from "../../utils";
+export const ridingFamiliars = [
+    {
+        familiar: $familiar `Puck Man`,
+        drops: $items `yellow pixel`,
+        probability: 0.25,
+        dropPredicate: () => get("_yellowPixelDropsCrown") < 25,
+    },
+    {
+        familiar: $familiar `Ms. Puck Man`,
+        drops: $items `yellow pixel`,
+        probability: 0.25,
+        dropPredicate: () => get("_yellowPixelDropsCrown") < 25,
+    },
+    {
+        familiar: $familiar `Grimstone Golem`,
+        drops: $items `grimstone mask`,
+        probability: 0.5,
+        dropPredicate: () => get("_grimstoneMaskDropsCrown") < 1,
+    },
+    {
+        familiar: $familiar `Knob Goblin Organ Grinder`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Happy Medium`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Garbage Fire`,
+        drops: $items `burning newspaper`,
+        probability: 0.5,
+        dropPredicate: () => get("_garbageFireDropsCrown") < 3,
+    },
+    {
+        familiar: $familiar `Machine Elf`,
+        drops: $items `abstraction: sensation, abstraction: thought, abstraction: action, abstraction: category, abstraction: perception, abstraction: purpose`,
+        probability: 0.2,
+        dropPredicate: () => get("_abstractionDropsCrown") < 25,
+    },
+    {
+        familiar: $familiar `Trick-or-Treating Tot`,
+        drops: $items `hoarded candy wad`,
+        probability: 0.5,
+        dropPredicate: () => get("_hoardedCandyDropsCrown") < 3,
+    },
+    {
+        familiar: $familiar `Warbear Drone`,
+        drops: $items `warbear whosit`,
+        probability: 1 / 4.5,
+    },
+    {
+        familiar: $familiar `Li'l Xenomorph`,
+        drops: $items `lunar isotope`,
+        probability: 0.05,
+    },
+    {
+        familiar: $familiar `Pottery Barn Owl`,
+        drops: $items `volcanic ash`,
+        probability: 0.1,
+    },
+    {
+        familiar: $familiar `Grim Brother`,
+        drops: $items `grim fairy tale`,
+        probability: 1,
+        dropPredicate: () => get("_grimFairyTaleDropsCrown") < 2,
+    },
+    {
+        familiar: $familiar `Optimistic Candle`,
+        drops: $items `glob of melted wax`,
+        probability: 1,
+        dropPredicate: () => get("_optimisticCandleDropsCrown") < 3,
+    },
+    {
+        familiar: $familiar `Adventurous Spelunker`,
+        drops: $items `teflon ore, velcro ore, vinyl ore, cardboard ore, styrofoam ore, bubblewrap ore`,
+        probability: 1,
+        dropPredicate: () => get("_oreDropsCrown") < 6,
+    },
+    {
+        familiar: $familiar `Twitching Space Critter`,
+        drops: $items `space beast fur`,
+        probability: 1,
+        dropPredicate: () => get("_spaceFurDropsCrown") < 1,
+    },
+    {
+        familiar: $familiar `Party Mouse`,
+        drops: 50,
+        probability: 0.05,
+    },
+    {
+        familiar: $familiar `Yule Hound`,
+        drops: $items `candy cane`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Gluttonous Green Ghost`,
+        drops: $items `bean burrito, enchanted bean burrito, jumping bean burrito`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Reassembled Blackbird`,
+        drops: $items `blackberry`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Reconstituted Crow`,
+        drops: $items `blackberry`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Hunchbacked Minion`,
+        drops: new Map([
+            [$item `disembodied brain`, 0.02],
+            [$item `skeleton bone`, 0.98],
+        ]),
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Reanimated Reanimator`,
+        drops: $items `hot wing, broken skull`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Attention-Deficit Demon`,
+        drops: $items `chorizo brownies, white chocolate and tomato pizza, carob chunk noodles`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Piano Cat`,
+        drops: $items `beertini, papaya slung, salty slug, tomato daiquiri`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Golden Monkey`,
+        drops: $items `gold nuggets`,
+        probability: 0.5,
+    },
+    {
+        familiar: $familiar `Robot Reindeer`,
+        drops: $items `candy cane, eggnog, fruitcake, gingerbread bugbear`,
+        probability: 0.3,
+    },
+    {
+        familiar: $familiar `Stocking Mimic`,
+        drops: $items `Angry Farmer candy, Cold Hots candy, Rock Pops, Tasty Fun Good rice candy, Wint-O-Fresh mint`,
+        probability: 0.3,
+    },
+    {
+        familiar: $familiar `BRICKO chick`,
+        drops: $items `BRICKO brick`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Cotton Candy Carnie`,
+        drops: $items `cotton candy pinch`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Untamed Turtle`,
+        drops: $items `snailmail bits, turtlemail bits, turtle wax`,
+        probability: 0.35,
+    },
+    {
+        familiar: $familiar `Astral Badger`,
+        drops: $items `spooky mushroom, Knob mushroom, Knoll mushroom`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Green Pixie`,
+        drops: $items `bottle of tequila`,
+        probability: 0.2,
+    },
+    {
+        familiar: $familiar `Angry Goat`,
+        drops: $items `goat cheese pizza`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Adorable Seal Larva`,
+        drops: $items `stench nuggets, spooky nuggets, hot nuggets, cold nuggets, sleaze nuggets`,
+        probability: 0.35,
+    },
+    {
+        familiar: $familiar `Ancient Yuletide Troll`,
+        drops: $items `candy cane, eggnog, fruitcake, gingerbread bugbear`,
+        probability: 0.3,
+    },
+    {
+        familiar: $familiar `Sweet Nutcracker`,
+        drops: $items `candy cane, eggnog, fruitcake, gingerbread bugbear`,
+        probability: 0.3,
+    },
+    {
+        familiar: $familiar `Casagnova Gnome`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Coffee Pixie`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Dancing Frog`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Grouper Groupie`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Hand Turkey`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Hippo Ballerina`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Jitterbug`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Leprechaun`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Obtuse Angel`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Psychedelic Bear`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Robortender`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Ghost of Crimbo Commerce`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Hobo Monkey`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Rockin' Robin`,
+        drops: 60,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Feral Kobold`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Oily Woim`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Cat Burglar`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Misshapen Animal Skeleton`,
+        drops: 30,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Gelatinous Cubeling`,
+        drops: 0,
+        probability: 0,
+    },
+    {
+        familiar: $familiar `Frozen Gravy Fairy`,
+        drops: $items `cold nuggets`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Stinky Gravy Fairy`,
+        drops: $items `stench nuggets`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Sleazy Gravy Fairy`,
+        drops: $items `sleaze nuggets`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Spooky Gravy Fairy`,
+        drops: $items `spooky nuggets`,
+        probability: 1,
+    },
+    {
+        familiar: $familiar `Flaming Gravy Fairy`,
+        // drops a hot nugget every combat, 5 of which can be used to make a hot wad
+        drops: $items `hot nuggets`,
+        probability: 1,
+    },
+];
+const FULL_RIDING_LIST = [
+    ...ridingFamiliars,
+    ...Familiar.all()
+        .filter((f) => !ridingFamiliars.some(({ familiar }) => familiar === f))
+        .map((familiar) => ({ familiar, drops: 0, probability: 1 })),
+];
+/**
+ * Value a specified familiar Crown rider
+ *
+ * @param rider Familiar to value
+ * @param modifierValueFunction Value of the extra modifiers the familiar provides,
+ * @param dropsValueFunction Value to assign the drops of the familiar gives
+ * @param ignoreLimitedDrops Whether to ignore drops that are daily or otherwise limited
+ * @returns Rider value (in meat)
+ */
+export function valueRider(rider, modifierValueFunction, dropsValueFunction, ignoreLimitedDrops = false) {
+    const dropValue = !rider.dropPredicate || (rider.dropPredicate() && !ignoreLimitedDrops)
+        ? rider.probability *
+            (typeof rider.drops === "number"
+                ? rider.drops
+                : dropsValueFunction(rider.drops))
+        : 0;
+    const modifierValue = modifierValueFunction(rider.familiar);
+    return dropValue + modifierValue;
+}
+const riderModes = new Map();
+const DEFAULTS = {
+    modifierValueFunction: () => 0,
+    dropsValueFunction: () => 0,
+    ignoreLimitedDrops: false,
+    excludeCurrentFamiliar: true,
+};
+/**
+ * Creates a rider mode for this session
+ *
+ * @param name Rider mode name
+ * @param details An object consisting of various settings for the RiderMode:
+ * @param details.modifierValueFunction Function to value a familiar itself, often using modifiers,
+ * @param details.dropsValueFunction Function to value the drops of a familiar, which are stored as an `Item[]` or `Map<Item, number>`
+ * @param details.ignoreLimitedDrops Whether to ignore daily or otherwise limited drops
+ * @param details.excludeCurrentFamiliar Whether to exclude the player's current familiar
+ * @returns Map of all rider modes created this session, including the one that was just made
+ */
+export function createRiderMode(name, details) {
+    return riderModes.set(name, { ...DEFAULTS, ...details });
+}
+/**
+ * @param name The name of the `RiderMode` to check
+ * @returns Whether or not said `RiderMode` exists
+ */
+export function hasRiderMode(name) {
+    return riderModes.has(name);
+}
+const riderLists = new Map();
+/**
+ * Pick a rider
+ *
+ * @param mode Mode by which to select possible riders
+ * @returns Picked faimiliar rider or null if no rider could be selected
+ */
+export function pickRider(mode) {
+    const modeData = riderModes.get(mode);
+    if (!modeData)
+        return null;
+    const { modifierValueFunction, dropsValueFunction, ignoreLimitedDrops, excludeCurrentFamiliar, } = modeData;
+    if (!riderLists.has(mode)) {
+        riderLists.set(mode, FULL_RIDING_LIST.filter(({ familiar }) => have(familiar)).sort((a, b) => valueRider(b, modifierValueFunction, dropsValueFunction, ignoreLimitedDrops) -
+            valueRider(a, modifierValueFunction, dropsValueFunction, ignoreLimitedDrops)));
+    }
+    const list = riderLists.get(mode);
+    if (list) {
+        const riderToReturn = list.find(({ dropPredicate, familiar }) => (dropPredicate?.() ?? true) &&
+            (!excludeCurrentFamiliar || myFamiliar() !== familiar));
+        return riderToReturn ?? null;
+    }
+    return null;
+}
+/**
+ * Find the associated NumericModifier for a given familiar when enthroned or bjornified
+ *
+ * @param modifier The NumericModifier in question
+ * @param familiar The Familiar in question
+ * @returns The value of the given numeric modifier for the Crown of Thrones (or buddy bjorn) when the given familiar is encromulated
+ */
+export function getModifier(modifier, familiar) {
+    return numericModifier(`Throne:${familiar}`, modifier);
+}
+/**
+ * Create a `modifierValueFunction` for a familiar.
+ *
+ * @param modifiers An array consisting of the `NumericModifier`s relevant to your valuation
+ * @param functions An object keyed by `NumericModifier`s whose values are functions that map the the result of a modifier to its corresponding valuation
+ * @returns A function that maps a familiar to the value of its modifiers in the crown of thrones or buddy bjorn.
+ */
+export function createModifierValueFunction(modifiers, functions) {
+    return (familiar) => sum(modifiers, (modifier) => functions[modifier](getModifier(modifier, familiar)));
+}

package/dist/resources/2010/LookingGlass.d.ts

@@ -0,0 +1,29 @@
+import { Effect, Item } from "kolmafia";
+/**
+ * Find the name length required to get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to check
+ * @returns The number of characters required to get an effect
+ */
+export declare function findTeaPartyHatLength(effect: Effect): number;
+/**
+ * Find all hats that will get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to check
+ * @returns An array of equippable hats
+ */
+export declare function findTeaPartyHats(effect: Effect): Item[];
+/**
+ * Check if a hat is available to get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to check
+ * @returns If any valid hat is in inventory
+ */
+export declare function haveTeaPartyHat(effect: Effect): boolean;
+/**
+ * Try to get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to get
+ * @returns If the request was successful
+ */
+export declare function tryTeaPartyBuff(effect: Effect): boolean;

package/dist/resources/2010/LookingGlass.js

@@ -0,0 +1,89 @@
+import { canEquip, cliExecute, haveEffect, Item, toSlot, } from "kolmafia";
+import { ensureEffect, have } from "../../lib";
+import { get } from "../../property";
+import { $effect, $slot } from "../../template-string";
+const firstTeaPartyEffect = $effect `Assaulted with Pepper`;
+const lastTeaPartyEffect = $effect `Oleaginous Soles`;
+/**
+ * Checks if an item is a valid hat for The Mad Tea Party
+ *
+ * @param item The item to check
+ * @param characters The desired nameLength for The Mad Tea Party effect
+ * @returns If this item is a valid hat for The Mad Tea Party
+ */
+function validTeaPartyHat(item, characters) {
+    if (toSlot(item) !== $slot `hat` || !canEquip(item)) {
+        return false;
+    }
+    else if (characters <= 5) {
+        return item.nameLength <= 5;
+    }
+    else if (characters >= 30) {
+        return item.nameLength >= 30;
+    }
+    return characters === item.nameLength;
+}
+/**
+ * Find the name length required to get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to check
+ * @returns The number of characters required to get an effect
+ */
+export function findTeaPartyHatLength(effect) {
+    const effectId = effect.id;
+    if (effectId < firstTeaPartyEffect.id || effectId > lastTeaPartyEffect.id) {
+        throw new Error(`Invalid Mad Tea Party effect ${effect}`);
+    }
+    return Math.floor(effectId - firstTeaPartyEffect.id + 5);
+}
+/**
+ * Find all hats that will get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to check
+ * @returns An array of equippable hats
+ */
+export function findTeaPartyHats(effect) {
+    const characters = findTeaPartyHatLength(effect);
+    if (!characters) {
+        throw new Error(`Invalid Mad Tea Party effect ${effect}`);
+    }
+    return Item.all().filter((item) => validTeaPartyHat(item, characters));
+}
+/**
+ * Check if a hat is available to get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to check
+ * @returns If any valid hat is in inventory
+ */
+export function haveTeaPartyHat(effect) {
+    const characters = findTeaPartyHatLength(effect);
+    if (!characters) {
+        throw new Error(`Invalid Mad Tea Party effect ${effect}`);
+    }
+    return (Item.all().find((item) => validTeaPartyHat(item, characters) && have(item)) !== undefined);
+}
+/**
+ * Try to get an effect from The Mad Tea Party
+ *
+ * @param effect The effect to get
+ * @returns If the request was successful
+ */
+export function tryTeaPartyBuff(effect) {
+    if (get("_madTeaParty")) {
+        return false;
+    }
+    const characters = findTeaPartyHatLength(effect);
+    if (!characters) {
+        throw new Error(`Invalid Mad Tea Party effect ${effect}`);
+    }
+    if (!haveTeaPartyHat(effect)) {
+        return false;
+    }
+    ensureEffect($effect `Down the Rabbit Hole`);
+    if (!have($effect `Down the Rabbit Hole`)) {
+        return false;
+    }
+    const turns = haveEffect(effect);
+    cliExecute(`hatter ${characters}`);
+    return have(effect) && haveEffect(effect) > turns;
+}

package/dist/resources/2011/Gygaxian.d.ts

@@ -0,0 +1,9 @@
+import { Item } from "kolmafia";
+/**
+ * @returns true if the player can Summon Dice
+ */
+export declare function have(): boolean;
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export declare function expected(): Map<Item, number>;

package/dist/resources/2011/Gygaxian.js

@@ -0,0 +1,24 @@
+import { have as _have } from "../../lib";
+import { $item, $skill } from "../../template-string";
+const summonSkill = $skill `Summon Dice`;
+const libramChance = 1.0 / 6;
+const libramExpected = new Map([
+    [$item `d4`, libramChance],
+    [$item `d6`, libramChance],
+    [$item `d8`, libramChance],
+    [$item `d10`, libramChance],
+    [$item `d12`, libramChance],
+    [$item `d20`, libramChance],
+]);
+/**
+ * @returns true if the player can Summon Dice
+ */
+export function have() {
+    return _have(summonSkill);
+}
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export function expected() {
+    return libramExpected;
+}

package/dist/resources/2011/ObtuseAngel.d.ts

@@ -0,0 +1,33 @@
+import { Monster } from "kolmafia";
+import { Copier } from "../../Copier";
+/**
+ * @returns whether the player has an Obtuse Angel
+ */
+export declare function have(): boolean;
+/**
+ * @returns number of badly romantic arrows used today
+ */
+export declare function getBadlyRomanticArrowUses(): number;
+/**
+ * @returns whether badly romantic arrow can still be used
+ */
+export declare function haveBadlyRomanticArrowUsesRemaining(): boolean;
+/**
+ * @returns whether the player could use badly romantic arrow in theory
+ */
+export declare function couldUseBadlyRomanticArrow(): boolean;
+/**
+ * Prepares badly romantic arrow for use
+ *
+ * @returns success
+ */
+export declare function prepareBadlyRomanticArrow(): boolean;
+/**
+ * @returns whether the player can use badly romantic arrow right now
+ */
+export declare function canUseBadlyRomanticArrow(): boolean;
+/**
+ * @returns current badly romantic arrow monster target
+ */
+export declare function getBadlyRomanticArrowMonster(): Monster | null;
+export declare const BadlyRomanticArrow: Copier;

package/dist/resources/2011/ObtuseAngel.js

@@ -0,0 +1,51 @@
+import { useFamiliar } from "kolmafia";
+import { Copier } from "../../Copier";
+import { have as _have, isCurrentFamiliar } from "../../lib";
+import { get } from "../../property";
+import { $familiar } from "../../template-string";
+const familiar = $familiar `Obtuse Angel`;
+/**
+ * @returns whether the player has an Obtuse Angel
+ */
+export function have() {
+    return _have(familiar);
+}
+/**
+ * @returns number of badly romantic arrows used today
+ */
+export function getBadlyRomanticArrowUses() {
+    return Math.max(0, get("_badlyRomanticArrows"));
+}
+/**
+ * @returns whether badly romantic arrow can still be used
+ */
+export function haveBadlyRomanticArrowUsesRemaining() {
+    return getBadlyRomanticArrowUses() === 0;
+}
+/**
+ * @returns whether the player could use badly romantic arrow in theory
+ */
+export function couldUseBadlyRomanticArrow() {
+    return have() && haveBadlyRomanticArrowUsesRemaining();
+}
+/**
+ * Prepares badly romantic arrow for use
+ *
+ * @returns success
+ */
+export function prepareBadlyRomanticArrow() {
+    return useFamiliar(familiar);
+}
+/**
+ * @returns whether the player can use badly romantic arrow right now
+ */
+export function canUseBadlyRomanticArrow() {
+    return isCurrentFamiliar(familiar) && haveBadlyRomanticArrowUsesRemaining();
+}
+/**
+ * @returns current badly romantic arrow monster target
+ */
+export function getBadlyRomanticArrowMonster() {
+    return get("romanticTarget");
+}
+export const BadlyRomanticArrow = new Copier(() => couldUseBadlyRomanticArrow(), () => prepareBadlyRomanticArrow(), () => canUseBadlyRomanticArrow(), () => getBadlyRomanticArrowMonster());

package/dist/resources/2011/StompingBoots.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @returns whether the player has the Pair of Stomping Boots in their terrarium
+ */
+export declare function have(): boolean;
+/**
+ * @returns number of free runaways that have already been used today
+ * @see Bandersnatch with which the Stomping Boots shares a counter
+ */
+export declare function getRunaways(): number;
+/**
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns total number of free runaways that the player can get from their Stomping Boots
+ */
+export declare function getMaxRunaways(considerWeightAdjustment?: boolean): number;
+/**
+ * @param considerWeightAdjustment Whether to consider weight adjustment in free run calculation
+ * @returns the number of remaining free runaways the player can get from their Stomping Boots
+ */
+export declare function getRemainingRunaways(considerWeightAdjustment?: boolean): number;
+/**
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns whether the player could use their Stomping Boots to get a free run in theory
+ */
+export declare function couldRunaway(considerWeightAdjustment?: boolean): boolean;
+/**
+ * @returns whether the player can use their Stomping Boots to get a free run right now
+ */
+export declare function canRunaway(): boolean;
+/**
+ * Prepare a Stomping Boots runaway.
+ *
+ * This will take your Stomping Boots with you.
+ * If any of those steps fail, it will return false.
+ *
+ * @returns Success
+ */
+export declare function prepareRunaway(): boolean;