libram 0.8.28 → 0.8.29

package/dist/resources/2023/ClosedCircuitPayphone.d.ts

@@ -0,0 +1,80 @@
+import { Monster, Item, Location } from "kolmafia";
+/**
+ * @returns Whether we currently have the closed-circuit pay phone
+ */
+export declare function have(): boolean;
+/**
+ * @returns Rufus's currently expected quest target, if he has one
+ */
+export declare function rufusTarget(): Monster | Item | string | null;
+declare const INGRESS_RIFTS: {
+    readonly desertbeach: Location;
+    readonly forestvillage: Location;
+    readonly mclargehuge: Location;
+    readonly beanstalk: Location;
+    readonly manor3: Location;
+    readonly "8bit": Location;
+    readonly pyramid: Location;
+    readonly giantcastle: Location;
+    readonly woods: Location;
+    readonly hiddencity: Location;
+    readonly cemetery: Location;
+    readonly plains: Location;
+    readonly town_right: Location;
+};
+export declare type Ingress = "" | keyof typeof INGRESS_RIFTS;
+/**
+ * @returns Your current `shadowRiftIngress`; `null` if none is set this ascension
+ */
+export declare function currentIngress(): Ingress;
+/**
+ * @returns The current shadow rift that Mafia thinks KoL thinks you're in.
+ */
+export declare function currentRift(): Location | null;
+/**
+ * Choose a shadow rift to suit your needs
+ *
+ * @param options An object of various requirements you might have for the rift you want
+ * @param options.canAdventure Set to `true` if you want to only select a rift that you can currently access
+ * @param options.monsters Set to an array of Shadow Monsters you want to be available in the rift
+ * @param options.drops Set to an array of item drops you want to come from monsters in the rift
+ * @param options.otherFilter Set an optional additional filtering function not covered by the above logic
+ * @param options.sortBy Set a function used to compare valid rifts between eachother; bigger numbers are better
+ * @returns A rift that meets the criteria you specify, if one exists
+ */
+export declare function chooseRift(options: {
+    canAdventure?: boolean;
+    monsters?: Monster[];
+    drops?: Item[];
+    otherFilter?: (l: Location) => boolean;
+    sortBy?: (l: Location) => number;
+}): Location | null;
+/**
+ * Choose a quest based on the options available to us
+ *
+ * @param chooser A function that maps quest-options to a choice
+ * @returns Whether we successfully accepted a quest
+ */
+export declare function chooseQuest(chooser: ({ entity, artifact, items, }: {
+    entity: Monster;
+    artifact: Item;
+    items: Item;
+}) => 1 | 2 | 3 | 4): boolean;
+/**
+ * @returns Array containing all shadow rift locations
+ */
+export declare function rifts(): Location[];
+/**
+ * Picks an option based on your current shadow rift ingress
+ *
+ * @param options An object keyed by shadow rift ingress; it must either contain all possible ingresses, or have a `default` parameter.
+ * @returns The option corresponding to your current shadow rift ingress.
+ */
+export declare const byIngress: <S>(options: import("../../utils").Switch<Ingress, S>) => S;
+/**
+ * Submit your Rufus quest
+ *
+ * @returns Whether we successfully submitted your Rufus quest
+ */
+export declare function submitQuest(): boolean;
+export {};

package/dist/resources/2023/ClosedCircuitPayphone.js

