libram 0.6.7 → 0.6.10

package/dist/Clan.js

@@ -123,7 +123,7 @@ export class Clan {
      * Join clan
      */
     join() {
-        return Clan._join(this.id);
+        return Clan.join(this.id);
     }
     check() {
         return visitUrl("clan_hall.php").includes(`<b>${this.name}</b>`);

package/dist/ascend.d.ts

@@ -1,4 +1,4 @@
-import { Class, Item } from "kolmafia";
+import { Skill, Class, Item } from "kolmafia";
 import { Path } from "./Path";
 import { Ceiling, Desk, Nightstand } from "./resources/2015/ChateauMantegna";
 export declare enum Lifestyle {
@@ -17,7 +17,7 @@ declare type MoonSign = number | "mongoose" | "wallaby" | "vole" | "platypus" |
  * @param consumable From the astral deli. Pick the container item, not the product.
  * @param pet From the astral pet store.
  */
-export declare function ascend(path: Path, playerClass: Class, lifestyle: Lifestyle, moon: MoonSign, consumable?: Item | undefined, pet?: Item | undefined): void;
+export declare function ascend(path: Path, playerClass: Class, lifestyle: Lifestyle, moon: MoonSign, consumable?: Item | undefined, pet?: Item | undefined, permSkills?: Map<Skill, Lifestyle> | undefined): void;
 declare const worksheds: readonly ["warbear LP-ROM burner", "warbear jackhammer drill press", "warbear induction oven", "warbear high-efficiency still", "warbear chemistry lab", "warbear auto-anvil", "spinning wheel", "snow machine", "Little Geneticist DNA-Splicing Lab", "portable Mayo Clinic", "Asdon Martin keyfob", "diabolic pizza cube", "cold medicine cabinet"];
 declare type Workshed = typeof worksheds[number];
 declare const gardens: readonly ["packet of pumpkin seeds", "Peppermint Pip Packet", "packet of dragon's teeth", "packet of beer seeds", "packet of winter seeds", "packet of thanksgarden seeds", "packet of tall grass seeds", "packet of mushroom spores"];

package/dist/ascend.js

@@ -1,4 +1,4 @@
-import { containsText, eudoraItem, getCampground, getWorkshed, Item, toInt, use, visitUrl, xpath, } from "kolmafia";
+import { containsText, eudoraItem, getCampground, getWorkshed, Item, toInt, use, visitUrl, xpath, haveSkill, } from "kolmafia";
 import { ChateauMantegna } from "./resources";
 import { $item, $items, $stat } from "./template-string";
 export var Lifestyle;
@@ -68,13 +68,7 @@ function toMoonId(moon, playerClass) {
  * @param consumable From the astral deli. Pick the container item, not the product.
  * @param pet From the astral pet store.
  */
-export function ascend(path, playerClass, lifestyle, moon, consumable = $item `astral six-pack`, pet = undefined) {
-    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
-        visitUrl("ascend.php?action=ascend&confirm=on&confirm2=on");
-    }
-    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
-        throw new Error("Failed to ascend.");
-    }
+export function ascend(path, playerClass, lifestyle, moon, consumable = $item `astral six-pack`, pet = undefined, permSkills = undefined) {
     if (!path.classes.includes(playerClass)) {
         throw new Error(`Invalid class ${playerClass} for this path`);
     }
@@ -85,11 +79,23 @@ export function ascend(path, playerClass, lifestyle, moon, consumable = $item `a
         throw new Error(`Invalid moon ${moon}`);
     if (consumable &&
         !$items `astral six-pack, astral hot dog dinner, [10882]carton of astral energy drinks`.includes(consumable)) {
-        throw new Error(`Invalid consumable ${consumable}`);
+        throw new Error(`Invalid consumable ${consumable}!`);
     }
     if (pet &&
         !$items `astral bludgeon, astral shield, astral chapeau, astral bracer, astral longbow, astral shorts, astral mace, astral ring, astral statuette, astral pistol, astral mask, astral pet sweater, astral shirt, astral belt`.includes(pet)) {
-        throw new Error(`Invalid astral item ${pet}`);
+        throw new Error(`Invalid astral item ${pet}!`);
+    }
+    const illegalSkill = permSkills
+        ? Array.from(permSkills.keys()).find((skill) => !skill.permable || !haveSkill(skill))
+        : undefined;
+    if (illegalSkill) {
+        throw new Error(`Invalid skill ${illegalSkill}!`);
+    }
+    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
+        visitUrl("ascend.php?action=ascend&confirm=on&confirm2=on");
+    }
+    if (!containsText(visitUrl("charpane.php"), "Astral Spirit")) {
+        throw new Error("Failed to ascend.");
     }
     visitUrl("afterlife.php?action=pearlygates");
     if (consumable) {
@@ -97,6 +103,14 @@ export function ascend(path, playerClass, lifestyle, moon, consumable = $item `a
     }
     if (pet)
         visitUrl(`afterlife.php?action=buyarmory&whichitem=${toInt(pet)}`);
+    if (permSkills) {
+        for (const [skill, permLevel] of permSkills.entries()) {
+            if (permLevel !== Lifestyle.casual) {
+                const permText = permLevel === Lifestyle.hardcore ? "hcperm" : "scperm";
+                visitUrl(`afterlife.php?action=${permText}&whichskill=${toInt(skill)}`);
+            }
+        }
+    }
     visitUrl(`afterlife.php?action=ascend&confirmascend=1&whichsign=${moonId}&gender=2&whichclass=${toInt(playerClass)}&whichpath=${path.id}&asctype=${lifestyle}&nopetok=1&noskillsok=1&lamepathok=1&lamesignok=1&pwd`, true);
 }
 const worksheds = [

package/dist/challengePaths/2015/CommunityService.d.ts

@@ -1,31 +1,27 @@
 import { Requirement } from "../../maximize";
-/**
- * A log of the predicted turns, actual turns, and duration of each CS test performed.
- */
-export declare const log: {
-    [index: string]: {
-        predictedTurns: number;
-        turnCost: number;
-        seconds: number;
-    };
-};
-declare class Test {
+export default class CommunityService {
     private choice;
+    private stat;
     private property;
     private predictor;
     private maximizeRequirements;
     /**
      * Class to store properties of various CS tests.
      * @param id The id the game HTML uses to identify the test; this is used primarily in runChoice.
+     * @param stat The principle stat the test measures, often used as more easily memorable shorthand for the specific tests
      * @param property The name of the test as a string, often used as part of the string property "csServicesPerformed".
      * @param predictor A function that returns an estimate for the number of turns that the test will take given your character's current state.
      * @param maximizeRequirements A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
      */
-    constructor(id: number, property: string, predictor: () => number, maximizeRequirements?: Requirement | null);
+    private constructor();
     /**
      * @returns The id number of the test, used primarily in runChoice.
      */
     get id(): number;
+    /**
+     * @returns The primary stat the test measures, used primarily as memorable shorthand in place of test names.
+     */
+    get statName(): string;
     /**
      * @returns The name of the test, used primarily as part of the string property "csServicesPerformed"
      */
@@ -38,6 +34,7 @@ declare class Test {
      * @returns A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
      */
     get requirement(): Requirement | null;
+    static logTask(name: string, action: () => number | void): void;
     /**
      * Checks the "csServicesPerformed" property to see whether mafia currently believes this test is complete.
      * @returns Whether mafia currently believes this test is complete.
@@ -54,33 +51,49 @@ declare class Test {
     do(): boolean;
     /**
      * Wrapper function that prepares for a test and then completes it, adding time and turn details to the log.
-     * @param prepare A function that does all necessary preparations for this CS test, including choosing your outfit.
-     * @param beCertain Whether we should check council.php instead of mafia to determine whether the test is complete.
-     * @param maxTurns We will run the test iff the predicted turns is less than or equal to this parameter.
-     * @returns The output of the prepare function given, or null if the test is already complete.
+     * @param prepare A function that does all necessary preparations for this CS test, including choosing your outfit. Optionally returns the number of turns you expect to spend preparing for the test.
+     * @param maxTurns We will run the test iff the predicted/actual turns is less than or equal to this parameter.
+     * @returns "completed", "failed", or "already completed".
      */
-    run(prepare: () => void, beCertain?: boolean, maxTurns?: number): boolean;
+    run(prepare: () => void | number, maxTurns?: number): "completed" | "failed" | "already completed";
+    private _verifyIsDone;
     /**
      * Checks council.php to verify that a test is complete; more reliable than isDone, but requires an additional pagehit.
      * @returns Whether council.php suggests that the test is complete.
      */
     verifyIsDone(): boolean;
+    private _actualCost;
+    /**
+     * Checks council.php for the number of turns this test will take; more reliable than prediction, but requires an additional pagehit.
+     * @returns The number of turns to complete this test according to council.php.
+     */
+    actualCost(): number;
+    /**
+     * A log of the predicted turns, actual turns, and duration of each CS test performed.
+     */
+    static log: {
+        [index: string]: {
+            predictedTurns: number;
+            turnCost: number;
+            seconds: number;
+            type: "test" | "task";
+        };
+    };
+    /**
+     * Prints turncount and time details of the test in question.
+     * @param colour The colour (or color) you'd like the log to be printed in.
+     */
+    static printLog(colour?: string): void;
+    static HP: CommunityService;
+    static Muscle: CommunityService;
+    static Mysticality: CommunityService;
+    static Moxie: CommunityService;
+    static FamiliarWeight: CommunityService;
+    static WeaponDamage: CommunityService;
+    static SpellDamage: CommunityService;
+    static Noncombat: CommunityService;
+    static BoozeDrop: CommunityService;
+    static HotRes: CommunityService;
+    static CoilWire: CommunityService;
+    static donate: () => void;
 }
-export declare const HP: Test;
-export declare const Muscle: Test;
-export declare const Mysticality: Test;
-export declare const Moxie: Test;
-export declare const FamiliarWeight: Test;
-export declare const WeaponDamage: Test;
-export declare const SpellDamage: Test;
-export declare const Noncombat: Test;
-export declare const BoozeDrop: Test;
-export declare const HotRes: Test;
-export declare const CoilWire: Test;
-/**
- * Prints turncount and time details of the test in question.
- * @param colour The colour (or color) you'd like the log to be printed in.
- */
-export declare function printLog(colour?: string): void;
-export declare const donate: () => void;
-export {};

package/dist/challengePaths/2015/CommunityService.js

@@ -1,29 +1,39 @@
-import { equippedItem, familiarWeight, getPower, haveEquipped, myBasestat, myBuffedstat, myFamiliar, myLevel, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, weightAdjustment, } from "kolmafia";
+import { equippedItem, familiarWeight, getPower, haveEquipped, myAdventures, myBasestat, myBuffedstat, myFamiliar, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, weightAdjustment, } from "kolmafia";
 import { have } from "../../lib";
 import { Requirement } from "../../maximize";
 import { get as getModifier } from "../../modifier";
 import { get } from "../../property";
-import { MummingTrunk, SongBoom } from "../../resources";
+import { MummingTrunk } from "../../resources";
 import { $effect, $familiar, $item, $items, $slot, $stat, $thrall, } from "../../template-string";
 import { sum } from "../../utils";
-/**
- * A log of the predicted turns, actual turns, and duration of each CS test performed.
- */
-export const log = {};
-class Test {
+const thralls = new Map([
+    [$stat `muscle`, $thrall `Elbow Macaroni`],
+    [$stat `moxie`, $thrall `Penne Dreadful`],
+]);
+const statCommunityServicePredictor = (stat) => {
+    return () => 60 -
+        Math.floor((1 / 30) *
+            (myBuffedstat(stat) -
+                myBasestat(thralls.get(stat) === myThrall() ? $stat `mysticality` : stat)));
+};
+const visitCouncil = () => visitUrl("council.php");
+export default class CommunityService {
     choice;
+    stat;
     property;
     predictor;
     maximizeRequirements;
     /**
      * Class to store properties of various CS tests.
      * @param id The id the game HTML uses to identify the test; this is used primarily in runChoice.
+     * @param stat The principle stat the test measures, often used as more easily memorable shorthand for the specific tests
      * @param property The name of the test as a string, often used as part of the string property "csServicesPerformed".
      * @param predictor A function that returns an estimate for the number of turns that the test will take given your character's current state.
      * @param maximizeRequirements A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
      */
-    constructor(id, property, predictor, maximizeRequirements = null) {
+    constructor(id, stat, property, predictor, maximizeRequirements) {
         this.choice = id;
+        this.stat = stat;
         this.property = property;
         this.predictor = predictor;
         this.maximizeRequirements = maximizeRequirements;
@@ -34,6 +44,12 @@ class Test {
     get id() {
         return this.choice;
     }
+    /**
+     * @returns The primary stat the test measures, used primarily as memorable shorthand in place of test names.
+     */
+    get statName() {
+        return this.stat;
+    }
     /**
      * @returns The name of the test, used primarily as part of the string property "csServicesPerformed"
      */
@@ -52,6 +68,17 @@ class Test {
     get requirement() {
         return this.maximizeRequirements;
     }
+    static logTask(name, action) {
+        const startTime = Date.now();
+        const startTurns = myTurncount();
+        const estimatedTurns = action() ?? 0;
+        CommunityService.log[name] = {
+            type: "task",
+            turnCost: myTurncount() - startTurns,
+            predictedTurns: estimatedTurns,
+            seconds: (Date.now() - startTime) / 1000,
+        };
+    }
     /**
      * Checks the "csServicesPerformed" property to see whether mafia currently believes this test is complete.
      * @returns Whether mafia currently believes this test is complete.
@@ -71,139 +98,159 @@ class Test {
      * @returns Whether mafia believes the test is complete at the end of this function.
      */
     do() {
-        visitUrl("council.php");
-        runChoice(this.choice);
-        return this.isDone();
+        if (get("csServicesPerformed").trim().length === 0)
+            visitCouncil();
+        visitCouncil();
+        const councilText = runChoice(this.choice);
+        return this._verifyIsDone(councilText);
     }
     /**
      * Wrapper function that prepares for a test and then completes it, adding time and turn details to the log.
-     * @param prepare A function that does all necessary preparations for this CS test, including choosing your outfit.
-     * @param beCertain Whether we should check council.php instead of mafia to determine whether the test is complete.
-     * @param maxTurns We will run the test iff the predicted turns is less than or equal to this parameter.
-     * @returns The output of the prepare function given, or null if the test is already complete.
+     * @param prepare A function that does all necessary preparations for this CS test, including choosing your outfit. Optionally returns the number of turns you expect to spend preparing for the test.
+     * @param maxTurns We will run the test iff the predicted/actual turns is less than or equal to this parameter.
+     * @returns "completed", "failed", or "already completed".
      */
-    run(prepare, beCertain = false, maxTurns = Infinity) {
-        const finishedFunction = () => beCertain ? this.verifyIsDone() : this.isDone();
-        if (finishedFunction())
-            return false;
+    run(prepare, maxTurns = Infinity) {
+        if (this.isDone())
+            return "already completed";
         const startTime = Date.now();
         const startTurns = myTurncount();
+        let additionalTurns;
         try {
-            prepare();
+            additionalTurns = prepare() ?? 0;
         }
         catch {
-            return false;
+            return "failed";
         }
         const prediction = this.predictor();
-        if (prediction <= maxTurns) {
-            this.do();
+        const council = visitCouncil();
+        const turns = this._actualCost(council);
+        if (!turns)
+            return "already completed";
+        if (turns > Math.min(maxTurns, myAdventures())) {
+            return "failed";
         }
-        if (finishedFunction()) {
-            log[this.property] = {
-                predictedTurns: prediction,
-                turnCost: myTurncount() - startTurns,
-                seconds: (Date.now() - startTime) / 1000,
-            };
-            return true;
-        }
-        return false;
+        if (!this.do())
+            return "failed";
+        CommunityService.log[this.property] = {
+            predictedTurns: prediction + additionalTurns,
+            turnCost: myTurncount() - startTurns,
+            seconds: (Date.now() - startTime) / 1000,
+            type: "test",
+        };
+        return "completed";
+    }
+    _verifyIsDone(councilText) {
+        return !councilText.includes(`<input type=hidden name=option value=${this.choice}>`);
     }
     /**
      * Checks council.php to verify that a test is complete; more reliable than isDone, but requires an additional pagehit.
      * @returns Whether council.php suggests that the test is complete.
      */
     verifyIsDone() {
-        return !visitUrl("council.php").includes(`<input type=hidden name=option value=${this.choice}>`);
+        return this._verifyIsDone(visitCouncil());
     }
+    _actualCost(councilText) {
+        const match = councilText.match(`<input type=hidden name=option value=${this.id}>.*?Perform Service \\((\\d+) Adventures\\)`);
+        return match ? parseInt(match[1]) : 0;
+    }
+    /**
+     * Checks council.php for the number of turns this test will take; more reliable than prediction, but requires an additional pagehit.
+     * @returns The number of turns to complete this test according to council.php.
+     */
+    actualCost() {
+        return this._actualCost(visitCouncil());
+    }
+    /**
+     * A log of the predicted turns, actual turns, and duration of each CS test performed.
+     */
+    static log = {};
+    /**
+     * Prints turncount and time details of the test in question.
+     * @param colour The colour (or color) you'd like the log to be printed in.
+     */
+    static printLog(colour = "blue") {
+        const logEntries = Object.entries(CommunityService.log);
+        for (const [testName, testEntry] of logEntries) {
+            const { type, predictedTurns, turnCost, seconds } = testEntry;
+            if (type === "test") {
+                print(`We predicted the ${testName} test would take ${predictedTurns} turns, ${predictedTurns === turnCost ? "and" : "but"} it took ${turnCost} turns.`, colour);
+                print(`${testName} took ${seconds.toFixed(1)} seconds.`, colour);
+            }
+            else {
+                if (!(predictedTurns === 0 && turnCost === 0)) {
+                    print(`We predicted the task ${testName} would take ${predictedTurns} turns, ${predictedTurns === turnCost ? "and" : "but"} it took ${turnCost} turns.`, colour);
+                }
+                print(`The task ${testName} took ${seconds.toFixed(1)} seconds.`, colour);
+            }
+        }
+        const totalTime = sum(logEntries, ([, testEntry]) => testEntry.seconds);
+        print(`All together, you have spent ${totalTime.toFixed(1)} seconds during this Community Service run`, colour);
+    }
+    // Below, we have the tests themselves.
+    static HP = new CommunityService(1, "HP", "Donate Blood", () => 60 - Math.floor((myMaxhp() - myBuffedstat($stat `muscle`) - 3) / 30), new Requirement(["HP"], {}));
+    static Muscle = new CommunityService(2, "Muscle", "Feed The Children", statCommunityServicePredictor($stat `Muscle`), new Requirement(["Muscle"], {}));
+    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", () => 60 - Math.floor((familiarWeight(myFamiliar()) + weightAdjustment()) / 5), new Requirement(["Familiar Weight"], {}));
+    static WeaponDamage = new CommunityService(6, "Weapon Damage", "Reduce Gazelle Population", () => {
+        const weaponPower = getPower(equippedItem($slot `weapon`));
+        const offhandPower = toSlot(equippedItem($slot `off-hand`)) === $slot `weapon`
+            ? getPower(equippedItem($slot `off-hand`))
+            : 0;
+        const familiarPower = toSlot(equippedItem($slot `familiar`)) === $slot `weapon`
+            ? getPower(equippedItem($slot `familiar`))
+            : 0;
+        // mafia does not currently count swagger
+        const multiplier = have($effect `Bow-Legged Swagger`) ? 2 : 1;
+        // We add 0.001 because the floor function sometimes introduces weird rounding errors
+        return (60 -
+            Math.floor((multiplier *
+                (getModifier("Weapon Damage") -
+                    0.15 * (weaponPower + offhandPower + familiarPower))) /
+                50 +
+                0.001) -
+            Math.floor((multiplier * getModifier("Weapon Damage Percent")) / 50 + 0.001));
+    }, new Requirement(["Weapon Damage", "Weapon Damage Percent"], {}));
+    static SpellDamage = new CommunityService(7, "Spell Damage", "Make Sausage", () => {
+        const dragonfishDamage = myFamiliar() === $familiar `Magic Dragonfish`
+            ? numericModifier($familiar `Magic Dragonfish`, "Spell Damage Percent", familiarWeight($familiar `Magic Dragonfish`) + weightAdjustment(), $item `none`)
+            : 0;
+        // We add 0.001 because the floor function sometimes introduces weird rounding errors
+        return (60 -
+            Math.floor(getModifier("Spell Damage") / 50 + 0.001) -
+            Math.floor((getModifier("Spell Damage Percent") - dragonfishDamage) / 50 + 0.001));
+    }, new Requirement(["Spell Damage", "Spell Damage Percent"], {}));
+    static Noncombat = new CommunityService(8, "Non-Combat", "Be a Living Statue", () => {
+        const noncombatRate = -1 * getModifier("Combat Rate");
+        return 60 - 3 * Math.floor(noncombatRate / 5);
+    }, new Requirement(["-combat"], {}));
+    static BoozeDrop = new CommunityService(9, "Item Drop", "Make Margaritas", () => {
+        const mummingCostume = MummingTrunk.currentCostumes().get(myFamiliar());
+        const mummingBuff = mummingCostume && mummingCostume[0] === "Item Drop"
+            ? mummingCostume[1]
+            : 0;
+        const familiarItemDrop = numericModifier(myFamiliar(), "Item Drop", familiarWeight(myFamiliar()) + weightAdjustment(), equippedItem($slot `familiar`)) +
+            mummingBuff -
+            numericModifier(equippedItem($slot `familiar`), "Item Drop");
+        const familiarBoozeDrop = numericModifier(myFamiliar(), "Booze Drop", familiarWeight(myFamiliar()) + weightAdjustment(), 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
+            ? 0.5
+            : 1;
+        // We add 0.001 because the floor function sometimes introduces weird rounding errors
+        return (60 -
+            Math.floor((multiplier * (getModifier("Item Drop") - familiarItemDrop)) / 30 +
+                0.001) -
+            Math.floor((getModifier("Booze Drop") - familiarBoozeDrop) / 15 + 0.001));
+    }, new Requirement(["Item Drop", "2 Booze Drop"], {
+        preventEquip: $items `broken champagne bottle`,
+    }));
+    static HotRes = new CommunityService(10, "Hot Resistance", "Clean Steam Tunnels", () => 60 - getModifier("Hot Resistance"), new Requirement(["Hot Resistance"], {}));
+    static CoilWire = new CommunityService(11, "Coil Wire", "Coil Wire", () => 60, new Requirement([], {}));
+    static donate = () => {
+        visitCouncil();
+        visitUrl("choice.php?whichchoice=1089&option=30");
+    };
 }
-const thralls = new Map([
-    [$stat `muscle`, $thrall `Elbow Macaroni`],
-    [$stat `moxie`, $thrall `Penne Dreadful`],
-]);
-const statTestPredictor = (stat) => {
-    return () => 60 -
-        Math.floor((1 / 30) *
-            (myBuffedstat(stat) -
-                myBasestat(thralls.get(stat) === myThrall() ? $stat `mysticality` : stat)));
-};
-export const HP = new Test(1, "Donate Blood", () => 60 - Math.floor((myMaxhp() - myBuffedstat($stat `muscle`) - 3) / 30), new Requirement(["HP"], {}));
-export const Muscle = new Test(2, "Feed The Children", statTestPredictor($stat `Muscle`), new Requirement(["Muscle"], {}));
-export const Mysticality = new Test(3, "Build Playground Mazes", statTestPredictor($stat `Mysticality`), new Requirement(["Mysticality"], {}));
-export const Moxie = new Test(4, "Feed Conspirators", statTestPredictor($stat `Moxie`), new Requirement(["Moxie"], {}));
-export const FamiliarWeight = new Test(5, "Breed More Collies", () => 60 - Math.floor((familiarWeight(myFamiliar()) + weightAdjustment()) / 5), new Requirement(["Familiar Weight"], {}));
-export const WeaponDamage = new Test(6, "Reduce Gazelle Population", () => {
-    const weaponPower = getPower(equippedItem($slot `weapon`));
-    const offhandPower = toSlot(equippedItem($slot `off-hand`)) === $slot `weapon`
-        ? getPower(equippedItem($slot `off-hand`))
-        : 0;
-    const familiarPower = toSlot(equippedItem($slot `familiar`)) === $slot `weapon`
-        ? getPower(equippedItem($slot `familiar`))
-        : 0;
-    const songDamage = SongBoom.song() === "These Fists Were Made for Punchin'" ? myLevel() : 0;
-    // mafia does not currently count swagger
-    const multiplier = have($effect `Bow-Legged Swagger`) ? 2 : 1;
-    // We add 0.001 because the floor function sometimes introduces weird rounding errors
-    return (60 -
-        Math.floor((multiplier *
-            (getModifier("Weapon Damage") -
-                0.15 * (weaponPower + offhandPower + familiarPower) -
-                songDamage)) /
-            50 +
-            0.001) -
-        Math.floor((multiplier * getModifier("Weapon Damage Percent")) / 50 + 0.001));
-}, new Requirement(["Weapon Damage", "Weapon Damage Percent"], {}));
-export const SpellDamage = new Test(7, "Make Sausage", () => {
-    const dragonfishDamage = myFamiliar() === $familiar `Magic Dragonfish`
-        ? numericModifier($familiar `Magic Dragonfish`, "Spell Damage Percent", familiarWeight($familiar `Magic Dragonfish`) + weightAdjustment(), $item `none`)
-        : 0;
-    // We add 0.001 because the floor function sometimes introduces weird rounding errors
-    return (60 -
-        Math.floor(getModifier("Spell Damage") / 50 + 0.001) -
-        Math.floor((getModifier("Spell Damage Percent") - dragonfishDamage) / 50 + 0.001));
-}, new Requirement(["Spell Damage", "Spell Damage Percent"], {}));
-export const Noncombat = new Test(8, "Be a Living Statue", () => {
-    const noncombatRate = -1 * getModifier("Combat Rate");
-    const unsoftcappedRate = noncombatRate > 25 ? 25 + (noncombatRate - 25) * 5 : noncombatRate;
-    return 60 - 3 * Math.floor(unsoftcappedRate / 5);
-}, new Requirement(["-combat"], {}));
-export const BoozeDrop = new Test(9, "Make Margaritas", () => {
-    const mummingCostume = MummingTrunk.currentCostumes().get(myFamiliar());
-    const mummingBuff = mummingCostume && mummingCostume[0] === "Item Drop"
-        ? mummingCostume[1]
-        : 0;
-    const familiarItemDrop = numericModifier(myFamiliar(), "Item Drop", familiarWeight(myFamiliar()) + weightAdjustment(), equippedItem($slot `familiar`)) +
-        mummingBuff -
-        numericModifier(equippedItem($slot `familiar`), "Item Drop");
-    const familiarBoozeDrop = numericModifier(myFamiliar(), "Booze Drop", familiarWeight(myFamiliar()) + weightAdjustment(), 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
-        ? 0.5
-        : 1;
-    // We add 0.001 because the floor function sometimes introduces weird rounding errors
-    return (60 -
-        multiplier *
-            Math.floor((getModifier("Item Drop") - familiarItemDrop) / 30 + 0.001) -
-        Math.floor((getModifier("Booze Drop") - familiarBoozeDrop) / 15 + 0.001));
-}, new Requirement(["Item Drop", "2 Booze Drop"], {
-    preventEquip: $items `broken champagne bottle`,
-}));
-export const HotRes = new Test(10, "Clean Steam Tunnels", () => 60 - getModifier("Hot Resistance"), new Requirement(["Hot Resistance"], {}));
-export const CoilWire = new Test(11, "Coil Wire", () => 60, null);
-/**
- * Prints turncount and time details of the test in question.
- * @param colour The colour (or color) you'd like the log to be printed in.
- */
-export function printLog(colour = "blue") {
-    const logEntries = Object.entries(log);
-    for (const [testName, testEntry] of logEntries) {
-        const { predictedTurns, turnCost, seconds } = testEntry;
-        print(`We predicted the ${testName} test would take ${predictedTurns} turns, ${predictedTurns === turnCost ? "and" : "but"} it took ${turnCost} turns`, colour);
-        print(`${testName} took ${seconds} seconds`, colour);
-    }
-    print(`All together, you have spent ${sum(logEntries, ([, testEntry]) => testEntry.seconds)} seconds during this Community Service run`, colour);
-}
-export const donate = () => {
-    visitUrl("council.php");
-    visitUrl("choice.php?whichchoice=1089&option=30");
-};

package/dist/challengePaths/index.d.ts

@@ -1,2 +1,2 @@
-import * as CommunityService from "./2015/CommunityService";
+import CommunityService from "./2015/CommunityService";
 export { CommunityService };

package/dist/challengePaths/index.js

@@ -1,2 +1,2 @@
-import * as CommunityService from "./2015/CommunityService";
+import CommunityService from "./2015/CommunityService";
 export { CommunityService };

package/dist/combat.d.ts

@@ -103,7 +103,7 @@ export declare class Macro {
      * @param ifTrue Continuation if the condition is true.
      * @returns {Macro} This object itself.
      */
-    if_(condition: string | Monster | Effect | Skill | Item | Location | Class | Stat, ifTrue: string | Macro): this;
+    if_(condition: string | Monster | Monster[] | Effect | Skill | Item | Location | Class | Stat, ifTrue: string | Macro): this;
     /**
      * Create a new macro with an "if" statement.
      * @param condition The BALLS condition for the if statement.

package/dist/combat.js

@@ -211,6 +211,12 @@ export class Macro {
         if (condition instanceof Monster) {
             ballsCondition = `monsterid ${condition.id}`;
         }
+        else if (condition instanceof Array) {
+            ballsCondition = condition
+                .map((mon) => `monsterid ${mon.id}`)
+                .join(" || ");
+            ballsCondition = `(${ballsCondition})`;
+        }
         else if (condition instanceof Effect) {
             ballsCondition = `haseffect ${toInt(condition)}`;
         }

package/dist/counter.d.ts

@@ -1,9 +1,15 @@
 /**
- * Returns null for counters that do not exist, and otherwise returns the duration of the counter
+ * Returns Infinity for counters that do not exist, and otherwise returns the duration of the counter
  * @param counter The name of the counter in question
- * @returns null if the counter does not exist; otherwise returns the duration of the counter
+ * @returns Infinity if the counter does not exist; otherwise returns the duration of the counter
  */
-export declare function get(counter: string): number | null;
+export declare function get(counter: string): number;
+/**
+ * The world is everything that is the case. This determines which counters are the case.
+ * @param counter The name of the counter in question
+ * @returns True for counters which currently exist; false for those which do not
+ */
+export declare function exists(counter: string): boolean;
 /**
  * Creates a manual counter with specified name and duration
  * @param counter Name of the counter to manually create

package/dist/counter.js

@@ -1,19 +1,27 @@
 import { cliExecute, getCounter, getCounters } from "kolmafia";
 /**
- * Returns null for counters that do not exist, and otherwise returns the duration of the counter
+ * Returns Infinity for counters that do not exist, and otherwise returns the duration of the counter
  * @param counter The name of the counter in question
- * @returns null if the counter does not exist; otherwise returns the duration of the counter
+ * @returns Infinity if the counter does not exist; otherwise returns the duration of the counter
  */
 export function get(counter) {
     const value = getCounter(counter);
-    //getCounter returns -1 for counters that don't exist, but it also returns -1 for counters whose value is -1
+    // getCounter returns -1 for counters that don't exist, but it also returns -1 for counters whose value is -1
     if (value === -1) {
-        //if we have a counter with value -1, we check to see if that counter exists via getCounters()
-        //We return null if it doesn't exist
-        return getCounters(counter, -1, -1).trim() === "" ? null : -1;
+        // if we have a counter with value -1, we check to see if that counter exists via getCounters()
+        // We return null if it doesn't exist
+        return getCounters(counter, -1, -1).trim() === "" ? Infinity : -1;
     }
     return value;
 }
+/**
+ * The world is everything that is the case. This determines which counters are the case.
+ * @param counter The name of the counter in question
+ * @returns True for counters which currently exist; false for those which do not
+ */
+export function exists(counter) {
+    return (getCounter(counter) !== -1 || getCounters(counter, -1, -1).trim() !== "");
+}
 /**
  * Creates a manual counter with specified name and duration
  * @param counter Name of the counter to manually create