libram 0.4.7 → 0.5.1

package/dist/freerun.js

@@ -87,10 +87,13 @@ function cheapestRunSource() {
 }
 function cheapestItemRun() {
     const cheapestRun = cheapestRunSource();
-    return new FreeRun("Cheap Combat Item", () => retrieveItem(cheapestRun), Macro.trySkill($skill `Asdon Martin: Spring-Loaded Front Bumper`).item(cheapestRunSource()), {
+    return new FreeRun("Cheap Combat Item", () => retrieveItem(cheapestRun), Macro.trySkill($skill `Asdon Martin: Spring-Loaded Front Bumper`).item(cheapestRun), {
         preparation: () => retrieveItem(cheapestRun),
     });
 }
-export function findFreeRun(useFamiliar = true, buyStuff = true) {
-    return (freeRuns.find((run) => run.available() && (useFamiliar || run?.options?.familiar)) ?? (buyStuff ? cheapestItemRun() : undefined));
+export function tryFindFreeRun(useFamiliar = true) {
+    return (freeRuns.find((run) => run.available() && (useFamiliar || run?.options?.familiar)) ?? null);
+}
+export function ensureFreeRun(useFamiliar = true) {
+    return tryFindFreeRun(useFamiliar) ?? cheapestItemRun();
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./ascend";
 export * from "./Clan";
 export * from "./combat";
+export * as Counter from "./counter";
 export * from "./diet";
 export * from "./lib";
 export * from "./maximize";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./ascend";
 export * from "./Clan";
 export * from "./combat";
+export * as Counter from "./counter";
 export * from "./diet";
 export * from "./lib";
 export * from "./maximize";

package/dist/lib.d.ts

@@ -1,5 +1,6 @@
 /** @module GeneralLibrary */
 import "core-js/modules/es.object.entries";
+import "core-js/features/array/flat";
 /**
  * Returns the current maximum Accordion Thief songs the player can have in their head
  *

package/dist/lib.js

@@ -1,5 +1,6 @@
 /** @module GeneralLibrary */
 import "core-js/modules/es.object.entries";
+import "core-js/features/array/flat";
 import { appearanceRates, autosellPrice, availableAmount, booleanModifier, cliExecute, fullnessLimit, getCampground, getCounters, getPlayerId, getPlayerName, getRelated, haveEffect, haveFamiliar, haveServant, haveSkill, holiday, inebrietyLimit, mallPrice, myEffects, myFamiliar, myFullness, myInebriety, myPath, mySpleenUse, myThrall, myTurncount, numericModifier, spleenLimit, toItem, toSkill, totalTurnsPlayed, } from "kolmafia";
 import { $class, $familiar, $item, $items, $monsters } from "./template-string";
 import { get } from "./property";
@@ -21,8 +22,14 @@ export function getSongLimit() {
  * @param skillOrEffect The Skill or Effect
  */
 export function isSong(skillOrEffect) {
-    const skill = skillOrEffect instanceof Effect ? toSkill(skillOrEffect) : skillOrEffect;
-    return skill.class === $class `Accordion Thief` && skill.buff;
+    if (skillOrEffect instanceof Effect &&
+        skillOrEffect.attributes.includes("song")) {
+        return true;
+    }
+    else {
+        const skill = skillOrEffect instanceof Effect ? toSkill(skillOrEffect) : skillOrEffect;
+        return skill.class === $class `Accordion Thief` && skill.buff;
+    }
 }
 /**
  * List all active Effects

package/dist/maximize.d.ts

@@ -27,8 +27,9 @@ export declare function setDefaultMaximizeOptions(options: Partial<MaximizeOptio
  * @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 declare function maximizeCached(objectives: string[], options?: Partial<MaximizeOptions>): void;
+export declare function maximizeCached(objectives: string[], options?: Partial<MaximizeOptions>): boolean;
 export declare class Requirement {
     #private;
     /**
@@ -51,8 +52,9 @@ export declare class Requirement {
     static merge(allRequirements: Requirement[]): Requirement;
     /**
      * Runs maximizeCached, using the maximizeParameters and maximizeOptions contained by this requirement.
+     * @returns Whether the maximize call succeeded.
      */
-    maximize(): void;
+    maximize(): boolean;
     /**
      * Merges requirements, and then runs maximizeCached on the combined requirement.
      * @param requirements Requirements to maximize on

package/dist/maximize.js

@@ -2,6 +2,34 @@ import { availableAmount, bjornifyFamiliar, canEquip, cliExecute, enthroneFamili
 import { $familiar, $item, $slot, $slots, $stats } from "./template-string";
 import logger from "./logger";
 import { setEqual } from "./utils";
+/**
+ * Merges a Partial<MaximizeOptions> onto a MaximizeOptions. 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.
+ */
+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 ?? []),
+        ],
+    };
+}
 const defaultMaximizeOptions = {
     updateOnFamiliarChange: true,
     updateOnCanEquipChanged: true,
@@ -149,7 +177,7 @@ function applyCached(entry, options) {
         }
         const familiarEquip = entry.equipment.get($slot `familiar`);
         if (familiarEquip)
-            equip(familiarEquip);
+            equip($slot `familiar`, familiarEquip);
     }
     else {
         for (const [slot, item] of entry.equipment) {
@@ -189,8 +217,11 @@ const slotStructure = [
 function verifyCached(entry) {
     let success = true;
     for (const slotGroup of slotStructure) {
-        const desiredSet = slotGroup.map((slot) => entry.equipment.get(slot) ?? $item `none`);
-        const equippedSet = slotGroup.map((slot) => equippedItem(slot));
+        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)) {
             logger.warning(`Failed to apply cached ${desiredSet.join(", ")} in ${slotGroup.join(", ")}.`);
             success = false;
@@ -272,9 +303,10 @@ function saveCached(cacheKey, options) {
  * @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 = { ...defaultMaximizeOptions, ...options };
+    const fullOptions = mergeMaximizeOptions(defaultMaximizeOptions, options);
     const { forceEquip, preventEquip, bonusEquip, onlySlot, preventSlot, } = fullOptions;
     // Sort each group in objective to ensure consistent ordering in string
     const objective = [
@@ -294,12 +326,13 @@ export function maximizeCached(objectives, options = {}) {
         applyCached(cacheEntry, fullOptions);
         if (verifyCached(cacheEntry)) {
             logger.info(`Equipped cached ${objective}`);
-            return;
+            return true;
         }
         logger.warning("Maximize cache application failed, maximizing...");
     }
-    maximize(objective, false);
+    const result = maximize(objective, false);
     saveCached(objective, fullOptions);
+    return result;
 }
 export class Requirement {
     #maximizeParameters;
@@ -359,9 +392,10 @@ export class Requirement {
     }
     /**
      * Runs maximizeCached, using the maximizeParameters and maximizeOptions contained by this requirement.
+     * @returns Whether the maximize call succeeded.
      */
     maximize() {
-        maximizeCached(this.maximizeParameters, this.maximizeOptions);
+        return maximizeCached(this.maximizeParameters, this.maximizeOptions);
     }
     /**
      * Merges requirements, and then runs maximizeCached on the combined requirement.

package/dist/modifier.d.ts

@@ -11,3 +11,9 @@ export declare type ModifierValue<T> = T extends BooleanModifier ? boolean : T e
 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;

package/dist/modifier.js

@@ -33,3 +33,33 @@ export function get(name, subject) {
         return statModifier(subject, name);
     }
 }
+/**
+ * Merge two Modifiers objects into one, summing all numeric modifiers, ||ing all boolean modifiers, and otherwise letting the second object overwrite the first.
+ * @param modifiers1 Modifiers objects to be merged onto.
+ * @param modifiers2 Modifiers object to merge.
+ * @returns A single Modifiers object obtained by merging.
+ */
+function pairwiseMerge(modifiers1, modifiers2) {
+    const returnValue = { ...modifiers1, ...modifiers2 };
+    for (const modifier in modifiers1) {
+        if (Array.from(Object.values(modifiers2)).includes(modifier)) {
+            if (arrayContains(modifier, numericModifiers)) {
+                returnValue[modifier] =
+                    (modifiers1[modifier] ?? 0) + (modifiers2[modifier] ?? 0);
+            }
+            if (arrayContains(modifier, booleanModifiers)) {
+                returnValue[modifier] =
+                    (modifiers1[modifier] ?? false) || (modifiers2[modifier] ?? false);
+            }
+        }
+    }
+    return returnValue;
+}
+/**
+ * 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 function mergeModifiers(...modifierss) {
+    return modifierss.reduce((a, b) => pairwiseMerge(a, b), {});
+}

package/dist/property.d.ts

@@ -1,6 +1,7 @@
 import "core-js/modules/es.object.entries";
 import "core-js/modules/es.object.from-entries";
 import { KnownProperty, PropertyValue } from "./propertyTyping";
+import { NumericProperty } from "./propertyTypes";
 export declare const getString: (property: string, default_?: string | undefined) => string;
 export declare const getCommaSeparated: (property: string, default_?: string[] | undefined) => string[];
 export declare const getBoolean: (property: string, default_?: boolean | undefined) => boolean;
@@ -45,12 +46,51 @@ export declare function withChoices(choices: {
 }, callback: () => void): void;
 export declare function withChoice(choice: number, value: number | string, callback: () => void): void;
 export declare class PropertiesManager {
-    properties: Properties;
-    constructor();
+    private properties;
+    get storedValues(): Properties;
+    /**
+     * Sets a collection of properties to the given values, storing the old values.
+     * @param propertiesToSet A Properties object, keyed by property name.
+     */
     set(propertiesToSet: Properties): void;
+    /**
+     * Sets a collection of choice adventure properties to the given values, storing the old values.
+     * @param choicesToSet An object keyed by choice adventure number.
+     */
     setChoices(choicesToSet: {
         [choice: number]: number | string;
     }): void;
+    /**
+     * Resets the given properties to their original stored value. Does not delete entries from the manager.
+     * @param properties Collection of properties to reset.
+     */
+    reset(...properties: KnownProperty[]): void;
+    /**
+     * Iterates over all stored values, setting each property back to its original stored value. Does not delete entries from the manager.
+     */
     resetAll(): void;
+    /**
+     * Stops storing the original values of inputted properties.
+     * @param properties Properties for the manager to forget.
+     */
+    clear(...properties: KnownProperty[]): void;
+    /**
+     * Clears all properties.
+     */
+    clearAll(): void;
+    /**
+     * Increases a numeric property to the given value if necessary.
+     * @param property The numeric property we want to potentially raise.
+     * @param value The minimum value we want that property to have.
+     * @returns Whether we needed to change the property.
+     */
+    setMinimumValue(property: NumericProperty, value: number): boolean;
+    /**
+     * Decrease a numeric property to the given value if necessary.
+     * @param property The numeric property we want to potentially lower.
+     * @param value The maximum value we want that property to have.
+     * @returns Whether we needed to change the property.
+     */
+    setMaximumValue(property: NumericProperty, value: number): boolean;
 }
 export {};

package/dist/property.js

@@ -89,10 +89,14 @@ export function withChoice(choice, value, callback) {
     withChoices({ [choice]: value }, callback);
 }
 export class PropertiesManager {
-    properties;
-    constructor() {
-        this.properties = {};
+    properties = {};
+    get storedValues() {
+        return this.properties;
     }
+    /**
+     * Sets a collection of properties to the given values, storing the old values.
+     * @param propertiesToSet A Properties object, keyed by property name.
+     */
     set(propertiesToSet) {
         for (const [propertyName, propertyValue] of Object.entries(propertiesToSet)) {
             if (this.properties[propertyName] === undefined) {
@@ -101,13 +105,75 @@ export class PropertiesManager {
             set(propertyName, propertyValue);
         }
     }
+    /**
+     * Sets a collection of choice adventure properties to the given values, storing the old values.
+     * @param choicesToSet An object keyed by choice adventure number.
+     */
     setChoices(choicesToSet) {
         this.set(Object.fromEntries(Object.entries(choicesToSet).map(([choiceNumber, choiceValue]) => [
             `choiceAdventure${choiceNumber}`,
             choiceValue,
         ])));
     }
+    /**
+     * Resets the given properties to their original stored value. Does not delete entries from the manager.
+     * @param properties Collection of properties to reset.
+     */
+    reset(...properties) {
+        for (const property of properties) {
+            const value = this.properties[property];
+            if (value) {
+                set(property, value);
+            }
+        }
+    }
+    /**
+     * Iterates over all stored values, setting each property back to its original stored value. Does not delete entries from the manager.
+     */
     resetAll() {
         Object.entries(this.properties).forEach(([propertyName, propertyValue]) => set(propertyName, propertyValue));
     }
+    /**
+     * Stops storing the original values of inputted properties.
+     * @param properties Properties for the manager to forget.
+     */
+    clear(...properties) {
+        for (const property of properties) {
+            if (this.properties[property]) {
+                delete this.properties[property];
+            }
+        }
+    }
+    /**
+     * Clears all properties.
+     */
+    clearAll() {
+        this.properties = {};
+    }
+    /**
+     * Increases a numeric property to the given value if necessary.
+     * @param property The numeric property we want to potentially raise.
+     * @param value The minimum value we want that property to have.
+     * @returns Whether we needed to change the property.
+     */
+    setMinimumValue(property, value) {
+        if (get(property) < value) {
+            this.set({ [property]: value });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Decrease a numeric property to the given value if necessary.
+     * @param property The numeric property we want to potentially lower.
+     * @param value The maximum value we want that property to have.
+     * @returns Whether we needed to change the property.
+     */
+    setMaximumValue(property, value) {
+        if (get(property) > value) {
+            this.set({ [property]: value });
+            return true;
+        }
+        return false;
+    }
 }