@@ -0,0 +1,129 @@
+import { Monster, Item, getMonsters, itemDrops, canAdventure, runChoice, toItem, use, } from "kolmafia";
+import { directlyUse, have as have_, questStep } from "../../lib";
+import { get, withChoice } from "../../property";
+import { $item, $location, $monster } from "../../template-string";
+import { makeByXFunction, maxBy } from "../../utils";
+const item = $item `closed-circuit pay phone`;
+/**
+ * @returns Whether we currently have the closed-circuit pay phone
+ */
+export function have() {
+    return have_(item);
+}
+/**
+ * @returns Rufus's currently expected quest target, if he has one
+ */
+export function rufusTarget() {
+    const target = get("rufusQuestTarget");
+    switch (get("rufusQuestType")) {
+        case "entity":
+            return Monster.get(target);
+        case "artifact":
+        case "items":
+            return Item.get(target);
+        default:
+            return null;
+    }
+}
+const INGRESS_RIFTS = {
+    desertbeach: $location `Shadow Rift (Desert Beach)`,
+    forestvillage: $location `Shadow Rift (Forest Village)`,
+    mclargehuge: $location `Shadow Rift (Mt. McLargeHuge)`,
+    beanstalk: $location `Shadow Rift (Somewhere Over the Beanstalk)`,
+    manor3: $location `Shadow Rift (Spookyraven Manor Third Floor)`,
+    "8bit": $location `Shadow Rift (The 8-Bit Realm)`,
+    pyramid: $location `Shadow Rift (The Ancient Buried Pyramid)`,
+    giantcastle: $location `Shadow Rift (The Castle in the Clouds in the Sky)`,
+    woods: $location `Shadow Rift (The Distant Woods)`,
+    hiddencity: $location `Shadow Rift (The Hidden City)`,
+    cemetery: $location `Shadow Rift (The Misspelled Cemetary)`,
+    plains: $location `Shadow Rift (The Nearby Plains)`,
+    town_right: $location `Shadow Rift (The Right Side of the Tracks)`,
+};
+/**
+ * @returns Your current `shadowRiftIngress`; `null` if none is set this ascension
+ */
+export function currentIngress() {
+    return get("shadowRiftIngress");
+}
+/**
+ * @returns The current shadow rift that Mafia thinks KoL thinks you're in.
+ */
+export function currentRift() {
+    const ingress = currentIngress();
+    return ingress ? INGRESS_RIFTS[ingress] : null;
+}
+const RIFTS = Array.from(Object.values(INGRESS_RIFTS));
+/**
+ * Choose a shadow rift to suit your needs
+ *
+ * @param options An object of various requirements you might have for the rift you want
+ * @param options.canAdventure Set to `true` if you want to only select a rift that you can currently access
+ * @param options.monsters Set to an array of Shadow Monsters you want to be available in the rift
+ * @param options.drops Set to an array of item drops you want to come from monsters in the rift
+ * @param options.otherFilter Set an optional additional filtering function not covered by the above logic
+ * @param options.sortBy Set a function used to compare valid rifts between eachother; bigger numbers are better
+ * @returns A rift that meets the criteria you specify, if one exists
+ */
+export function chooseRift(options) {
+    const filterFunction = (l) => {
+        const monsters = getMonsters(l);
+        if (options.canAdventure && !canAdventure(l))
+            return false;
+        if (options.monsters?.some((m) => !monsters.includes(m)))
+            return false;
+        if (options.drops?.every((i) => !monsters.some((m) => i.name in itemDrops(m))))
+            return false;
+        return options.otherFilter?.(l) ?? true;
+    };
+    const validRifts = [...RIFTS].filter(filterFunction);
+    if (!validRifts.length)
+        return null;
+    return options.sortBy ? maxBy(validRifts, options.sortBy) : validRifts[0];
+}
+/**
+ * Choose a quest based on the options available to us
+ *
+ * @param chooser A function that maps quest-options to a choice
+ * @returns Whether we successfully accepted a quest
+ */
+export function chooseQuest(chooser) {
+    if (get("questRufus") !== "unstarted")
+        return false;
+    if (!have())
+        return false;
+    withChoice(1497, "", () => {
+        directlyUse(item);
+        runChoice(chooser({
+            artifact: toItem(get("rufusDesiredArtifact")),
+            entity: get("rufusDesiredEntity") ?? $monster.none,
+            items: toItem(get("rufusDesiredItems")),
+        }));
+    });
+    return get("questRufus") !== "unstarted";
+}
+/**
+ * @returns Array containing all shadow rift locations
+ */
+export function rifts() {
+    return [...RIFTS];
+}
+/**
+ * Picks an option based on your current shadow rift ingress
+ *
+ * @param options An object keyed by shadow rift ingress; it must either contain all possible ingresses, or have a `default` parameter.
+ * @returns The option corresponding to your current shadow rift ingress.
+ */
+export const byIngress = makeByXFunction(currentIngress);
+/**
+ * Submit your Rufus quest
+ *
+ * @returns Whether we successfully submitted your Rufus quest
+ */
+export function submitQuest() {
+    if (questStep("questRufus") === 1) {
+        withChoice(1498, 1, () => use(item));
+        return questStep("questRufus") === -1;
+    }
+    return false;
+}

