libram 0.8.28 → 0.8.29

package/dist/ascend.js

@@ -0,0 +1,268 @@
+import { eudoraItem, getCampground, Item, Path, use, visitUrl, xpath, haveSkill, getPermedSkills, toSkill, } from "kolmafia";
+import { signNameToId } from "./moonSign";
+import { get } from "./property";
+import { ChateauMantegna } from "./resources";
+import { $item, $items, $stat } from "./template-string";
+import { arrayContains, tc } from "./utils";
+export var Lifestyle;
+(function (Lifestyle) {
+    Lifestyle[Lifestyle["casual"] = 1] = "casual";
+    Lifestyle[Lifestyle["softcore"] = 2] = "softcore";
+    Lifestyle[Lifestyle["normal"] = 2] = "normal";
+    Lifestyle[Lifestyle["hardcore"] = 3] = "hardcore";
+})(Lifestyle || (Lifestyle = {}));
+export var KolGender;
+(function (KolGender) {
+    KolGender[KolGender["male"] = 1] = "male";
+    KolGender[KolGender["female"] = 2] = "female";
+})(KolGender || (KolGender = {}));
+/**
+ * Get a mapping of permed skills to the extent to which they're permed.
+ *
+ * If a skill is not permed at all, it will not appear in the mapping.
+ *
+ * @returns Permed skills mapping
+ */
+export function permedSkills() {
+    return new Map(Array.from(Object.entries(getPermedSkills())).map(([skillName, isHardcore]) => [
+        toSkill(skillName),
+        isHardcore ? Lifestyle.hardcore : Lifestyle.softcore,
+    ]));
+}
+export class AscendError extends Error {
+}
+const gardens = [
+    "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",
+    "packet of rock seeds",
+];
+const eudorae = [
+    "My Own Pen Pal kit",
+    "GameInformPowerDailyPro subscription card",
+    "Xi Receiver Unit",
+    "New-You Club Membership Form",
+    "Our Daily Candles™ order form",
+];
+const isGarden = (x) => arrayContains(x, gardens);
+const isEudora = (x) => arrayContains(x, eudorae);
+const isDesk = (x) => arrayContains(x, ChateauMantegna.desks);
+const isNightstand = (x) => arrayContains(x, ChateauMantegna.nightstands);
+const isCeiling = (x) => arrayContains(x, ChateauMantegna.ceilings);
+export class AscensionPrepError extends Error {
+    cause;
+    constructor(cause, original) {
+        if (isGarden(cause)) {
+            super(`Unable to swap garden to ${cause}; garden is currently ${original}.`);
+        }
+        else if (isEudora(cause)) {
+            super(`Unable to swap eudora to ${cause}; eudora is currently ${original}.`);
+        }
+        else if (isDesk(cause)) {
+            super(`Unable to swap chateau desk to ${cause}; desk is currently ${original}.`);
+        }
+        else if (isNightstand(cause)) {
+            super(`Unable to swap chateau nightstand to ${cause}; nightstand is currently ${original}.`);
+        }
+        else if (isCeiling(cause)) {
+            super(`Unable to swap chateau ceiling to ${cause}; ceiling is currently ${original}.`);
+        }
+        else
+            super(cause);
+        this.cause = cause;
+    }
+}
+/**
+ * Determine the id of the appropriate moon sign.
+ *
+ * @param moon Either a moon sign or the desired unlocked zone name
+ * @param playerClass Class, required for working out a moon sign based on the desired zone
+ * @returns Moon sign id
+ */
+function inputToMoonId(moon, playerClass) {
+    if (typeof moon === "number")
+        return moon;
+    const offset = () => {
+        switch (playerClass.primestat) {
+            case $stat `Muscle`:
+                return 0;
+            case $stat `Mysticality`:
+                return 1;
+            case $stat `Moxie`:
+                return 2;
+            default:
+                throw new AscendError(`unknown prime stat for ${playerClass}`);
+        }
+    };
+    const fromNormalInput = signNameToId(tc(moon));
+    if (fromNormalInput > 0)
+        return fromNormalInput;
+    switch (moon.toLowerCase()) {
+        case "degrassi":
+        case "degrassi knoll":
+        case "friendly degrassi knoll":
+        case "knoll":
+            return 1 + offset();
+        case "canada":
+        case "canadia":
+        case "little canadia":
+            return 4 + offset();
+        case "gnomads":
+        case "gnomish":
+        case "gnomish gnomads camp":
+            return 7 + offset();
+        default:
+            throw new AscendError("Invalid moon sign!");
+    }
+}
+/**
+ * Determine if player is currently in Valhalla
+ *
+ * @returns Whether player is in Valhalla
+ */
+function isInValhalla() {
+    const charPaneText = visitUrl("charpane.php");
+    // Match the infinity images (inf_small.gif, inf_large.gif)
+    // At time of writing, the full img tag used is:
+    // <img src="https://d2uyhvukfffg5a.cloudfront.net/otherimages/inf_small.gif">
+    const matches = charPaneText.match(/<img src="[^"]*\/otherimages\/inf_\w+\.gif">/);
+    return matches !== null;
+}
+/**
+ * Hops the gash, perming no skills by default
+ *
+ * @param options Configuration for the ascension
+ * @param options.path Your path of choice for this ascension
+ * @param options.playerClass Your class of choice for this ascension
+ * @param options.lifestyle 1 for casual, 2 for softcore, 3 for hardcore. Alternately, use the Lifestyle enum
+ * @param options.kolGender An entry from the KolGender enum: 1 for male, 2 for female (sorry that it's limited to those). Defaults to 2 or the corresponding value for defaultGenderOverride pref (which should be 'male' or 'female')
+ * @param options.moon Your moon sign as a string, or the zone you're looking for as a string
+ * @param options.consumable From the astral deli. Pick the container item, not the product. Defaults to astral six-pack, provide $item`none` for nothing.
+ * @param options.pet From the astral pet store.
+ * @param options.permOptions Options for perming during a player's stay in Valhalla
+ * @param options.permOptions.permSkills A Map<Skill, Lifestyle> of skills you'd like to perm, ordered by priority.
+ * @param options.permOptions.neverAbort Whether the ascension should abort on failure
+ */
+export function ascend(options) {
+    const DEFAULT_OPTIONS = {
+        kolGender: get("defaultGenderOverride", "female") === "male"
+            ? KolGender.male
+            : KolGender.female,
+        consumable: $item `astral six-pack`,
+        pet: $item `none`,
+    };
+    const prunedOptions = Object.fromEntries(Object.entries(options).filter(([, value]) => value));
+    const { path, playerClass, lifestyle, kolGender, moon, consumable, pet, permOptions, } = { ...DEFAULT_OPTIONS, ...prunedOptions };
+    if (playerClass.path !== (path.avatar ? path : Path.none)) {
+        throw new AscendError(`Invalid class ${playerClass} for this path!`);
+    }
+    if (path.id < 0)
+        throw new AscendError(`Invalid path: ${path}!`);
+    const moonId = inputToMoonId(moon, playerClass);
+    if (moonId < 1 || moonId > 9)
+        throw new Error(`Invalid moon ${moon}`);
+    if (!$items `none, astral six-pack, astral hot dog dinner, [10882]carton of astral energy drinks`.includes(consumable)) {
+        throw new AscendError(`Invalid astral consumable: ${consumable}`);
+    }
+    if (!$items `none, astral bludgeon, astral shield, astral chapeau, astral bracer, astral longbow, astral shorts, astral mace, astral trousers, astral ring, astral statuette, astral pistol, astral mask, astral pet sweater, astral shirt, astral belt`.includes(pet)) {
+        throw new AscendError(`Invalid astral pet: ${pet}`);
+    }
+    const unownedSkills = [...(permOptions?.permSkills.keys() ?? [])].filter((skill) => !haveSkill(skill));
+    if (unownedSkills.length) {
+        throw new AscendError(`You're trying to perm the following skills, but don't actually have them: ${unownedSkills.join(", ")}`);
+    }
+    const unpermableSkills = [...(permOptions?.permSkills.keys() ?? [])].filter((skill) => !skill.permable);
+    if (unpermableSkills.length) {
+        throw new AscendError(`You're trying to perm the following skills, but they're unpermable: ${unownedSkills.join(", ")}`);
+    }
+    if (!isInValhalla()) {
+        visitUrl("ascend.php?action=ascend&confirm=on&confirm2=on");
+    }
+    if (!isInValhalla()) {
+        throw new AscendError("Failed to ascend--do you have a pending trade offer?");
+    }
+    visitUrl("afterlife.php?action=pearlygates");
+    if (consumable !== $item `none`) {
+        visitUrl(`afterlife.php?action=buydeli&whichitem=${consumable.id}`);
+    }
+    if (pet !== $item `none`) {
+        visitUrl(`afterlife.php?action=buyarmory&whichitem=${pet.id}`);
+    }
+    if (permOptions) {
+        const currentPerms = permedSkills();
+        let karma = get("bankedKarma");
+        for (const [skill, prospectivePermLevel,] of permOptions.permSkills.entries()) {
+            const currentPermLevel = currentPerms.get(skill) ?? Lifestyle.casual;
+            if (prospectivePermLevel > currentPermLevel) {
+                const expectedKarma = 100 * (prospectivePermLevel - currentPermLevel);
+                if (karma < expectedKarma) {
+                    if (!permOptions.neverAbort)
+                        throw new AscendError(`Skill ${skill} is too karmaically expensive!`);
+                    continue;
+                }
+                karma -= expectedKarma;
+                const permText = prospectivePermLevel === Lifestyle.hardcore ? "hcperm" : "scperm";
+                visitUrl(`afterlife.php?action=${permText}&whichskill=${skill.id}`);
+            }
+        }
+    }
+    visitUrl(`afterlife.php?action=ascend&confirmascend=1&whichsign=${moonId}&gender=${kolGender}&whichclass=${playerClass.id}&whichpath=${path.id}&asctype=${lifestyle}&nopetok=1&noskillsok=1&lamepathok=1&lamesignok=1&pwd`, true);
+}
+/**
+ * Sets up various iotms you may want to use in the coming ascension
+ *
+ * @param ascensionPrep Configuration for various ascension prep settings. Any ommitted key will be kept as-is
+ * @param ascensionPrep.garden Garden to which to switch
+ * @param ascensionPrep.eudora Eudora to which to switch
+ * @param ascensionPrep.chateau Chateau configuration
+ * @param ascensionPrep.chateau.desk Chateau desk configuration
+ * @param ascensionPrep.chateau.ceiling Chateau ceiling configuration
+ * @param ascensionPrep.chateau.nightstand Chateau nightstand configuration
+ * @param ascensionPrep.throwOnFail If true, this will throw an error when it fails to switch something
+ */
+export function prepareAscension({ garden, eudora, chateau, throwOnFail, } = {}) {
+    throwOnFail = throwOnFail ?? true;
+    if (garden && !Object.getOwnPropertyNames(getCampground()).includes(garden)) {
+        use(Item.get(garden));
+        const gardenName = Object.getOwnPropertyNames(getCampground()).find(isGarden);
+        if (gardenName !== garden && throwOnFail) {
+            throw new AscensionPrepError(garden, gardenName);
+        }
+    }
+    if (eudora && eudoraItem().name !== eudora) {
+        const eudoraNumber = 1 + eudorae.indexOf(eudora);
+        if (!xpath(visitUrl("account.php?tab=correspondence"), `//select[@name="whichpenpal"]/option/@value`).includes(eudoraNumber.toString()) &&
+            throwOnFail) {
+            throw new AscensionPrepError(`Unable to swap eudora to ${eudora} because you are not subscribed to it.`);
+        }
+        else {
+            visitUrl(`account.php?actions[]=whichpenpal&whichpenpal=${eudoraNumber}&action=Update`, true);
+        }
+        if (eudoraItem() !== Item.get(eudora) && throwOnFail) {
+            throw new AscensionPrepError(eudora, eudoraItem());
+        }
+    }
+    if (chateau && ChateauMantegna.have()) {
+        const { desk, ceiling, nightstand } = chateau;
+        if (ceiling && ChateauMantegna.getCeiling() !== ceiling) {
+            if (!ChateauMantegna.changeCeiling(ceiling) && throwOnFail) {
+                throw new AscensionPrepError(ceiling, ChateauMantegna.getCeiling() ?? "unknown");
+            }
+        }
+        if (desk && ChateauMantegna.getDesk() !== desk) {
+            if (!ChateauMantegna.changeDesk(desk) && throwOnFail) {
+                throw new AscensionPrepError(desk, ChateauMantegna.getDesk() ?? "unknown");
+            }
+        }
+        if (nightstand && ChateauMantegna.getNightstand() !== nightstand) {
+            if (!ChateauMantegna.changeNightstand(nightstand) && throwOnFail) {
+                throw new AscensionPrepError(nightstand, ChateauMantegna.getNightstand() ?? "unknown");
+            }
+        }
+    }
+}

