libram 0.8.26 → 0.8.28

package/dist/maximize.js

@@ -1,525 +0,0 @@
-import { availableAmount, bjornifyFamiliar, canEquip, cliExecute, enthroneFamiliar, equip, equippedAmount, equippedItem, getProperty, haveEquipped, isWearingOutfit, Item, maximize, myBasestat, myBjornedFamiliar, myEnthronedFamiliar, myFamiliar, outfit, Slot, } from "kolmafia";
-import { have } from "./lib";
-import logger from "./logger";
-import { $effect, $familiar, $item, $slot, $slots, $stats, } from "./template-string";
-import { setEqual } from "./utils";
-function toMaximizerName({ name, id }) {
-    return name.includes(";") ? `¶${id}` : name;
-}
-/**
- * Merges a partial set of maximizer options onto a full set maximizer options. We merge via overriding for all boolean properties and for onlySlot, and concat all other array properties.
- *
- * @param defaultOptions MaximizeOptions to use as a "base."
- * @param addendums Options to attempt to merge onto defaultOptions.
- * @returns Merged maximizer options
- */
-export function mergeMaximizeOptions(defaultOptions, addendums) {
-    return {
-        updateOnFamiliarChange: addendums.updateOnFamiliarChange ?? defaultOptions.updateOnFamiliarChange,
-        updateOnCanEquipChanged: addendums.updateOnCanEquipChanged ??
-            defaultOptions.updateOnCanEquipChanged,
-        useOutfitCaching: addendums.useOutfitCaching ?? defaultOptions.useOutfitCaching,
-        forceEquip: [...defaultOptions.forceEquip, ...(addendums.forceEquip ?? [])],
-        preventEquip: [
-            ...defaultOptions.preventEquip,
-            ...(addendums.preventEquip ?? []),
-        ].filter((item) => !defaultOptions.forceEquip.includes(item) &&
-            !addendums.forceEquip?.includes(item)),
-        bonusEquip: new Map([
-            ...defaultOptions.bonusEquip,
-            ...(addendums.bonusEquip ?? []),
-        ]),
-        onlySlot: addendums.onlySlot ?? defaultOptions.onlySlot,
-        preventSlot: [
-            ...defaultOptions.preventSlot,
-            ...(addendums.preventSlot ?? []),
-        ],
-        forceUpdate: addendums.forceUpdate ?? defaultOptions.forceUpdate,
-        modes: { ...defaultOptions.modes, ...(addendums.modes ?? {}) },
-    };
-}
-const defaultMaximizeOptions = {
-    updateOnFamiliarChange: true,
-    updateOnCanEquipChanged: true,
-    useOutfitCaching: true,
-    forceEquip: [],
-    preventEquip: [],
-    bonusEquip: new Map(),
-    onlySlot: [],
-    preventSlot: [],
-    forceUpdate: false,
-    modes: {},
-};
-/**
- *
- * @param options Default options for each maximizer run.
- * @param options.updateOnFamiliarChange Re-run the maximizer if familiar has changed. Default true.
- * @param options.updateOnCanEquipChanged Re-run the maximizer if stats have changed what can be equipped. Default true.
- * @param options.forceEquip Equipment to force-equip ("equip X").
- * @param options.preventEquip Equipment to prevent equipping ("-equip X").
- * @param options.bonusEquip Equipment to apply a bonus to ("200 bonus X").
- */
-export function setDefaultMaximizeOptions(options) {
-    Object.assign(defaultMaximizeOptions, options);
-}
-const modeableCommands = [
-    "backupcamera",
-    "umbrella",
-    "snowsuit",
-    "edpiece",
-    "retrocape",
-    "parka",
-    "jillcandle",
-];
-export const modeableItems = {
-    backupcamera: $item `backup camera`,
-    umbrella: $item `unbreakable umbrella`,
-    snowsuit: $item `Snow Suit`,
-    edpiece: $item `The Crown of Ed the Undying`,
-    retrocape: $item `unwrapped knock-off retro superhero cape`,
-    parka: $item `Jurassic Parka`,
-    jillcandle: $item `LED candle`,
-};
-export const modeableState = {
-    backupcamera: () => getProperty("backupCameraMode"),
-    umbrella: () => getProperty("umbrellaState"),
-    snowsuit: () => getProperty("snowsuit"),
-    edpiece: () => getProperty("edPiece"),
-    retrocape: () => getProperty("retroCapeSuperhero") +
-        " " +
-        getProperty("retroCapeWashingInstructions"),
-    parka: () => getProperty("parkaMode"),
-    jillcandle: () => getProperty("ledCandleMode"),
-};
-/**
- * Get set of current modes for modeables
- *
- * @returns Set of modes
- */
-export function getCurrentModes() {
-    const modes = {};
-    for (const key of modeableCommands) {
-        if (haveEquipped(modeableItems[key])) {
-            modes[key] = modeableState[key]();
-        }
-    }
-    return modes;
-}
-/**
- * Apply set of modes
- *
- * @param modes Modes to apply
- */
-export function applyModes(modes) {
-    for (const command of modeableCommands) {
-        if (haveEquipped(modeableItems[command]) && modes[command] !== undefined) {
-            if (modeableState[command]() !== modes[command]) {
-                cliExecute(command + " " + modes[command]);
-            }
-        }
-    }
-}
-// Subset of slots that are valid for caching.
-const cachedSlots = $slots `hat, weapon, off-hand, back, shirt, pants, acc1, acc2, acc3, familiar`;
-class CacheEntry {
-    equipment;
-    rider;
-    familiar;
-    canEquipItemCount;
-    modes;
-    constructor(equipment, rider, familiar, canEquipItemCount, modes) {
-        this.equipment = equipment;
-        this.rider = rider;
-        this.familiar = familiar;
-        this.canEquipItemCount = canEquipItemCount;
-        this.modes = modes;
-    }
-}
-class OutfitLRUCache {
-    static OUTFIT_PREFIX = "Script Outfit";
-    // Current outfits allocated
-    #outfitSlots = [];
-    // Array of indices into #outfitSlots in order of use. Most recent at the front.
-    #useHistory = [];
-    #maxSize;
-    constructor(maxSize) {
-        this.#maxSize = maxSize;
-    }
-    checkConsistent() {
-        if (this.#useHistory.length !== this.#outfitSlots.length ||
-            ![...this.#useHistory].sort().every((value, index) => value === index)) {
-            throw new Error("Outfit cache consistency failed.");
-        }
-    }
-    promote(index) {
-        this.#useHistory = [index, ...this.#useHistory.filter((i) => i !== index)];
-        this.checkConsistent();
-    }
-    get(key) {
-        const index = this.#outfitSlots.indexOf(key);
-        if (index < 0)
-            return undefined;
-        this.promote(index);
-        return `${OutfitLRUCache.OUTFIT_PREFIX} ${index}`;
-    }
-    insert(key) {
-        let lastUseIndex = undefined;
-        if (this.#outfitSlots.length >= this.#maxSize) {
-            lastUseIndex = this.#useHistory.pop();
-            if (lastUseIndex === undefined) {
-                throw new Error("Outfit cache consistency failed.");
-            }
-            this.#useHistory.splice(0, 0, lastUseIndex);
-            this.#outfitSlots[lastUseIndex] = key;
-            this.checkConsistent();
-            return `${OutfitLRUCache.OUTFIT_PREFIX} ${lastUseIndex}`;
-        }
-        else {
-            const index = this.#outfitSlots.push(key) - 1;
-            this.#useHistory.splice(0, 0, index);
-            this.checkConsistent();
-            return `${OutfitLRUCache.OUTFIT_PREFIX} ${index}`;
-        }
-    }
-    clear() {
-        this.#outfitSlots = [];
-        this.#useHistory = [];
-    }
-}
-/**
- * Save current equipment as KoL-native outfit.
- *
- * @param name Name of new outfit.
- */
-function saveOutfit(name) {
-    cliExecute(`outfit save ${name}`);
-}
-// Objective cache entries.
-const cachedObjectives = {};
-// Outfit cache entries. Keep 6 by default to avoid cluttering list.
-const outfitCache = new OutfitLRUCache(6);
-// Cache to prevent rescanning all items unnecessarily
-let cachedStats = [0, 0, 0];
-let cachedCanEquipItemCount = 0;
-/**
- * Count the number of unique items that can be equipped.
- *
- * @returns The count of unique items.
- */
-function canEquipItemCount() {
-    const stats = $stats `Muscle, Mysticality, Moxie`.map((stat) => Math.min(myBasestat(stat), 300));
-    if (stats.every((value, index) => value === cachedStats[index])) {
-        return cachedCanEquipItemCount;
-    }
-    cachedStats = stats;
-    cachedCanEquipItemCount = Item.all().filter((item) => canEquip(item)).length;
-    return cachedCanEquipItemCount;
-}
-/**
- * Checks the objective cache for a valid entry.
- *
- * @param cacheKey The cache key to check.
- * @param options Set of maximizer options
- * @returns A valid CacheEntry or null.
- */
-function checkCache(cacheKey, options) {
-    const entry = cachedObjectives[cacheKey];
-    if (!entry) {
-        return null;
-    }
-    if (options.updateOnFamiliarChange && myFamiliar() !== entry.familiar) {
-        logger.warning("Equipment found in maximize cache but familiar is different.");
-        return null;
-    }
-    if (options.updateOnCanEquipChanged &&
-        entry.canEquipItemCount !== canEquipItemCount()) {
-        logger.warning("Equipment found in maximize cache but equippable item list is out of date.");
-        return null;
-    }
-    return entry;
-}
-/**
- * Applies equipment that was found in the cache.
- *
- * @param entry The CacheEntry to apply
- * @param options Set of maximizer options
- */
-function applyCached(entry, options) {
-    const outfitName = options.useOutfitCaching
-        ? outfitCache.get(entry)
-        : undefined;
-    if (outfitName) {
-        if (!isWearingOutfit(outfitName)) {
-            outfit(outfitName);
-        }
-        const familiarEquip = entry.equipment.get($slot `familiar`);
-        if (familiarEquip)
-            equip($slot `familiar`, familiarEquip);
-    }
-    else {
-        for (const [slot, item] of entry.equipment) {
-            if (equippedItem(slot) !== item && availableAmount(item) > 0) {
-                equip(slot, item);
-            }
-        }
-        if (verifyCached(entry) && options.useOutfitCaching) {
-            const outfitName = outfitCache.insert(entry);
-            logger.info(`Saving equipment to outfit ${outfitName}.`);
-            saveOutfit(outfitName);
-        }
-    }
-    if (equippedAmount($item `Crown of Thrones`) > 0 &&
-        entry.rider.get($item `Crown of Thrones`)) {
-        enthroneFamiliar(entry.rider.get($item `Crown of Thrones`) || $familiar.none);
-    }
-    if (equippedAmount($item `Buddy Bjorn`) > 0 &&
-        entry.rider.get($item `Buddy Bjorn`)) {
-        bjornifyFamiliar(entry.rider.get($item `Buddy Bjorn`) || $familiar.none);
-    }
-    applyModes({ ...entry.modes, ...options.modes });
-}
-const slotStructure = [
-    $slots `hat`,
-    $slots `back`,
-    $slots `shirt`,
-    $slots `weapon, off-hand`,
-    $slots `pants`,
-    $slots `acc1, acc2, acc3`,
-    $slots `familiar`,
-];
-/**
- * Verifies that a CacheEntry was applied successfully.
- *
- * @param entry The CacheEntry to verify
- * @param warn Whether to warn if the cache could not be applied
- * @returns If all desired equipment was appliedn in the correct slots.
- */
-function verifyCached(entry, warn = true) {
-    let success = true;
-    for (const slotGroup of slotStructure) {
-        const desiredSlots = slotGroup
-            .map((slot) => [slot, entry.equipment.get(slot) ?? null])
-            .filter(([, item]) => item !== null);
-        const desiredSet = desiredSlots.map(([, item]) => item);
-        const equippedSet = desiredSlots.map(([slot]) => equippedItem(slot));
-        if (!setEqual(desiredSet, equippedSet)) {
-            if (warn) {
-                logger.warning(`Failed to apply cached ${desiredSet.join(", ")} in ${slotGroup.join(", ")}.`);
-            }
-            success = false;
-        }
-    }
-    if (equippedAmount($item `Crown of Thrones`) > 0 &&
-        entry.rider.get($item `Crown of Thrones`)) {
-        if (entry.rider.get($item `Crown of Thrones`) !== myEnthronedFamiliar()) {
-            if (warn) {
-                logger.warning(`Failed to apply ${entry.rider.get($item `Crown of Thrones`)} in ${$item `Crown of Thrones`}.`);
-            }
-            success = false;
-        }
-    }
-    if (equippedAmount($item `Buddy Bjorn`) > 0 &&
-        entry.rider.get($item `Buddy Bjorn`)) {
-        if (entry.rider.get($item `Buddy Bjorn`) !== myBjornedFamiliar()) {
-            if (warn) {
-                logger.warning(`Failed to apply${entry.rider.get($item `Buddy Bjorn`)} in ${$item `Buddy Bjorn`}.`);
-            }
-            success = false;
-        }
-    }
-    return success;
-}
-/**
- * Save current equipment to the objective cache.
- *
- * @param cacheKey The cache key to save.
- * @param options Set of maximizer options
- */
-function saveCached(cacheKey, options) {
-    const equipment = new Map();
-    const rider = new Map();
-    for (const slot of cachedSlots) {
-        equipment.set(slot, equippedItem(slot));
-    }
-    if (equippedAmount($item `card sleeve`) > 0) {
-        equipment.set($slot `card-sleeve`, equippedItem($slot `card-sleeve`));
-    }
-    if (equippedAmount($item `Crown of Thrones`) > 0) {
-        rider.set($item `Crown of Thrones`, myEnthronedFamiliar());
-    }
-    if (equippedAmount($item `Buddy Bjorn`) > 0) {
-        rider.set($item `Buddy Bjorn`, myBjornedFamiliar());
-    }
-    if (options.preventSlot && options.preventSlot.length > 0) {
-        for (const slot of options.preventSlot) {
-            equipment.delete(slot);
-        }
-        if (options.preventSlot.includes($slot `buddy-bjorn`)) {
-            rider.delete($item `Buddy Bjorn`);
-        }
-        if (options.preventSlot.includes($slot `crown-of-thrones`)) {
-            rider.delete($item `Crown of Thrones`);
-        }
-    }
-    if (options.onlySlot && options.onlySlot.length > 0) {
-        for (const slot of Slot.all()) {
-            if (!options.onlySlot.includes(slot)) {
-                equipment.delete(slot);
-            }
-        }
-        if (!options.onlySlot.includes($slot `buddy-bjorn`)) {
-            rider.delete($item `Buddy Bjorn`);
-        }
-        if (!options.onlySlot.includes($slot `crown-of-thrones`)) {
-            rider.delete($item `Crown of Thrones`);
-        }
-    }
-    const entry = new CacheEntry(equipment, rider, myFamiliar(), canEquipItemCount(), { ...getCurrentModes(), ...options.modes });
-    cachedObjectives[cacheKey] = entry;
-    if (options.useOutfitCaching) {
-        const outfitName = outfitCache.insert(entry);
-        logger.info(`Saving equipment to outfit ${outfitName}.`);
-        saveOutfit(outfitName);
-    }
-}
-/**
- * Run the maximizer, but only if the objective and certain pieces of game state haven't changed since it was last run.
- *
- * @param objectives Objectives to maximize for.
- * @param options Options for this run of the maximizer.
- * @param options.updateOnFamiliarChange Re-run the maximizer if familiar has changed. Default true.
- * @param options.updateOnCanEquipChanged Re-run the maximizer if stats have changed what can be equipped. Default true.
- * @param options.forceEquip Equipment to force-equip ("equip X").
- * @param options.preventEquip Equipment to prevent equipping ("-equip X").
- * @param options.bonusEquip Equipment to apply a bonus to ("200 bonus X").
- * @returns Whether the maximize call succeeded.
- */
-export function maximizeCached(objectives, options = {}) {
-    const fullOptions = mergeMaximizeOptions(defaultMaximizeOptions, options);
-    const { forceEquip, preventEquip, bonusEquip, onlySlot, preventSlot, forceUpdate, } = fullOptions;
-    // Sort each group in objective to ensure consistent ordering in string
-    const objective = [
-        ...new Set([
-            ...objectives.sort(),
-            ...forceEquip.map((item) => `"equip ${toMaximizerName(item)}"`).sort(),
-            ...preventEquip.map((item) => `-"equip ${toMaximizerName(item)}"`).sort(),
-            ...onlySlot.map((slot) => `${slot}`).sort(),
-            ...preventSlot.map((slot) => `-${slot}`).sort(),
-            ...Array.from(bonusEquip.entries())
-                .filter(([, bonus]) => bonus !== 0)
-                .map(([item, bonus]) => `${Math.round(bonus * 100) / 100} "bonus ${toMaximizerName(item)}"`)
-                .sort(),
-        ]),
-    ].join(", ");
-    // Items equipped in slots not touched by the maximizer must be in the cache key
-    const untouchedSlots = cachedSlots.filter((slot) => preventSlot.includes(slot) ||
-        (onlySlot.length > 0 && !onlySlot.includes(slot)));
-    const cacheKey = [
-        objective,
-        ...untouchedSlots
-            .map((slot) => `${slot}:${equippedItem(slot)}`)
-            .sort(),
-        have($effect `Offhand Remarkable`),
-    ].join("; ");
-    const cacheEntry = checkCache(cacheKey, fullOptions);
-    if (cacheEntry && !forceUpdate) {
-        if (verifyCached(cacheEntry, false))
-            return true;
-        logger.info("Equipment found in maximize cache, equipping...");
-        applyCached(cacheEntry, fullOptions);
-        if (verifyCached(cacheEntry)) {
-            logger.info(`Equipped cached ${cacheKey}`);
-            return true;
-        }
-        logger.warning("Maximize cache application failed, maximizing...");
-    }
-    const result = maximize(objective, false);
-    saveCached(cacheKey, fullOptions);
-    return result;
-}
-export class Requirement {
-    #maximizeParameters;
-    #maximizeOptions;
-    /**
-     * A convenient way of combining maximization parameters and options
-     *
-     * @param maximizeParameters Parameters you're attempting to maximize
-     * @param maximizeOptions Object potentially containing forceEquips, bonusEquips, preventEquips, and preventSlots
-     */
-    constructor(maximizeParameters, maximizeOptions) {
-        this.#maximizeParameters = maximizeParameters;
-        this.#maximizeOptions = maximizeOptions;
-    }
-    get maximizeParameters() {
-        return this.#maximizeParameters;
-    }
-    get maximizeOptions() {
-        return this.#maximizeOptions;
-    }
-    /**
-     * Merges two requirements, concanating relevant arrays. Typically used in static form.
-     *
-     * @param other Requirement to merge with.
-     */
-    merge(other) {
-        const optionsA = this.maximizeOptions;
-        const optionsB = other.maximizeOptions;
-        return new Requirement([...this.maximizeParameters, ...other.maximizeParameters], {
-            updateOnFamiliarChange: optionsA.updateOnFamiliarChange ||
-                other.maximizeOptions.updateOnFamiliarChange,
-            updateOnCanEquipChanged: optionsA.updateOnCanEquipChanged ||
-                other.maximizeOptions.updateOnCanEquipChanged,
-            forceEquip: [
-                ...(optionsA.forceEquip ?? []),
-                ...(other.maximizeOptions.forceEquip ?? []),
-            ].filter((x) => !other.maximizeOptions.preventEquip?.includes(x)),
-            preventEquip: [
-                ...(optionsA.preventEquip ?? []),
-                ...(other.maximizeOptions.preventEquip ?? []),
-            ].filter((x) => !other.maximizeOptions.forceEquip?.includes(x)),
-            bonusEquip: new Map([
-                ...(optionsA.bonusEquip?.entries() ?? []),
-                ...(optionsB.bonusEquip?.entries() ?? []),
-            ]),
-            onlySlot: [...(optionsA.onlySlot ?? []), ...(optionsB.onlySlot ?? [])],
-            preventSlot: [
-                ...(optionsA.preventSlot ?? []),
-                ...(optionsB.preventSlot ?? []),
-            ],
-            forceUpdate: optionsA.forceUpdate || optionsB.forceUpdate,
-        });
-    }
-    /**
-     * Merges a set of requirements together, starting with an empty requirement.
-     *
-     * @param allRequirements Requirements to merge
-     * @returns Merged requirements
-     */
-    static merge(allRequirements) {
-        return allRequirements.reduce((x, y) => x.merge(y), new Requirement([], {}));
-    }
-    /**
-     * Runs maximizeCached, using the maximizeParameters and maximizeOptions contained by this requirement.
-     *
-     * @returns Whether the maximize call succeeded.
-     */
-    maximize() {
-        return maximizeCached(this.maximizeParameters, this.maximizeOptions);
-    }
-    /**
-     * Merges requirements, and then runs maximizeCached on the combined requirement.
-     *
-     * @param requirements Requirements to maximize on
-     */
-    static maximize(...requirements) {
-        Requirement.merge(requirements).maximize();
-    }
-}
-/**
- * Clear all outfits cached by the maximizer.
- */
-export function clearMaximizerCache() {
-    outfitCache.clear();
-    for (const member in cachedObjectives)
-        delete cachedObjectives[member];
-}

package/dist/modifier.d.ts

@@ -1,41 +0,0 @@
-import { Class, Effect, Familiar, Item, Monster, Skill, Stat } from "kolmafia";
-import { BooleanModifier, ClassModifier, EffectModifier, MonsterModifier, NumericModifier, SkillModifier, StatModifier, StringModifier } from "./modifierTypes";
-export declare function get(name: BooleanModifier, subject?: string | Item | Effect): boolean;
-export declare function get(name: ClassModifier, subject: string | Item): Class;
-export declare function get(name: EffectModifier, subject: string | Item): Effect;
-export declare function get(name: MonsterModifier, subject: Effect): Monster;
-export declare function get(name: NumericModifier, subject?: string | Item | Effect | Skill | Familiar): number;
-export declare function get(name: SkillModifier, subject: string | Item): Skill;
-export declare function get(name: StringModifier, subject?: string | Effect | Item): string;
-export declare function get(name: StatModifier, subject: Effect): Stat;
-export declare type ModifierValue<T> = T extends BooleanModifier ? boolean : T extends ClassModifier ? Class : T extends EffectModifier ? Effect : T extends MonsterModifier ? Monster : T extends NumericModifier ? number : T extends SkillModifier ? Skill : T extends StatModifier ? Stat : T extends StringModifier ? string : string;
-export declare type Modifiers = Partial<{
-    [T in BooleanModifier | ClassModifier | EffectModifier | MonsterModifier | NumericModifier | SkillModifier | StatModifier | StringModifier]: ModifierValue<T>;
-}>;
-/**
- * Merge arbitrarily many Modifiers objects into one, summing all numeric modifiers, and ||ing all boolean modifiers.
- *
- * @param modifierss Modifiers objects to be merged together.
- * @returns A single Modifiers object obtained by merging.
- */
-export declare function mergeModifiers(...modifierss: Modifiers[]): Modifiers;
-/**
- * Prints the modtrace to the log.
- * Example: printModtrace("Meat Drop") or printModtrace(["Item Drop", "Booze Drop"])
- *
- * @param inputModifiers A string (or string[]) containing the modtrace lookup term(s).
- * @param baseModifier A string where all the info about modifiers in the string[] array can be grabbed with this one lookup term. (Automatically generated in most cases)
- * @param componentColor The print color for the sum returned for each input modifier
- * @param totalColor The print color for the total sum over every input modifier
- * @returns void
- */
-export declare function printModtrace(inputModifiers: string | string[], // the user's list of modifiers to look up
-baseModifier?: string, componentColor?: string, totalColor?: string): void;
-/**
- * Take the sum of a modifier over an array of Skills, Effects, and Items
- *
- * @param modifier A NumericModifier that we want to find the total value of
- * @param subjects A rested array of Skills, Effects, and Items that we want to find the total value of
- * @returns The sum of the appropriate modifier for all of the subjects
- */
-export declare function getTotalModifier(modifier: NumericModifier, ...subjects: (Skill | Effect | Item)[]): number;