package/dist/resources/2023/CursedMonkeyPaw.d.ts

@@ -0,0 +1,46 @@
+import { Item, Location, Effect, Monster } from "kolmafia";
+/**
+ * @returns Whether or not we currently `have` the cursed monkey's paw
+ */
+export declare function have(): boolean;
+/**
+ * @returns The number of monkey paw wishes we have remaining
+ */
+export declare function wishes(): number;
+export declare type WishableItemsFilters = Partial<{
+    location: (location: Location) => boolean;
+    monster: (monster: Monster) => boolean;
+    drop: (itemDrop: {
+        drop: Item;
+        rate: number;
+        type: string;
+    }) => boolean;
+}>;
+/**
+ * @param filters An optional object optionally consisting of filtering functions to shrink down the pool of wishable items
+ * @param filters.location A filtering function to remove locations from the pool of wishable targets.
+ * @param filters.monster A filtering function to remove monsters from the pool of wishable targets.
+ * @param filters.drop A filtering function to remove item drops from the pool of wishable targets.
+ * @returns A set of all items we expect to be able to wish; this doesn't actually constitute all items
+ */
+export declare function wishableItems(filters?: WishableItemsFilters): Set<Item>;
+/**
+ * @returns An Array consisting of all genie-wishable Effects that are not Monkey-wishable
+ */
+export declare function getUnwishableEffects(): Effect[];
+/**
+ * Decides if we expect that a given Item or Effect can be wished for.
+ * May be slow for Effects;
+ *
+ * @param wish The Item or Effect in question
+ * @returns Whether we expect it can be wished for
+ */
+export declare function isWishable(wish: Effect | Item): boolean;
+/**
+ * Wish for a given Item or Effect.
+ * If it's an item, will `prepareForAdventure`; if an item is available in multiple locations this will pick the first one.
+ *
+ * @param wish The Item or Effect to wish for
+ * @returns Whether we succeeded in this endeavor
+ */
+export declare function wishFor(wish: Effect | Item): boolean;

package/dist/resources/2023/CursedMonkeyPaw.js

