libram 0.8.28 → 0.8.30

package/dist/propertyTyping.js

@@ -0,0 +1,91 @@
+import { booleanProperties, familiarProperties, locationProperties, monsterProperties, numericOrStringProperties, numericProperties, phylumProperties, statProperties, stringProperties, } from "./propertyTypes";
+const booleanPropertiesSet = new Set(booleanProperties);
+const numericPropertiesSet = new Set(numericProperties);
+const numericOrStringPropertiesSet = new Set(numericOrStringProperties);
+const stringPropertiesSet = new Set(stringProperties);
+const locationPropertiesSet = new Set(locationProperties);
+const monsterPropertiesSet = new Set(monsterProperties);
+const familiarPropertiesSet = new Set(familiarProperties);
+const statPropertiesSet = new Set(statProperties);
+const phylumPropertiesSet = new Set(phylumProperties);
+/**
+ * Determine whether a property has a boolean value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a boolean value
+ */
+export function isBooleanProperty(property) {
+    return booleanPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a numeric value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a numeric value
+ */
+export function isNumericProperty(property) {
+    return numericPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a numeric or string value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a numeric or string value
+ */
+export function isNumericOrStringProperty(property) {
+    return numericOrStringPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a string value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a string value
+ */
+export function isStringProperty(property) {
+    return stringPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a Location value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a Location value
+ */
+export function isLocationProperty(property) {
+    return locationPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a Monster value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a Monster value
+ */
+export function isMonsterProperty(property) {
+    return monsterPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a Familiar value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a Familiar value
+ */
+export function isFamiliarProperty(property) {
+    return familiarPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a Stat value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a Stat value
+ */
+export function isStatProperty(property) {
+    return statPropertiesSet.has(property);
+}
+/**
+ * Determine whether a property has a Phylum value
+ *
+ * @param property Property to check
+ * @returns Whether the supplied property has a Phylum value
+ */
+export function isPhylumProperty(property) {
+    return phylumPropertiesSet.has(property);
+}

package/dist/resources/2007/CandyHearts.d.ts

@@ -0,0 +1,9 @@
+import { Item } from "kolmafia";
+/**
+ * @returns true if the player can Summon Candy Heart
+ */
+export declare function have(): boolean;
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export declare function expected(): Map<Item, number>;

package/dist/resources/2007/CandyHearts.js

@@ -0,0 +1,24 @@
+import { have as _have } from "../../lib";
+import { $item, $skill } from "../../template-string";
+const summonSkill = $skill `Summon Candy Heart`;
+const libramChance = 1.0 / 6;
+const libramExpected = new Map([
+    [$item `green candy heart`, libramChance],
+    [$item `lavender candy heart`, libramChance],
+    [$item `orange candy heart`, libramChance],
+    [$item `pink candy heart`, libramChance],
+    [$item `white candy heart`, libramChance],
+    [$item `yellow candy heart`, libramChance],
+]);
+/**
+ * @returns true if the player can Summon Candy Heart
+ */
+export function have() {
+    return _have(summonSkill);
+}
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export function expected() {
+    return libramExpected;
+}

package/dist/resources/2008/DivineFavors.d.ts

@@ -0,0 +1,9 @@
+import { Item } from "kolmafia";
+/**
+ * @returns true if the player can Summon Party Favors
+ */
+export declare function have(): boolean;
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export declare function expected(): Map<Item, number>;

package/dist/resources/2008/DivineFavors.js

@@ -0,0 +1,27 @@
+import { have as _have } from "../../lib";
+import { get } from "../../property";
+import { $item, $skill } from "../../template-string";
+const summonSkill = $skill `Summon Party Favor`;
+/**
+ * @returns true if the player can Summon Party Favors
+ */
+export function have() {
+    return _have(summonSkill);
+}
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export function expected() {
+    const rareSummons = get("_favorRareSummons");
+    const totalRareChance = 1.0 / 2 ** (rareSummons + 1);
+    const commonChance = (1.0 - totalRareChance) / 3;
+    const rareChance = totalRareChance / 3;
+    return new Map([
+        [$item `divine blowout`, commonChance],
+        [$item `divine can of silly string`, commonChance],
+        [$item `divine noisemaker`, commonChance],
+        [$item `divine champagne flute`, rareChance],
+        [$item `divine champagne popper`, rareChance],
+        [$item `divine cracker`, rareChance],
+    ]);
+}

package/dist/resources/2008/Stickers.d.ts

@@ -0,0 +1,49 @@
+import { Item } from "kolmafia";
+export declare const stickers: {
+    readonly unicorn: Item;
+    readonly apple: Item;
+    readonly UPC: Item;
+    readonly wrestler: Item;
+    readonly dragon: Item;
+    readonly rockband: Item;
+};
+export declare type Sticker = keyof typeof stickers;
+/**
+ * @returns Whether the player has the Summon Stickers skill
+ */
+export declare function have(): boolean;
+/**
+ * @returns The player's current sticker weapon
+ */
+export declare function weapon(): Item | null;
+declare const weapons: {
+    sword: Item;
+    crossbow: Item;
+};
+/**
+ * Make a sword
+ *
+ * @param sticker Sticker to use when making the sword
+ */
+export declare function makeSword(sticker: Sticker): void;
+/**
+ * Change weapon mode
+ *
+ * @param mode New weapon mode
+ * @returns Success
+ */
+export declare function foldWeapon(mode: keyof typeof weapons): boolean;
+/**
+ * Get current stickers on sticker weapon
+ *
+ * @returns Tuple of stickers
+ */
+export declare function currentStickers(): [Item, Item, Item];
+/**
+ * Set configuration for sticker weapon
+ *
+ * @param options Tuple of either sticker or null
+ * @returns Resultant configuration
+ */
+export declare function setStickers(...options: [Sticker | null, Sticker | null, Sticker | null]): [Item, Item, Item];
+export {};

package/dist/resources/2008/Stickers.js

@@ -0,0 +1,84 @@
+import { availableAmount, equippedItem, haveSkill, retrieveItem, visitUrl, } from "kolmafia";
+import { $item, $items, $skill, $slots } from "../../template-string";
+export const stickers = {
+    unicorn: $item `scratch 'n' sniff unicorn sticker`,
+    apple: $item `scratch 'n' sniff apple sticker`,
+    UPC: $item `scratch 'n' sniff UPC sticker`,
+    wrestler: $item `scratch 'n' sniff wrestler sticker`,
+    dragon: $item `scratch 'n' sniff dragon sticker`,
+    rockband: $item `scratch 'n' sniff rock band sticker`,
+};
+/**
+ * @returns Whether the player has the Summon Stickers skill
+ */
+export function have() {
+    return haveSkill($skill `Summon Stickers`);
+}
+/**
+ * @returns The player's current sticker weapon
+ */
+export function weapon() {
+    return ($items `scratch 'n' sniff sword, scratch 'n' sniff crossbow`.find((i) => availableAmount(i)) ?? null);
+}
+const weapons = {
+    sword: $item `scratch 'n' sniff sword`,
+    crossbow: $item `scratch 'n' sniff crossbow`,
+};
+/**
+ * Make a sword
+ *
+ * @param sticker Sticker to use when making the sword
+ */
+export function makeSword(sticker) {
+    if (weapon())
+        return;
+    visitUrl(`bedazzle.php?action=juststick&sticker=${stickers[sticker].id}&pwd`);
+}
+/**
+ * Change weapon mode
+ *
+ * @param mode New weapon mode
+ * @returns Success
+ */
+export function foldWeapon(mode) {
+    const currentWep = weapon();
+    if (!currentWep)
+        return false;
+    if (weapons[mode] === currentWep)
+        return true;
+    visitUrl("bedazzle.php?action=fold&pwd");
+    return weapons[mode] === currentWep;
+}
+/**
+ * Get current stickers on sticker weapon
+ *
+ * @returns Tuple of stickers
+ */
+export function currentStickers() {
+    return $slots `sticker1, sticker2, sticker3`.map((s) => equippedItem(s));
+}
+/**
+ * Set configuration for sticker weapon
+ *
+ * @param options Tuple of either sticker or null
+ * @returns Resultant configuration
+ */
+export function setStickers(...options) {
+    for (const s of options) {
+        if (s)
+            retrieveItem(stickers[s], options.filter((x) => x === s).length);
+    }
+    visitUrl("bedazzle.php");
+    const start = currentStickers();
+    for (let i = 0; i <= 2; i++) {
+        const sticker = options[i];
+        if (!sticker)
+            continue;
+        const item = stickers[sticker];
+        if (start[i] === item)
+            continue;
+        visitUrl(`bedazzle.php?action=peel&slot=${i + 1}&pwd`);
+        visitUrl(`bedazzle.php?action=stick&slot=${i + 1}&sticker=${item.id}&pwd`);
+    }
+    return currentStickers();
+}

package/dist/resources/2009/Bandersnatch.d.ts

@@ -0,0 +1,56 @@
+import { Effect } from "kolmafia";
+/**
+ * Determines whether the player has the Frumious Bandersnatch in their
+ * terrarium
+ *
+ * @returns Whether the player has a Frumious Bandersnatch
+ */
+export declare function have(): boolean;
+/**
+ * Get the number of free runaways that have already been used
+ *
+ * @see StompingBoots with which the Bandersnatch shares a counter
+ * @returns Number of free runaways used today
+ */
+export declare function getRunaways(): number;
+/**
+ * Determine the total number of free runaways that the player can
+ * get from their Bandersnatch
+ *
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns Current maximum runaways
+ */
+export declare function getMaxRunaways(considerWeightAdjustment?: boolean): number;
+/**
+ * Determine the number of remaining free runaways the player can
+ * get from their Bandersnatch
+ *
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns Current maximum runaways reamining
+ */
+export declare function getRemainingRunaways(considerWeightAdjustment?: boolean): number;
+/**
+ * Determine whether the player could use their Bandersnatch to
+ * get a free run in theory
+ *
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns Whether a free run is theoretically possible right now
+ */
+export declare function couldRunaway(considerWeightAdjustment?: boolean): boolean;
+/**
+ * Determine whether the player can use their Bandersnatch to get a
+ * free run right now
+ *
+ * @returns Whether a free run is actually possible right now
+ */
+export declare function canRunaway(): boolean;
+/**
+ * Prepare a Bandersnatch runaway.
+ *
+ * This will cast Ode to Booze and take your Bandersnatch with you.
+ * If any of those steps fail, it will return false.
+ *
+ * @param songsToRemove Ordered list of songs that could be shrugged to make room for Ode to Booze
+ * @returns Success
+ */
+export declare function prepareRunaway(songsToRemove: Effect[]): boolean;

package/dist/resources/2009/Bandersnatch.js

@@ -0,0 +1,93 @@
+import { familiarWeight, useFamiliar, useSkill, weightAdjustment, } from "kolmafia";
+import { have as _have, canRememberSong, getActiveSongs, isCurrentFamiliar, uneffect, } from "../../lib";
+import { get } from "../../property";
+import { $effect, $familiar, $skill } from "../../template-string";
+const familiar = $familiar `Frumious Bandersnatch`;
+/**
+ * Determines whether the player has the Frumious Bandersnatch in their
+ * terrarium
+ *
+ * @returns Whether the player has a Frumious Bandersnatch
+ */
+export function have() {
+    return _have(familiar);
+}
+/**
+ * Get the number of free runaways that have already been used
+ *
+ * @see StompingBoots with which the Bandersnatch shares a counter
+ * @returns Number of free runaways used today
+ */
+export function getRunaways() {
+    return get("_banderRunaways");
+}
+/**
+ * Determine the total number of free runaways that the player can
+ * get from their Bandersnatch
+ *
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns Current maximum runaways
+ */
+export function getMaxRunaways(considerWeightAdjustment = true) {
+    const weightBuffs = considerWeightAdjustment ? weightAdjustment() : 0;
+    return Math.floor((familiarWeight(familiar) + weightBuffs) / 5);
+}
+/**
+ * Determine the number of remaining free runaways the player can
+ * get from their Bandersnatch
+ *
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns Current maximum runaways reamining
+ */
+export function getRemainingRunaways(considerWeightAdjustment = true) {
+    return Math.max(0, getMaxRunaways(considerWeightAdjustment) - getRunaways());
+}
+/**
+ * Determine whether the player could use their Bandersnatch to
+ * get a free run in theory
+ *
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns Whether a free run is theoretically possible right now
+ */
+export function couldRunaway(considerWeightAdjustment = true) {
+    return have() && getRemainingRunaways(considerWeightAdjustment) > 0;
+}
+const odeSkill = $skill `The Ode to Booze`;
+const odeEffect = $effect `Ode to Booze`;
+/**
+ * Determine whether the player can use their Bandersnatch to get a
+ * free run right now
+ *
+ * @returns Whether a free run is actually possible right now
+ */
+export function canRunaway() {
+    return isCurrentFamiliar(familiar) && couldRunaway() && _have(odeEffect);
+}
+/**
+ * Prepare a Bandersnatch runaway.
+ *
+ * This will cast Ode to Booze and take your Bandersnatch with you.
+ * If any of those steps fail, it will return false.
+ *
+ * @param songsToRemove Ordered list of songs that could be shrugged to make room for Ode to Booze
+ * @returns Success
+ */
+export function prepareRunaway(songsToRemove) {
+    if (!_have(odeEffect)) {
+        if (!_have(odeSkill)) {
+            return false;
+        }
+        if (!canRememberSong()) {
+            const activeSongs = getActiveSongs();
+            for (const song of songsToRemove) {
+                if (activeSongs.includes(song) && uneffect(song)) {
+                    break;
+                }
+            }
+        }
+        if (!useSkill(odeSkill)) {
+            return false;
+        }
+    }
+    return useFamiliar(familiar);
+}

package/dist/resources/2009/LoveSongs.d.ts

@@ -0,0 +1,9 @@
+import { Item } from "kolmafia";
+/**
+ * @returns true if the player can Summon Love Song
+ */
+export declare function have(): boolean;
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export declare function expected(): Map<Item, number>;

package/dist/resources/2009/LoveSongs.js

@@ -0,0 +1,24 @@
+import { have as _have } from "../../lib";
+import { $item, $skill } from "../../template-string";
+const summonSkill = $skill `Summon Love Song`;
+const libramChance = 1.0 / 6;
+const libramExpected = new Map([
+    [$item `love song of disturbing obsession`, libramChance],
+    [$item `love song of icy revenge`, libramChance],
+    [$item `love song of naughty innuendo`, libramChance],
+    [$item `love song of smoldering passion`, libramChance],
+    [$item `love song of sugary cuteness`, libramChance],
+    [$item `love song of vague ambiguity`, libramChance],
+]);
+/**
+ * @returns true if the player can Summon Love Song
+ */
+export function have() {
+    return _have(summonSkill);
+}
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export function expected() {
+    return libramExpected;
+}

package/dist/resources/2009/SpookyPutty.d.ts

@@ -0,0 +1,31 @@
+import { Monster } from "kolmafia";
+/**
+ * See whether the player has a Spooky Putty item in some form
+ *
+ * @returns Whether the player has any Spooky Putty item
+ */
+export declare function have(): boolean;
+/**
+ * Get spooky putty sheet copies made today
+ *
+ * @returns Number of spooky putty sheet copies made
+ */
+export declare function getSpookyPuttySheetCopiesMade(): number;
+/**
+ * Prepares a spooky putty sheet for use
+ *
+ * @returns Success
+ */
+export declare function prepareSpookyPuttySheet(): boolean;
+/**
+ * Get the current puttied monster
+ *
+ * @returns Current puttied monster
+ */
+export declare function getSpookyPuttySheetMonster(): Monster | null;
+/**
+ * Use the spooky putty sheet (i.e. fight the monster probably)
+ *
+ * @returns Success
+ */
+export declare function useSpookyPuttySheet(): boolean;

package/dist/resources/2009/SpookyPutty.js

@@ -0,0 +1,49 @@
+import { cliExecute, use } from "kolmafia";
+import { getFoldGroup, have as haveItem } from "../../lib";
+import { get } from "../../property";
+import { $item } from "../../template-string";
+const sheet = $item `Spooky Putty sheet`;
+/**
+ * See whether the player has a Spooky Putty item in some form
+ *
+ * @returns Whether the player has any Spooky Putty item
+ */
+export function have() {
+    return getFoldGroup(sheet).some((item) => haveItem(item));
+}
+/**
+ * Get spooky putty sheet copies made today
+ *
+ * @returns Number of spooky putty sheet copies made
+ */
+export function getSpookyPuttySheetCopiesMade() {
+    return Math.max(0, get("spookyPuttyCopiesMade"));
+}
+/**
+ * Prepares a spooky putty sheet for use
+ *
+ * @returns Success
+ */
+export function prepareSpookyPuttySheet() {
+    if (!have())
+        return false;
+    if (haveItem(sheet))
+        return true;
+    return cliExecute("fold Spooky putty sheet");
+}
+/**
+ * Get the current puttied monster
+ *
+ * @returns Current puttied monster
+ */
+export function getSpookyPuttySheetMonster() {
+    return get("spookyPuttyMonster");
+}
+/**
+ * Use the spooky putty sheet (i.e. fight the monster probably)
+ *
+ * @returns Success
+ */
+export function useSpookyPuttySheet() {
+    return use(sheet);
+}

package/dist/resources/2010/Brickos.d.ts

@@ -0,0 +1,9 @@
+import { Item } from "kolmafia";
+/**
+ * @returns true if the player can Summon BRICKOs
+ */
+export declare function have(): boolean;
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export declare function expected(): Map<Item, number>;

package/dist/resources/2010/Brickos.js

@@ -0,0 +1,21 @@
+import { have as _have } from "../../lib";
+import { get } from "../../property";
+import { $item, $skill } from "../../template-string";
+const summonSkill = $skill `Summon BRICKOs`;
+/**
+ * @returns true if the player can Summon BRICKOs
+ */
+export function have() {
+    return _have(summonSkill);
+}
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export function expected() {
+    const eyeSummons = get("_brickoEyeSummons");
+    const eyeChance = eyeSummons === 3 ? 0.0 : eyeSummons === 0 ? 0.5 : 1.0 / 3.0;
+    return new Map([
+        [$item `BRICKO eye brick`, eyeChance],
+        [$item `BRICKO brick`, 3.0 - eyeChance],
+    ]);
+}

package/dist/resources/2010/CrownOfThrones.d.ts

@@ -0,0 +1,68 @@
+import { Familiar, Item } from "kolmafia";
+import { NumericModifier } from "../../modifierTypes";
+export declare type FamiliarRider = {
+    familiar: Familiar;
+    drops: number | Item[] | Map<Item, number>;
+    probability: number;
+    dropPredicate?: () => boolean;
+};
+export declare const ridingFamiliars: readonly FamiliarRider[];
+/**
+ * Value a specified familiar Crown rider
+ *
+ * @param rider Familiar to value
+ * @param modifierValueFunction Value of the extra modifiers the familiar provides,
+ * @param dropsValueFunction Value to assign the drops of the familiar gives
+ * @param ignoreLimitedDrops Whether to ignore drops that are daily or otherwise limited
+ * @returns Rider value (in meat)
+ */
+export declare function valueRider(rider: FamiliarRider, modifierValueFunction: (familiar: Familiar) => number, dropsValueFunction: (drops: Item[] | Map<Item, number>) => number, ignoreLimitedDrops?: boolean): number;
+declare type RiderMode = {
+    modifierValueFunction: (familiar: Familiar) => number;
+    dropsValueFunction: (drops: Item[] | Map<Item, number>) => number;
+    ignoreLimitedDrops: boolean;
+    excludeCurrentFamiliar: boolean;
+};
+/**
+ * Creates a rider mode for this session
+ *
+ * @param name Rider mode name
+ * @param details An object consisting of various settings for the RiderMode:
+ * @param details.modifierValueFunction Function to value a familiar itself, often using modifiers,
+ * @param details.dropsValueFunction Function to value the drops of a familiar, which are stored as an `Item[]` or `Map<Item, number>`
+ * @param details.ignoreLimitedDrops Whether to ignore daily or otherwise limited drops
+ * @param details.excludeCurrentFamiliar Whether to exclude the player's current familiar
+ * @returns Map of all rider modes created this session, including the one that was just made
+ */
+export declare function createRiderMode(name: string, details: Partial<RiderMode>): Map<string, RiderMode>;
+/**
+ * @param name The name of the `RiderMode` to check
+ * @returns Whether or not said `RiderMode` exists
+ */
+export declare function hasRiderMode(name: string): boolean;
+/**
+ * Pick a rider
+ *
+ * @param mode Mode by which to select possible riders
+ * @returns Picked faimiliar rider or null if no rider could be selected
+ */
+export declare function pickRider(mode: string): FamiliarRider | null;
+/**
+ * Find the associated NumericModifier for a given familiar when enthroned or bjornified
+ *
+ * @param modifier The NumericModifier in question
+ * @param familiar The Familiar in question
+ * @returns The value of the given numeric modifier for the Crown of Thrones (or buddy bjorn) when the given familiar is encromulated
+ */
+export declare function getModifier(modifier: NumericModifier, familiar: Familiar): number;
+/**
+ * Create a `modifierValueFunction` for a familiar.
+ *
+ * @param modifiers An array consisting of the `NumericModifier`s relevant to your valuation
+ * @param functions An object keyed by `NumericModifier`s whose values are functions that map the the result of a modifier to its corresponding valuation
+ * @returns A function that maps a familiar to the value of its modifiers in the crown of thrones or buddy bjorn.
+ */
+export declare function createModifierValueFunction<T extends NumericModifier>(modifiers: T[], functions: {
+    [x in T]: (mod: number) => number;
+}): (familiar: Familiar) => number;
+export {};