package/dist/challengePaths/2014/HeavyRains.d.ts

@@ -0,0 +1,22 @@
+import { Location, Monster } from "kolmafia";
+/**
+ * Cast Rain Man and fight the target monster
+ * @param target the monster to fight
+ */
+export declare function rainMan(target: Monster): void;
+/**
+ * Check if you can summon this monster using Rain Man
+ * @param target the monster to attempt to summon
+ * @returns true if you can summon the target monster, false otherwise
+ */
+export declare function canRainMan(target: Monster): boolean;
+export declare const RAIN_MONSTER_WINDOW_BEGIN = "Rain Monster window begin";
+export declare const RAIN_MONSTER_WINDOW_END = "Rain Monster window end";
+export declare const wanderers: readonly Monster[];
+/**
+ * Calculate the expected wandering monster based on current water level
+ * @param location the location to check for wanderers
+ * @returns The monster for this location given the current waterlevel
+ */
+export declare function expectedWanderer(location: Location): Monster;
+export declare const path: import("kolmafia").Path;

package/dist/challengePaths/2014/HeavyRains.js

@@ -0,0 +1,75 @@
+import { Modifier, Monster, monsterFactoidsAvailable, myRain, numericModifier, useSkill, visitUrl, } from "kolmafia";
+import { have } from "../../lib";
+import { withChoice } from "../../property";
+import { $monster, $path, $skill } from "../../template-string";
+/**
+ * Cast Rain Man and fight the target monster
+ * @param target the monster to fight
+ */
+export function rainMan(target) {
+    if (canRainMan(target)) {
+        withChoice(970, `1&whichmonster=${target.id}`, () => useSkill($skill `Rain Man`));
+    }
+}
+/**
+ * Check if you can summon this monster using Rain Man
+ * @param target the monster to attempt to summon
+ * @returns true if you can summon the target monster, false otherwise
+ */
+export function canRainMan(target) {
+    if (!have($skill `Rain Man`) || // having the skill implies you are in heavy rains path
+        myRain() < 50 ||
+        !target.copyable ||
+        target.id < 0) {
+        return false;
+    }
+    if (monsterFactoidsAvailable(target, false) > 0) {
+        return true;
+    }
+    const page = withChoice(970, 2, () => visitUrl(`runskillz.php?pwd&action=Skillz&whichskill=${$skill `Rain Man`.id}&quantity=1`));
+    return page.indexOf(`<option value=${target.id}>`) > 0;
+}
+export const RAIN_MONSTER_WINDOW_BEGIN = "Rain Monster window begin";
+export const RAIN_MONSTER_WINDOW_END = "Rain Monster window end";
+export const wanderers = Object.freeze(Monster.get([
+    "giant isopod",
+    "gourmet gourami",
+    "freshwater bonefish",
+    "alley catfish",
+    "piranhadon",
+    "giant tardigrade",
+    "aquaconda",
+    "storm cow",
+]));
+/**
+ * Calculate the expected wandering monster based on current water level
+ * @param location the location to check for wanderers
+ * @returns The monster for this location given the current waterlevel
+ */
+export function expectedWanderer(location) {
+    const difficultyWaterLevel = location.difficultyLevel === "low" ? 1 : 2;
+    const environmentWaterLevel = location.environment === "underground"
+        ? 4
+        : location.environment === "indoor"
+            ? 2
+            : 1; // location.environment === "unknown" || "outdoors"
+    const waterLevel = numericModifier(Modifier.get("Water Level")) +
+        difficultyWaterLevel +
+        environmentWaterLevel;
+    if (waterLevel > 1 && waterLevel < 6) {
+        return wanderers[waterLevel - 1];
+    }
+    else if (waterLevel === 6 && location.environment === "underground") {
+        return $monster `giant tardigrade`;
+    }
+    else if (waterLevel === 6 && location.environment === "indoor") {
+        return $monster `aquaconda`;
+    }
+    else if (waterLevel === 6 && location.environment === "outdoor") {
+        return $monster `storm cow`;
+    }
+    else {
+        return $monster `giant isopod`;
+    }
+}
+export const path = $path `Heavy Rains`;

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

@@ -0,0 +1,125 @@
+import { Effect } from "kolmafia";
+import { Requirement } from "../../maximize";
+export default class CommunityService {
+    private choice;
+    private stat;
+    private property;
+    private predictor;
+    private maximizeRequirements;
+    private timer;
+    /**
+     * 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.
+     */
+    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"
+     */
+    get name(): string;
+    /**
+     *  @returns The predicted number of turns this test will take given your character's current state.
+     */
+    get prediction(): number;
+    /**
+     * @returns A Requirement object, if applicable, that aligns with the things needed to maximize for this particular test.
+     */
+    get requirement(): Requirement | null;
+    /**
+     * Start the time & turn counter for the Test in question.
+     */
+    startTimer(): void;
+    private static taskTimers;
+    /**
+     * Start the time & turn counter for the given task
+     *
+     * @param name The name of the task to start the counter of
+     */
+    static startTimer(name: string): void;
+    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.
+     */
+    isDone(): boolean;
+    /**
+     * Maximizes based on the Requirement associated with this particular test.
+     */
+    maximize(): void;
+    /**
+     * 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(): 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. 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 | 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;
+    /**
+     * @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: Effect[]): 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;
+    static path: import("kolmafia").Path;
+}