@@ -0,0 +1,113 @@
+import { Item, Location, canAdventure, getMonsters, itemDropsArray, Effect, toEffect, monkeyPaw, prepareForAdventure, cliExecute, } from "kolmafia";
+import { have as have_ } from "../../lib";
+import logger from "../../logger";
+import { get } from "../../property";
+import { $item } from "../../template-string";
+import { clamp, flat } from "../../utils";
+const item = $item `cursed monkey's paw`;
+/**
+ * @returns Whether or not we currently `have` the cursed monkey's paw
+ */
+export function have() {
+    return have_(item);
+}
+/**
+ * @returns The number of monkey paw wishes we have remaining
+ */
+export function wishes() {
+    return clamp(5 - get("_monkeyPawWishesUsed"), 0, 5);
+}
+/**
+ * @param filters An optional object optionally consisting of filtering functions to shrink down the pool of wishable items
+ * @param filters.location A filtering function to remove locations from the pool of wishable targets.
+ * @param filters.monster A filtering function to remove monsters from the pool of wishable targets.
+ * @param filters.drop A filtering function to remove item drops from the pool of wishable targets.
+ * @returns A set of all items we expect to be able to wish; this doesn't actually constitute all items
+ */
+export function wishableItems(filters = {}) {
+    return new Set(flat(Location.all()
+        .filter((l) => canAdventure(l) && (filters.location?.(l) ?? true))
+        .map((l) => getMonsters(l)
+        .filter((m) => m.copyable && (filters.monster?.(m) ?? true))
+        .map((m) => itemDropsArray(m)
+        .filter(({ type, rate, drop }) => !drop.quest &&
+        (type !== "c" || rate >= 1) && // Remove random roll drops
+        (filters.drop?.({ type, rate, drop }) ?? true))
+        .map(({ drop }) => drop)))));
+}
+const INVALID_CHARACTERS = /[^a-z\d -]/g;
+let _unwishableEffects;
+function unwishableEffects() {
+    // This is the set of all names of genie-wishable effects, split into the maximal substrings we can actually submit
+    const names = Effect.all()
+        .filter((e) => !e.attributes.includes("nohookah"))
+        .map((e) => {
+        const name = e.name.toLowerCase();
+        return { name, splitName: name.split(INVALID_CHARACTERS) };
+    });
+    return names
+        .filter(({ name, splitName }) => 
+    // Any effect that doesn't contain an INVALID_CHARACTER is fine
+    splitName.length > 1 &&
+        // To be unwishable, there can't be any substrings that uniquely match a genie-wishable effect
+        splitName.every((s) => 
+        // So we check every maximal substring against every one of our genie-wishable effects, excluding the effect we're currently looking at
+        // if one of the substrings matches a substring associated with another effect, we're screwed.
+        names.some(({ name: n }) => n !== name && n.includes(s))))
+        .map(({ name }) => toEffect(name));
+}
+/**
+ * @returns An Array consisting of all genie-wishable Effects that are not Monkey-wishable
+ */
+export function getUnwishableEffects() {
+    return (_unwishableEffects ??= unwishableEffects());
+}
+/**
+ * Decides if we expect that a given Item or Effect can be wished for.
+ * May be slow for Effects;
+ *
+ * @param wish The Item or Effect in question
+ * @returns Whether we expect it can be wished for
+ */
+export function isWishable(wish) {
+    if (wish instanceof Item) {
+        return wishableItems().has(wish);
+    }
+    else {
+        if (wish.attributes.includes("nohookah"))
+            return false;
+        if (!wish.name.match(/[.,']/))
+            return true;
+        return !getUnwishableEffects().includes(wish);
+    }
+}
+/**
+ * Wish for a given Item or Effect.
+ * If it's an item, will `prepareForAdventure`; if an item is available in multiple locations this will pick the first one.
+ *
+ * @param wish The Item or Effect to wish for
+ * @returns Whether we succeeded in this endeavor
+ */
+export function wishFor(wish) {
+    if (wishes() <= 0)
+        return false;
+    if (wish instanceof Effect)
+        return monkeyPaw(wish);
+    const locations = Location.all().filter((l) => canAdventure(l) &&
+        getMonsters(l).some((m) => m.copyable && itemDropsArray(m).some(({ drop }) => drop === wish)));
+    try {
+        if (locations.length) {
+            cliExecute("checkpoint");
+            prepareForAdventure(locations[0]);
+        }
+        const result = monkeyPaw(wish);
+        if (!result) {
+            logger.debug(`Failed to monkeyPaw wish for ${wish}; assumed it was available in locations ${locations.join(", ")}`);
+        }
+        return result;
+    }
+    finally {
+        if (locations.length)
+            cliExecute("outfit checkpoint");
+    }
+}

package/dist/resources/2024/AprilingBandHelmet.d.ts

@@ -0,0 +1,57 @@
+import { Effect, Item } from "kolmafia";
+/**
+ * @returns whether you `have` the Apriling band helmet
+ */
+export declare function have(): boolean;
+export declare const MARCHING_SONGS: readonly ["Apriling Band Patrol Beat", "Apriling Band Battle Cadence", "Apriling Band Celebration Bop"];
+export declare type MarchingSong = typeof MARCHING_SONGS[number];
+export declare const MARCHING_SONG_EFFECTS: readonly Effect[];
+export declare const INSTRUMENTS: readonly ["Apriling band saxophone", "Apriling band quad tom", "Apriling band tuba", "Apriling band staff", "Apriling band piccolo"];
+export declare type Instrument = typeof INSTRUMENTS[number];
+export declare const INSTRUMENT_ITEMS: readonly Item[];
+/**
+ * @returns Whether we can currently join a new section of our Apriling band
+ */
+export declare function canJoinSection(): boolean;
+/**
+ * Joins the given section of your Apriling band, returning whether you successfully obtained its instrument
+ *
+ * @param section The section of your band to join--either the instrument's name as a string, or the item itself.
+ *
+ * @returns Whether we have the item, at the end of all things
+ */
+export declare const joinSection: (input: Item | "Apriling band saxophone" | "Apriling band quad tom" | "Apriling band tuba" | "Apriling band staff" | "Apriling band piccolo") => boolean;
+/**
+ * @returns Whether we can currently change the marching song of our Apriling Band
+ */
+export declare function canChangeSong(): boolean;
+/**
+ * Instructs your Apriling band to play the given song, returning whether it's successfully playing
+ *
+ * @param song The song for your band to play--either the effect's name or the effect itself.
+ *
+ * @returns Whether we have the effect, at the end of all things
+ */
+export declare const changeSong: (input: Effect | "Apriling Band Patrol Beat" | "Apriling Band Battle Cadence" | "Apriling Band Celebration Bop") => boolean;
+/**
+ * Conduct your Apriling band helmet
+ *
+ * @param result The instrument (as an item or string) or song (as an effect or string) you want out of this thing
+ * @returns Whether we successfully completed the task
+ */
+export declare function conduct(result: Item | Instrument | Effect | MarchingSong): boolean;
+/**
+ * Plays a given Apriling band instrument
+ *
+ * @param instrument The instrument to play
+ * @param acquire Whether or not we should obtain the instrument if we don't currently have it
+ * @returns Whether we successfully played our instrument
+ */
+export declare function play(instrument: Instrument | Item, acquire?: boolean): boolean;
+/**
+ * Determine whether you can play an instrument
+ * @param instrument The instrument you want to play
+ * @param acquire Whether you're willing to obtain an instrument you don't already have
+ * @returns Whether you can play that instrument
+ */
+export declare function canPlay(instrument: Instrument | Item, acquire?: boolean): boolean;

package/dist/resources/2024/AprilingBandHelmet.js

@@ -0,0 +1,118 @@
+import { Effect, Item, myHash, runChoice, toEffect, toItem, totalTurnsPlayed, visitUrl, } from "kolmafia";
+import { have as have_ } from "../../lib";
+import { get } from "../../property";
+import { $item } from "../../template-string";
+import { arrayContains } from "../../utils";
+const helmet = $item `Apriling band helmet`;
+/**
+ * @returns whether you `have` the Apriling band helmet
+ */
+export function have() {
+    return have_(helmet);
+}
+export const MARCHING_SONGS = Object.freeze([
+    "Apriling Band Patrol Beat",
+    "Apriling Band Battle Cadence",
+    "Apriling Band Celebration Bop",
+]);
+export const MARCHING_SONG_EFFECTS = Object.freeze(MARCHING_SONGS.map((song) => toEffect(song)));
+export const INSTRUMENTS = Object.freeze([
+    "Apriling band saxophone",
+    "Apriling band quad tom",
+    "Apriling band tuba",
+    "Apriling band staff",
+    "Apriling band piccolo",
+]);
+export const INSTRUMENT_ITEMS = Object.freeze(INSTRUMENTS.map((instrument) => toItem(instrument)));
+const visitConduct = () => visitUrl("inventory.php?pwd&action=apriling");
+/**
+ * @returns Whether we can currently join a new section of our Apriling band
+ */
+export function canJoinSection() {
+    return have() && get("_aprilBandInstruments") < 2;
+}
+function makeConductFunction(mafiaClass, canDo, set, offset) {
+    return (input) => {
+        if (!canDo())
+            return false;
+        const [name, instance] = typeof input === "string"
+            ? [input, mafiaClass.get(input)]
+            : [input.name, input];
+        if (have_(instance))
+            return true;
+        const key = set.indexOf(name);
+        if (key === -1)
+            return false;
+        visitConduct();
+        runChoice(key + offset);
+        runChoice(9);
+        return have_(instance);
+    };
+}
+/**
+ * Joins the given section of your Apriling band, returning whether you successfully obtained its instrument
+ *
+ * @param section The section of your band to join--either the instrument's name as a string, or the item itself.
+ *
+ * @returns Whether we have the item, at the end of all things
+ */
+export const joinSection = makeConductFunction(Item, canJoinSection, INSTRUMENTS, 4);
+/**
+ * @returns Whether we can currently change the marching song of our Apriling Band
+ */
+export function canChangeSong() {
+    return have() && get("nextAprilBandTurn") <= totalTurnsPlayed();
+}
+/**
+ * Instructs your Apriling band to play the given song, returning whether it's successfully playing
+ *
+ * @param song The song for your band to play--either the effect's name or the effect itself.
+ *
+ * @returns Whether we have the effect, at the end of all things
+ */
+export const changeSong = makeConductFunction(Effect, canChangeSong, MARCHING_SONGS, 1);
+/**
+ * Conduct your Apriling band helmet
+ *
+ * @param result The instrument (as an item or string) or song (as an effect or string) you want out of this thing
+ * @returns Whether we successfully completed the task
+ */
+export function conduct(result) {
+    if (result instanceof Item || arrayContains(result, INSTRUMENTS)) {
+        return joinSection(result);
+    }
+    return changeSong(result);
+}
+/**
+ * Plays a given Apriling band instrument
+ *
+ * @param instrument The instrument to play
+ * @param acquire Whether or not we should obtain the instrument if we don't currently have it
+ * @returns Whether we successfully played our instrument
+ */
+export function play(instrument, acquire = false) {
+    const item = instrument instanceof Item ? instrument : Item.get(instrument);
+    if (!canPlay(instrument, acquire))
+        return false;
+    if (acquire && !have_(item))
+        joinSection(item);
+    const currentUsesRemaining = item.dailyusesleft;
+    visitUrl(`inventory.php?pwd=${myHash()}&iid=${item.id}&action=aprilplay`, false);
+    return item.dailyusesleft !== currentUsesRemaining;
+}
+/**
+ * Determine whether you can play an instrument
+ * @param instrument The instrument you want to play
+ * @param acquire Whether you're willing to obtain an instrument you don't already have
+ * @returns Whether you can play that instrument
+ */
+export function canPlay(instrument, acquire = false) {
+    if (!have())
+        return false;
+    const item = instrument instanceof Item ? instrument : Item.get(instrument);
+    if (!have_(item) && (!acquire || !canJoinSection()))
+        return false;
+    if (item.dailyusesleft <= 0)
+        return false;
+    return true;
+}

package/dist/resources/2024/ChestMimic.d.ts

@@ -0,0 +1,42 @@
+import { Monster, runCombat } from "kolmafia";
+/**
+ * @returns Whether you `have` the Chest Mimic familiar.
+ */
+export declare function have(): boolean;
+/**
+ * @returns List of monsters available for donation at this time
+ */
+export declare function getDonableMonsters(): Monster[];
+/**
+ * @returns List of monsters available to receive as an egg at this time
+ */
+export declare function getReceivableMonsters(): Monster[];
+/**
+ * Donate an egg to the DNA bank
+ *
+ * @param monster The monster whose egg you want to donate
+ * @returns Whether we succeeded in our endeavor
+ */
+export declare function donate(monster: Monster): boolean;
+/**
+ * Receive an egg from the DNA bank
+ *
+ * @param monster The monster whose egg you want to receive
+ * @returns Whether we succeeded in our endeavor
+ */
+export declare function receive(monster: Monster): boolean;
+/**
+ * Differentiate a Mimic egg into a monster, and fight it!
+ *
+ * @param monster The monster to differentiate your egg into
+ * @param combat Any parameters you'd like to pass to `runCombat`
+ * @returns Whether we successfully differentiated our egg
+ */
+export declare function differentiate(monster: Monster, ...combat: Parameters<typeof runCombat>): boolean;
+/**
+ * Check how many of a monster is available to differentiate into
+ *
+ * @param monster The monster to differentiate your egg into; may behave weirdly with name collisions
+ * @returns How many of a Monster we can differentiate
+ */
+export declare function differentiableQuantity(monster: Monster): number;