libram 0.8.28 → 0.8.29

package/dist/challengePaths/2015/CommunityService.js

@@ -0,0 +1,334 @@
+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 } from "../../property";
+import { MummingTrunk } from "../../resources";
+import { $effect, $familiar, $item, $items, $path, $slot, $stat, $thrall, } from "../../template-string";
+import { clamp, sum } from "../../utils";
+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() && !have($effect `Expert Oiliness`)
+                    ? $stat `mysticality`
+                    : 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) +
+        sum(newEffects, (effect) => numericModifier(effect, modifier)));
+}
+export default class CommunityService {
+    choice;
+    stat;
+    property;
+    predictor;
+    maximizeRequirements;
+    timer = null;
+    /**
+     * 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, stat, property, predictor, maximizeRequirements) {
+        this.choice = id;
+        this.stat = stat;
+        this.property = property;
+        this.predictor = predictor;
+        this.maximizeRequirements = maximizeRequirements;
+    }
+    /**
+     * @returns The id number of the test, used primarily in runChoice.
+     */
+    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"
+     */
+    get name() {
+        return this.property;
+    }
+    /**
+     *  @returns The predicted number of turns this test will take given your character's current state.
+     */
+    get prediction() {
+        return this.predictor();
+    }
+    /**
+     * @returns A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
+     */
+    get requirement() {
+        return this.maximizeRequirements;
+    }
+    /**
+     * Start the time & turn counter for the Test in question.
+     */
+    startTimer() {
+        this.timer ??= { time: Date.now(), turns: myTurncount() };
+    }
+    static taskTimers = new Map();
+    /**
+     * Start the time & turn counter for the given task
+     *
+     * @param name The name of the task to start the counter of
+     */
+    static startTimer(name) {
+        if (!this.taskTimers.has(name)) {
+            this.taskTimers.set(name, { time: Date.now(), turns: myTurncount() });
+        }
+    }
+    static logTask(name, action) {
+        const { time, turns } = this.taskTimers.get(name) ?? {
+            time: Date.now(),
+            turns: myTurncount(),
+        };
+        const estimatedTurns = action() ?? 0;
+        CommunityService.log[name] = {
+            type: "task",
+            turnCost: myTurncount() - turns,
+            predictedTurns: estimatedTurns,
+            seconds: (Date.now() - time) / 1000,
+        };
+    }
+    /**
+     * Checks the "csServicesPerformed" property to see whether mafia currently believes this test is complete.
+     *
+     * @returns Whether mafia currently believes this test is complete.
+     */
+    isDone() {
+        return get("csServicesPerformed").includes(this.property);
+    }
+    /**
+     * Maximizes based on the Requirement associated with this particular test.
+     */
+    maximize() {
+        if (this.maximizeRequirements)
+            this.maximizeRequirements.maximize();
+    }
+    /**
+     * Attempts to turn in the test to the Council of Loathing.
+     *
+     * @returns Whether mafia believes the test is complete at the end of this function.
+     */
+    do() {
+        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. 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, maxTurns = Infinity) {
+        if (this.isDone())
+            return "already completed";
+        const { time, turns } = this.timer ?? {
+            time: Date.now(),
+            turns: myTurncount(),
+        };
+        let additionalTurns;
+        try {
+            const result = prepare();
+            additionalTurns = typeof result === "number" ? result : 0;
+        }
+        catch (e) {
+            print(`${e}`, "red");
+            return "failed";
+        }
+        const prediction = this.predictor();
+        const council = visitCouncil();
+        const turnCost = this._actualCost(council);
+        if (!turnCost)
+            return "already completed";
+        if (turnCost > Math.min(maxTurns, myAdventures())) {
+            return "failed";
+        }
+        if (!this.do())
+            return "failed";
+        CommunityService.log[this.property] = {
+            predictedTurns: prediction + additionalTurns,
+            turnCost: myTurncount() - turns,
+            seconds: (Date.now() - time) / 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 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());
+    }
+    /**
+     * @param effects A spread array of Effects to consider
+     * @returns The number of turns we expect to save if we start using those effects
+     */
+    turnsSavedBy(...effects) {
+        const currentTurns = clamp(this.prediction, 1, 60);
+        const newTurns = clamp(this.predictor(...effects), 1, 60);
+        return currentTurns - newTurns;
+    }
+    /**
+     * 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", (...effects) => 60 -
+        Math.floor((baseWeight() + 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`));
+        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 *
+                (hypotheticalModifier("Weapon Damage", ...effects) -
+                    0.15 * (weaponPower + offhandPower + familiarPower))) /
+                50 +
+                0.001) -
+            Math.floor((multiplier *
+                hypotheticalModifier("Weapon Damage Percent", ...effects)) /
+                50 +
+                0.001));
+    }, 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)
+            : 0;
+        // We add 0.001 because the floor function sometimes introduces weird rounding errors
+        return (60 -
+            Math.floor(hypotheticalModifier("Spell Damage", ...effects) / 50 + 0.001) -
+            Math.floor((hypotheticalModifier("Spell Damage Percent", ...effects) -
+                dragonfishDamage) /
+                50 +
+                0.001));
+    }, new Requirement(["Spell Damage", "Spell Damage Percent"], {}));
+    static Noncombat = new CommunityService(8, "Non-Combat", "Be a Living Statue", (...effects) => {
+        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`));
+        const newFamiliarModifier = -1 *
+            numericModifier(myFamiliar(), "Combat Rate", familiarWeight(myFamiliar()) +
+                hypotheticalModifier("Familiar Weight", ...effects), equippedItem($slot `familiar`));
+        const adjustedRate = unsoftcappedRate(noncombatRate) -
+            unsoftcappedRate(currentFamiliarModifier) +
+            unsoftcappedRate(newFamiliarModifier);
+        return 60 - 3 * Math.floor(adjustedRate / 5);
+    }, new Requirement(["-combat"], {}));
+    static BoozeDrop = new CommunityService(9, "Item Drop", "Make Margaritas", (...effects) => {
+        const mummingCostume = MummingTrunk.currentCostumes().get(myFamiliar());
+        const mummingBuff = mummingCostume && mummingCostume[0] === "Item Drop"
+            ? mummingCostume[1]
+            : 0;
+        const familiarItemDrop = numericModifier(myFamiliar(), "Item Drop", baseWeight() + weightAdjustment(), 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");
+        // 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 *
+                (hypotheticalModifier("Item Drop", ...effects) -
+                    familiarItemDrop -
+                    numericModifier(myThrall(), "Item Drop"))) /
+                30 +
+                0.001) -
+            Math.floor((hypotheticalModifier("Booze Drop", ...effects) - 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", (...effects) => {
+        const currentFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", familiarWeight(myFamiliar()) + numericModifier("Familiar Weight"), equippedItem($slot `familiar`));
+        const newFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", familiarWeight(myFamiliar()) +
+            hypotheticalModifier("Familiar Weight", ...effects), equippedItem($slot `familiar`));
+        return (60 -
+            (hypotheticalModifier("Hot Resistance", ...effects) -
+                currentFamiliarModifier +
+                newFamiliarModifier));
+    }, 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");
+    };
+    static path = $path `Community Service`;
+}

package/dist/challengePaths/2016/NuclearAutumn.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Visits the Cooling Tank on level 8 of the Fallout shelter to gain 300 rads
+ */
+export declare function coolingTank(): void;
+/**
+ * Visits the Spa Simulation Chamber on level 4 of the Fallout shelter for 100 turns of "100% all stats"
+ */
+export declare function spa(): void;
+/**
+ * Visits the Chronodynamics Laboratory on level 5 of the Fallout shelter to permanently increase radiation level by 3
+ */
+export declare function chronoLab(): void;
+export declare const path: import("kolmafia").Path;

package/dist/challengePaths/2016/NuclearAutumn.js

@@ -0,0 +1,21 @@
+import { visitUrl } from "kolmafia";
+import { $path } from "../../template-string";
+/**
+ * Visits the Cooling Tank on level 8 of the Fallout shelter to gain 300 rads
+ */
+export function coolingTank() {
+    visitUrl("place.php?whichplace=falloutshelter&action=vault8");
+}
+/**
+ * Visits the Spa Simulation Chamber on level 4 of the Fallout shelter for 100 turns of "100% all stats"
+ */
+export function spa() {
+    visitUrl("place.php?whichplace=falloutshelter&action=vault3");
+}
+/**
+ * Visits the Chronodynamics Laboratory on level 5 of the Fallout shelter to permanently increase radiation level by 3
+ */
+export function chronoLab() {
+    visitUrl("place.php?whichplace=falloutshelter&action=vault5");
+}
+export const path = $path `Nuclear Autumn`;

package/dist/challengePaths/index.d.ts

@@ -0,0 +1,4 @@
+import * as HeavyRains from "./2014/HeavyRains";
+import CommunityService from "./2015/CommunityService";
+import * as NuclearAutumn from "./2016/NuclearAutumn";
+export { CommunityService, NuclearAutumn, HeavyRains };

package/dist/challengePaths/index.js

@@ -0,0 +1,4 @@
+import * as HeavyRains from "./2014/HeavyRains";
+import CommunityService from "./2015/CommunityService";
+import * as NuclearAutumn from "./2016/NuclearAutumn";
+export { CommunityService, NuclearAutumn, HeavyRains };