libram 0.9.4 → 0.9.6

package/dist/Macro.test.js

@@ -16,7 +16,7 @@ describe(Macro, () => {
         expect(Macro.if_("mock", Macro.abort()).toString()).toEqual(`if mock;abort;endif;`);
     });
     it("ifNot", () => {
-        expect(Macro.ifNot("mock", Macro.abort()).toString()).toEqual(`if !(mock);abort;endif;`);
+        expect(Macro.ifNot("mock", Macro.abort()).toString()).toEqual(`if !mock;abort;endif;`);
     });
     it("while_", () => {
         expect(Macro.while_("mock", Macro.abort()).toString()).toEqual(`while mock;abort;endwhile;`);

package/dist/actions/ActionSource.js

@@ -1,7 +1,7 @@
 import { mallPrice, useFamiliar } from "kolmafia";
 import { Macro } from "../combat.js";
 import { Requirement } from "../maximize.js";
-import { sum, flat } from "../utils.js";
+import { sum } from "../utils.js";
 /**
  * Merge a set of constraints into one
  *
@@ -97,7 +97,7 @@ export class ActionSource {
             // Inconsistent constraints - no path forward here.
             return null;
         }
-        return new ActionSource([...flat(actions.map((action) => action.source))], () => sum(actions, (action) => action.potential()), Macro.step(...actions.map((action) => action.macro)), constraints);
+        return new ActionSource(actions.flatMap((action) => action.source), () => sum(actions, (action) => action.potential()), Macro.step(...actions.map((action) => action.macro)), constraints);
     }
     /**
      * Perform all preparation necessary to make this action available.

package/dist/challengePaths/2015/CommunityService.js

@@ -1,5 +1,5 @@
-import { equippedItem, familiarWeight, getPower, haveEquipped, myAdventures, myBasestat, myBuffedstat, myFamiliar, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, weightAdjustment, } from "kolmafia";
-import { have } from "../../lib.js";
+import { equippedItem, getPower, haveEquipped, myAdventures, myBasestat, myBuffedstat, myFamiliar, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, } from "kolmafia";
+import { have, totalFamiliarWeight } from "../../lib.js";
 import { Requirement } from "../../maximize.js";
 import { get } from "../../property.js";
 import { MummingTrunk } from "../../resources/index.js";
@@ -18,7 +18,6 @@ const statCommunityServicePredictor = (stat) => {
                     : stat)));
 };
 const visitCouncil = () => visitUrl("council.php");
-const baseWeight = () => have($effect `Fidoxene`) ? 20 : familiarWeight(myFamiliar());
 function hypotheticalModifier(modifier, ...effects) {
     const newEffects = effects.filter((e) => !have(e));
     return (numericModifier(modifier) +
@@ -240,7 +239,8 @@ export default class CommunityService {
     static Mysticality = new CommunityService(3, "Mysticality", "Build Playground Mazes", statCommunityServicePredictor($stat `Mysticality`), new Requirement(["Mysticality"], {}));
     static Moxie = new CommunityService(4, "Moxie", "Feed Conspirators", statCommunityServicePredictor($stat `Moxie`), new Requirement(["Moxie"], {}));
     static FamiliarWeight = new CommunityService(5, "Familiar Weight", "Breed More Collies", (...effects) => 60 -
-        Math.floor((baseWeight() + hypotheticalModifier("Familiar Weight", ...effects)) /
+        Math.floor((totalFamiliarWeight(myFamiliar(), false) +
+            hypotheticalModifier("Familiar Weight", ...effects)) /
             5), new Requirement(["Familiar Weight"], {}));
     static WeaponDamage = new CommunityService(6, "Weapon Damage", "Reduce Gazelle Population", (...effects) => {
         const weaponPower = getPower(equippedItem($slot `weapon`));
@@ -266,7 +266,7 @@ export default class CommunityService {
     }, new Requirement(["Weapon Damage", "Weapon Damage Percent"], {}));
     static SpellDamage = new CommunityService(7, "Spell Damage", "Make Sausage", (...effects) => {
         const dragonfishDamage = myFamiliar() === $familiar `Magic Dragonfish`
-            ? numericModifier($familiar `Magic Dragonfish`, "Spell Damage Percent", baseWeight() + weightAdjustment(), $item.none)
+            ? numericModifier($familiar `Magic Dragonfish`, "Spell Damage Percent", totalFamiliarWeight(), $item.none)
             : 0;
         // We add 0.001 because the floor function sometimes introduces weird rounding errors
         return (60 -
@@ -280,9 +280,9 @@ export default class CommunityService {
         const noncombatRate = -1 * hypotheticalModifier("Combat Rate", ...effects);
         const unsoftcappedRate = (rate) => rate > 25 ? 25 + (rate - 25) * 5 : rate;
         const currentFamiliarModifier = -1 *
-            numericModifier(myFamiliar(), "Combat Rate", familiarWeight(myFamiliar()) + numericModifier("Familiar Weight"), equippedItem($slot `familiar`));
+            numericModifier(myFamiliar(), "Combat Rate", totalFamiliarWeight(), equippedItem($slot `familiar`));
         const newFamiliarModifier = -1 *
-            numericModifier(myFamiliar(), "Combat Rate", familiarWeight(myFamiliar()) +
+            numericModifier(myFamiliar(), "Combat Rate", totalFamiliarWeight(myFamiliar(), false) +
                 hypotheticalModifier("Familiar Weight", ...effects), equippedItem($slot `familiar`));
         const adjustedRate = unsoftcappedRate(noncombatRate) -
             unsoftcappedRate(currentFamiliarModifier) +
@@ -294,10 +294,10 @@ export default class CommunityService {
         const mummingBuff = mummingCostume && mummingCostume[0] === "Item Drop"
             ? mummingCostume[1]
             : 0;
-        const familiarItemDrop = numericModifier(myFamiliar(), "Item Drop", baseWeight() + weightAdjustment(), equippedItem($slot `familiar`)) +
+        const familiarItemDrop = numericModifier(myFamiliar(), "Item Drop", totalFamiliarWeight(), equippedItem($slot `familiar`)) +
             mummingBuff -
             numericModifier(equippedItem($slot `familiar`), "Item Drop");
-        const familiarBoozeDrop = numericModifier(myFamiliar(), "Booze Drop", baseWeight() + weightAdjustment(), equippedItem($slot `familiar`)) - numericModifier(equippedItem($slot `familiar`), "Booze Drop");
+        const familiarBoozeDrop = numericModifier(myFamiliar(), "Booze Drop", totalFamiliarWeight(), equippedItem($slot `familiar`)) - numericModifier(equippedItem($slot `familiar`), "Booze Drop");
         // Champagne doubling does NOT count for CS, so we undouble
         const multiplier = haveEquipped($item `broken champagne bottle`) &&
             get("garbageChampagneCharge") > 0
@@ -318,8 +318,8 @@ export default class CommunityService {
         preventEquip: $items `broken champagne bottle`,
     }));
     static HotRes = new CommunityService(10, "Hot Resistance", "Clean Steam Tunnels", (...effects) => {
-        const currentFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", familiarWeight(myFamiliar()) + numericModifier("Familiar Weight"), equippedItem($slot `familiar`));
-        const newFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", familiarWeight(myFamiliar()) +
+        const currentFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", totalFamiliarWeight(), equippedItem($slot `familiar`));
+        const newFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", totalFamiliarWeight(myFamiliar(), false) +
             hypotheticalModifier("Familiar Weight", ...effects), equippedItem($slot `familiar`));
         return (60 -
             (hypotheticalModifier("Hot Resistance", ...effects) -

package/dist/combat.js

@@ -349,9 +349,7 @@ export class Macro {
      * @returns {Macro} This object itself.
      */
     ifNot(condition, ifTrue) {
-        return this.step(`if !(${Macro.makeBALLSPredicate(condition)})`)
-            .step(ifTrue)
-            .step("endif");
+        return this.if_(`!${Macro.makeBALLSPredicate(condition)}`, ifTrue);
     }
     /**
      * Create a new macro with an "if" statement, inverting the condition.

package/dist/lib.d.ts

@@ -1,5 +1,5 @@
 /** @module GeneralLibrary */
-import { Effect, Element, Familiar, Item, Location, Monster, runCombat, Servant, Skill, Slot, Stat, Thrall } from "kolmafia";
+import { Effect, Element, Familiar, Item, Location, Monster, runCombat, Servant, Skill, Slot, Stat, Thrall, Coinmaster } from "kolmafia";
 /**
  * Determines the current maximum Accordion Thief songs the player can have in their head
  *
@@ -507,4 +507,50 @@ export declare function haveIntrinsic(effect: Effect): boolean;
  */
 export declare function extractItems(text: string): Map<Item, number>;
 export type CombatParams = Parameters<typeof runCombat>;
+/**
+ * Calculate & return the scaling rate of a monster--`0` for non-scalers.
+ * @param monster The monster to check
+ * @returns The current scaling rate of the monster, based on your current in-game state
+ */
+export declare const getScalingRate: (monster: Monster) => number;
+/**
+ * Calculate & return the scaling cap of a monster--`0` for non-scalers.
+ * @param monster The monster to check
+ * @returns The current scaling cap of the monster, based on your current in-game state
+ */
+export declare const getScalingCap: (monster: Monster) => number;
+/**
+ * Wrap a specified action in mafia's `batchOpen` and `batchClose`
+ *
+ * @param action Action to perform while using mafia's batching feature
+ * @returns The return value of the action
+ */
+export declare function withBatch<T>(action: () => T): T;
+export declare const bulkAutosell: (items: Map<Item, number>) => boolean;
+export declare const bulkPutCloset: (items: Map<Item, number>) => boolean;
+export declare const bulkPutDisplay: (items: Map<Item, number>) => boolean;
+export declare const bulkPutStash: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeCloset: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeDisplay: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeShop: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeStash: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeStorage: (items: Map<Item, number>) => boolean;
+export declare const bulkPutShop: (items: Map<Item, {
+    quantity?: number;
+    limit?: number;
+    price: number;
+}>) => boolean;
+export declare const bulkSell: (coinmaster: Coinmaster, items: Map<Item, number>) => boolean;
+export declare const bulkRepriceShop: (items: Map<Item, {
+    quantity?: number;
+    limit?: number;
+    price: number;
+}>) => boolean;
+/**
+ * Calculate the total weight of a given familiar, including soup & modifiers
+ * @param familiar The familiar to use--defaults to your current one
+ * @param considerAdjustment Whether to include your `weightAdjustment` in the calculation
+ * @returns The total weight of the given familiar
+ */
+export declare function totalFamiliarWeight(familiar?: Familiar, considerAdjustment?: boolean): number;
 export {};

package/dist/lib.js

@@ -1,9 +1,9 @@
 /** @module GeneralLibrary */
-import { appearanceRates, autosellPrice, availableAmount, booleanModifier, choiceFollowsFight, cliExecute, currentRound, Effect, elementalResistance, equip, equippedItem, extractItems as kolmafiaExtractItems, Familiar, fullnessLimit, getCampground, getCounters, getPlayerId, getPlayerName, getRelated, handlingChoice, haveEffect, haveFamiliar, haveServant, haveSkill, holiday, inebrietyLimit, inMultiFight, Item, Location, mallPrice, Monster, myClass, myEffects, myFamiliar, myFullness, myInebriety, myPath, myPrimestat, mySpleenUse, myThrall, myTurncount, numericModifier, Path, Servant, Skill, Slot, spleenLimit, Thrall, todayToString, toItem, toSkill, totalTurnsPlayed, visitUrl, xpath, } from "kolmafia";
+import { appearanceRates, autosellPrice, availableAmount, booleanModifier, choiceFollowsFight, cliExecute, currentRound, Effect, elementalResistance, equip, equippedItem, extractItems as kolmafiaExtractItems, Familiar, fullnessLimit, getCampground, getCounters, getPlayerId, getPlayerName, getRelated, handlingChoice, haveEffect, haveFamiliar, haveServant, haveSkill, holiday, inebrietyLimit, inMultiFight, Item, Location, mallPrice, Monster, myClass, myEffects, myFamiliar, myFullness, myInebriety, myPath, myPrimestat, mySpleenUse, myThrall, myTurncount, numericModifier, Path, Servant, Skill, Slot, spleenLimit, Thrall, todayToString, toItem, toSkill, totalTurnsPlayed, visitUrl, xpath, monsterEval, batchOpen, batchClose, autosell, putCloset, putDisplay, putShop, putStash, sell, takeCloset, takeDisplay, takeShop, takeStash, takeStorage, repriceShop, familiarWeight, weightAdjustment, } from "kolmafia";
 import logger from "./logger.js";
 import { get } from "./property.js";
 import { $class, $effect, $element, $familiar, $item, $items, $monsters, $skill, $stat, } from "./template-string.js";
-import { makeByXFunction, chunk, flat, notNull } from "./utils.js";
+import { makeByXFunction, chunk, notNull, clamp } from "./utils.js";
 /**
  * Determines the current maximum Accordion Thief songs the player can have in their head
  *
@@ -623,6 +623,10 @@ export function findFairyMultiplier(familiar) {
     const itemBonus = numericModifier(familiar, "Item Drop", 1, $item.none);
     if (itemBonus === 0)
         return 0;
+    // Assumes you're using LED candle; returns effective weight multiplier
+    if (familiar === $familiar `Jill-of-All-Trades`)
+        return 1.5;
+    // Working out the multiplier based on the Item Drop at 1lb
     return Math.pow(Math.sqrt(itemBonus + 55 / 4 + 3) - Math.sqrt(55) / 2, 2);
 }
 export const holidayWanderers = new Map([
@@ -645,9 +649,9 @@ export const holidayWanderers = new Map([
  * @returns List of holiday wanderer Monsters
  */
 export function getTodaysHolidayWanderers() {
-    return flat(holiday()
+    return holiday()
         .split("/")
-        .map((holiday) => holidayWanderers.get(holiday) ?? []));
+        .flatMap((holiday) => holidayWanderers.get(holiday) ?? []);
 }
 /**
  * Determines whether or not we can safely call visitUrl(), based on whether we're in a fight, multi-fight, choice, etc
@@ -924,10 +928,10 @@ export function getCombatFlags(flags = [...ACCOUNT_COMBAT_FLAGS]) {
  */
 export function setCombatFlags(...flags) {
     return visitUrl(`account.php?${([
-        ...flat(flags.map(({ flag, value }) => [
+        ...flags.flatMap(({ flag, value }) => [
             `actions[]=flag_${flag}`,
             `flag_${flag}=${Number(value)}`,
-        ])),
+        ]),
         "action=Update",
         "am=1",
         "ajax=1",
@@ -970,3 +974,132 @@ export function haveIntrinsic(effect) {
 export function extractItems(text) {
     return new Map(Object.entries(kolmafiaExtractItems(text)).map(([itemName, quantity]) => [Item.get(itemName), quantity]));
 }
+function makeScalerCalcFunction(cache, pattern) {
+    return function (monster) {
+        const current = cache.get(monster);
+        if (current !== undefined)
+            return monsterEval(current);
+        const result = pattern.exec(monster.attributes)?.[1] ?? "0";
+        cache.set(monster, result);
+        return monsterEval(result);
+    };
+}
+const scalerRates = new Map();
+const scalerCaps = new Map();
+const SCALE_RATE_PATTERN = /Scale: (?:\[([^\]]*)\]|(\d*))/;
+const SCALE_CAP_PATTERN = /Cap: (?:\[([^\]]*)\]|(\d*))/;
+/**
+ * Calculate & return the scaling rate of a monster--`0` for non-scalers.
+ * @param monster The monster to check
+ * @returns The current scaling rate of the monster, based on your current in-game state
+ */
+export const getScalingRate = makeScalerCalcFunction(scalerRates, SCALE_RATE_PATTERN);
+/**
+ * Calculate & return the scaling cap of a monster--`0` for non-scalers.
+ * @param monster The monster to check
+ * @returns The current scaling cap of the monster, based on your current in-game state
+ */
+export const getScalingCap = makeScalerCalcFunction(scalerCaps, SCALE_CAP_PATTERN);
+/**
+ * Wrap a specified action in mafia's `batchOpen` and `batchClose`
+ *
+ * @param action Action to perform while using mafia's batching feature
+ * @returns The return value of the action
+ */
+export function withBatch(action) {
+    batchOpen();
+    try {
+        return action();
+    }
+    finally {
+        batchClose();
+    }
+}
+const makeBulkFunction = (action) => (items) => {
+    batchOpen();
+    for (const [item, quantity] of items.entries())
+        action(quantity, item);
+    return batchClose();
+};
+/*
+ * Autosell items in bulk
+ */
+export const bulkAutosell = makeBulkFunction(autosell);
+/*
+ * Closet items in bulk
+ * Note: each item transfer will still consume one request
+ */
+export const bulkPutCloset = makeBulkFunction(putCloset);
+/*
+ * Display items in bulk
+ */
+export const bulkPutDisplay = makeBulkFunction(putDisplay);
+/*
+ * Deposit items into your clan stash in bulk
+ */
+export const bulkPutStash = makeBulkFunction(putStash);
+/*
+ * Remove items from your closet in bulk
+ * Note: each item transfer will still consume one request
+ */
+export const bulkTakeCloset = makeBulkFunction(takeCloset);
+/*
+ * Remove items from your display case in bulk
+ */
+export const bulkTakeDisplay = makeBulkFunction(takeDisplay);
+/*
+ * Remove items from your shop in bulk
+ */
+export const bulkTakeShop = makeBulkFunction(takeShop);
+/*
+ * Withdraw items from your clan stash in bulk
+ * Note: each item transfer will still consume one request
+ */
+export const bulkTakeStash = makeBulkFunction(takeStash);
+/*
+ * Remove items from your Hagnk's in bulk
+ */
+export const bulkTakeStorage = makeBulkFunction(takeStorage);
+/*
+ * Mallsell items in bulk
+ */
+export const bulkPutShop = (items) => {
+    batchOpen();
+    for (const [item, { quantity, limit, price }] of items.entries()) {
+        quantity
+            ? putShop(price, limit ?? 0, quantity, item)
+            : putShop(price, limit ?? 0, item);
+    }
+    return batchClose();
+};
+/*
+ * Coinmaster-sell items to the same coinmaster in bulk
+ */
+export const bulkSell = (coinmaster, items) => {
+    batchOpen();
+    for (const [item, quantity] of items.entries())
+        sell(coinmaster, quantity, item);
+    return batchClose();
+};
+/*
+ * Reprice items in your mallstore in bulk
+ */
+export const bulkRepriceShop = (items) => {
+    batchOpen();
+    for (const [item, { limit, price }] of items.entries()) {
+        limit ? repriceShop(price, limit, item) : repriceShop(price, item);
+    }
+    return batchClose();
+};
+/**
+ * Calculate the total weight of a given familiar, including soup & modifiers
+ * @param familiar The familiar to use--defaults to your current one
+ * @param considerAdjustment Whether to include your `weightAdjustment` in the calculation
+ * @returns The total weight of the given familiar
+ */
+export function totalFamiliarWeight(familiar = myFamiliar(), considerAdjustment = true) {
+    return (clamp(familiarWeight(myFamiliar()), have($effect `Fidoxene`) ? 20 : 0, Infinity) +
+        familiar.soupWeight +
+        (considerAdjustment ? weightAdjustment() : 0) +
+        (familiar.feasted ? 10 : 0));
+}