libram 0.3.2 → 0.4.2

package/dist/resources/2011/Gygaxian.js

@@ -0,0 +1,24 @@
+import { $item, $skill } from "../../template-string";
+import { have as _have } from "../../lib";
+export const summonSkill = $skill `Summon Dice`;
+const libramChance = 1.0 / 6;
+const libramExpected = new Map([
+    [$item `d4`, libramChance],
+    [$item `d6`, libramChance],
+    [$item `d8`, libramChance],
+    [$item `d10`, libramChance],
+    [$item `d12`, libramChance],
+    [$item `d20`, libramChance],
+]);
+/**
+ * @returns true if the player can Summon Dice
+ */
+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/2011/ObtuseAngel.js

@@ -1,91 +1,49 @@
-"use strict";
-
-require("core-js/modules/es.array.slice.js");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.have = have;
-exports.getBadlyRomanticArrowUses = getBadlyRomanticArrowUses;
-exports.haveBadlyRomanticArrowUsesRemaining = haveBadlyRomanticArrowUsesRemaining;
-exports.couldUseBadlyRomanticArrow = couldUseBadlyRomanticArrow;
-exports.prepareBadlyRomanticArrow = prepareBadlyRomanticArrow;
-exports.canUseBadlyRomanticArrow = canUseBadlyRomanticArrow;
-exports.getBadlyRomanticArrowMonster = getBadlyRomanticArrowMonster;
-exports.BadlyRomanticArrow = exports.familiar = void 0;
-
-var _kolmafia = require("kolmafia");
-
-var _Copier = require("../../Copier");
-
-var _lib = require("../../lib");
-
-var _property = require("../../property");
-
-var _templateString = require("../../template-string");
-
-var _templateObject;
-
-function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
-var familiar = (0, _templateString.$familiar)(_templateObject || (_templateObject = _taggedTemplateLiteral(["Obtuse Angel"])));
+import { useFamiliar } from "kolmafia";
+import { Copier } from "../../Copier";
+import { have as _have, isCurrentFamiliar } from "../../lib";
+import { get } from "../../property";
+import { $familiar } from "../../template-string";
+export const familiar = $familiar `Obtuse Angel`;
 /**
  * Returns true if the player has an Obtuse Angel
  */
-
-exports.familiar = familiar;
-
-function have() {
-  return (0, _lib.have)(familiar);
+export function have() {
+    return _have(familiar);
 }
 /**
  * Returns number of badly romantic arrows used
  */
-
-
-function getBadlyRomanticArrowUses() {
-  return Math.max(0, (0, _property.get)("_badlyRomanticArrows"));
+export function getBadlyRomanticArrowUses() {
+    return Math.max(0, get("_badlyRomanticArrows"));
 }
 /**
  * Returns true if badly romantic arrow can still be used
  */
-
-
-function haveBadlyRomanticArrowUsesRemaining() {
-  return getBadlyRomanticArrowUses() === 0;
+export function haveBadlyRomanticArrowUsesRemaining() {
+    return getBadlyRomanticArrowUses() === 0;
 }
 /**
  * Returns true if the player could use badly romantic arrow in theory
  */
-
-
-function couldUseBadlyRomanticArrow() {
-  return have() && haveBadlyRomanticArrowUsesRemaining();
+export function couldUseBadlyRomanticArrow() {
+    return have() && haveBadlyRomanticArrowUsesRemaining();
 }
 /**
  * Prepares badly romantic arrow for use
  */
-
-
-function prepareBadlyRomanticArrow() {
-  return (0, _kolmafia.useFamiliar)(familiar);
+export function prepareBadlyRomanticArrow() {
+    return useFamiliar(familiar);
 }
 /**
  * Returns true if the player can use badly romantic arrow right now
  */
-
-
-function canUseBadlyRomanticArrow() {
-  return (0, _lib.isCurrentFamiliar)(familiar) && haveBadlyRomanticArrowUsesRemaining();
+export function canUseBadlyRomanticArrow() {
+    return isCurrentFamiliar(familiar) && haveBadlyRomanticArrowUsesRemaining();
 }
 /**
  * Returns the current badly romantic arrow monster target
  */
-
-
-function getBadlyRomanticArrowMonster() {
-  return (0, _property.get)("romanticTarget");
+export function getBadlyRomanticArrowMonster() {
+    return get("romanticTarget");
 }
-
-var BadlyRomanticArrow = new _Copier.Copier(() => couldUseBadlyRomanticArrow(), () => prepareBadlyRomanticArrow(), () => canUseBadlyRomanticArrow(), () => getBadlyRomanticArrowMonster());
-exports.BadlyRomanticArrow = BadlyRomanticArrow;
+export const BadlyRomanticArrow = new Copier(() => couldUseBadlyRomanticArrow(), () => prepareBadlyRomanticArrow(), () => canUseBadlyRomanticArrow(), () => getBadlyRomanticArrowMonster());

package/dist/resources/2012/RainDoh.js

@@ -1,43 +1,17 @@
-"use strict";
-
-require("core-js/modules/es.array.slice.js");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.have = have;
-exports.getRainDohBlackBoxCopiesMade = getRainDohBlackBoxCopiesMade;
-exports.getRainDohBlackBoxMonster = getRainDohBlackBoxMonster;
-exports.useRainDohBlackBox = useRainDohBlackBox;
-exports.box = void 0;
-
-var _kolmafia = require("kolmafia");
-
-var _lib = require("../../lib");
-
-var _property = require("../../property");
-
-var _templateString = require("../../template-string");
-
-var _templateObject;
-
-function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
-var box = (0, _templateString.$item)(_templateObject || (_templateObject = _taggedTemplateLiteral(["Rain-Doh black box"])));
-exports.box = box;
-
-function have() {
-  return (0, _lib.getFoldGroup)(box).some(item => (0, _lib.have)(item));
+import { use } from "kolmafia";
+import { getFoldGroup, have as haveItem } from "../../lib";
+import { get } from "../../property";
+import { $item } from "../../template-string";
+export const box = $item `Rain-Doh black box`;
+export function have() {
+    return getFoldGroup(box).some((item) => haveItem(item));
 }
-
-function getRainDohBlackBoxCopiesMade() {
-  return Math.max(0, (0, _property.get)("_raindohCopiesMade"));
+export function getRainDohBlackBoxCopiesMade() {
+    return Math.max(0, get("_raindohCopiesMade"));
 }
-
-function getRainDohBlackBoxMonster() {
-  return (0, _property.get)("rainDohMonster");
+export function getRainDohBlackBoxMonster() {
+    return get("rainDohMonster");
+}
+export function useRainDohBlackBox() {
+    return use(box);
 }
-
-function useRainDohBlackBox() {
-  return (0, _kolmafia.use)(box);
-}

package/dist/resources/2012/Resolutions.d.ts

@@ -0,0 +1,9 @@
+export declare const summonSkill: Skill;
+/**
+ * @returns true if the player can Summon Resolutions
+ */
+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/2012/Resolutions.js

@@ -0,0 +1,28 @@
+import { $item, $skill } from "../../template-string";
+import { have as _have } from "../../lib";
+export const summonSkill = $skill `Summon Resolutions`;
+const commonChance = 0.98 / 6;
+const rareChance = 0.02 / 3;
+const libramExpected = new Map([
+    [$item `resolution: be feistier`, commonChance],
+    [$item `resolution: be happier`, commonChance],
+    [$item `resolution: be sexier`, commonChance],
+    [$item `resolution: be smarter`, commonChance],
+    [$item `resolution: be stronger`, commonChance],
+    [$item `resolution: be wealthier`, commonChance],
+    [$item `resolution: be kinder`, rareChance],
+    [$item `resolution: be luckier`, rareChance],
+    [$item `resolution: be more adventurous`, rareChance],
+]);
+/**
+ * @returns true if the player can Summon Resolutions
+ */
+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/2013/Florist.d.ts

@@ -0,0 +1,61 @@
+import { EnvironmentType } from "../../lib";
+declare class Flower {
+    name: string;
+    id: number;
+    environment: EnvironmentType;
+    modifier: string;
+    territorial: boolean;
+    constructor(name: string, id: number, environment: EnvironmentType, modifier: string, territorial?: boolean);
+    plantNamesInZone(location?: Location): string[] | undefined;
+    plantsInZone(location?: Location): Flower[] | undefined;
+    isPlantedHere(location?: Location): boolean;
+    available(location?: Location): boolean;
+    dig(): boolean;
+    plant(): boolean;
+}
+export declare function have(): boolean;
+export declare function flowersIn(location: Location): Flower[];
+export declare function flowersAvailableFor(location?: Location): Flower[];
+export declare function isFull(location?: Location): boolean;
+export declare const RabidDogwood: Flower;
+export declare const Rutabeggar: Flower;
+export declare const RadishRadish: Flower;
+export declare const Artichoker: Flower;
+export declare const SmokeRa: Flower;
+export declare const SkunkCabbage: Flower;
+export declare const DeadlyCinnamon: Flower;
+export declare const CeleryStalker: Flower;
+export declare const LettuceSpray: Flower;
+export declare const SeltzerWatercress: Flower;
+export declare const WarLily: Flower;
+export declare const StealingMagnolia: Flower;
+export declare const CannedSpinach: Flower;
+export declare const Impatiens: Flower;
+export declare const SpiderPlant: Flower;
+export declare const RedFern: Flower;
+export declare const BamBoo: Flower;
+export declare const ArcticMoss: Flower;
+export declare const AloeGuvnor: Flower;
+export declare const PitcherPlant: Flower;
+export declare const BlusteryPuffball: Flower;
+export declare const HornOfPlenty: Flower;
+export declare const WizardsWig: Flower;
+export declare const ShuffleTruffle: Flower;
+export declare const DisLichen: Flower;
+export declare const LooseMorels: Flower;
+export declare const FoulToadstool: Flower;
+export declare const Chillterelle: Flower;
+export declare const Portlybella: Flower;
+export declare const MaxHeadshroom: Flower;
+export declare const Spankton: Flower;
+export declare const Kelptomaniac: Flower;
+export declare const Crookweed: Flower;
+export declare const ElectricEelgrass: Flower;
+export declare const Duckweed: Flower;
+export declare const OrcaOrchid: Flower;
+export declare const Sargassum: Flower;
+export declare const SubSeaRose: Flower;
+export declare const Snori: Flower;
+export declare const UpSeaDaisy: Flower;
+export declare const all: readonly Flower[];
+export {};

package/dist/resources/2013/Florist.js

@@ -0,0 +1,149 @@
+import { floristAvailable, getFloristPlants, myLocation, visitUrl, } from "kolmafia";
+import { get } from "../../property";
+class Flower {
+    constructor(name, id, environment, modifier, territorial = false) {
+        this.name = name;
+        this.id = id;
+        this.environment = environment;
+        this.modifier = modifier;
+        this.territorial = territorial;
+    }
+    plantNamesInZone(location = myLocation()) {
+        return getFloristPlants()[location.toString()];
+    }
+    plantsInZone(location = myLocation()) {
+        return this.plantNamesInZone(location)
+            ?.map((flowerName) => toFlower(flowerName))
+            .filter((flower) => flower !== undefined);
+    }
+    isPlantedHere(location = myLocation()) {
+        const plantedHere = this.plantNamesInZone(location)?.includes(this.name);
+        return plantedHere !== undefined && plantedHere;
+    }
+    available(location = myLocation()) {
+        return (this.environment === location.environment &&
+            !get("_floristPlantsUsed").includes(this.name) &&
+            !this.isPlantedHere(location));
+    }
+    dig() {
+        if (!this.isPlantedHere())
+            return false;
+        const flowers = this.plantNamesInZone();
+        if (!flowers || !flowers[2])
+            return false;
+        const plantNumber = getFloristPlants()[myLocation().toString()].indexOf(this.name);
+        visitUrl(`choice.php?option=2&whichchoice=720&pwd&plnti=${plantNumber}`);
+        return !this.isPlantedHere();
+    }
+    plant() {
+        if (this.isPlantedHere())
+            return true;
+        if (isFull())
+            return false;
+        visitUrl(`choice.php?whichchoice=720&whichoption=1&pwd&plant=${this.id}`);
+        return this.isPlantedHere();
+    }
+}
+export function have() {
+    return floristAvailable();
+}
+function toFlower(name) {
+    return all.find((flower) => name === flower.name);
+}
+export function flowersIn(location) {
+    const returnValue = [];
+    getFloristPlants()[location.toString()].map(toFlower)
+        .forEach((flower) => {
+        if (flower)
+            returnValue.push(flower);
+    });
+    return returnValue;
+}
+export function flowersAvailableFor(location = myLocation()) {
+    return all.filter((flower) => flower.available(location));
+}
+export function isFull(location = myLocation()) {
+    return flowersIn(location).length === 3;
+}
+export const RabidDogwood = new Flower("Rabid Dogwood", 1, "outdoor", "+30 Monster Level", true);
+export const Rutabeggar = new Flower("Rutabeggar", 2, "outdoor", "+25 Item Drop", true);
+export const RadishRadish = new Flower("Rad-ish Radish", 3, "outdoor", "+5 Moxie Experience", true);
+export const Artichoker = new Flower("Artichoker", 4, "outdoor", "Delevels enemies");
+export const SmokeRa = new Flower("Smoke-ra", 5, "outdoor", "Blocks attacks");
+export const SkunkCabbage = new Flower("Skunk Cabbage", 6, "outdoor", "Stench damage");
+export const DeadlyCinnamon = new Flower("Deadly Cinnamon", 7, "outdoor", "Hot damage");
+export const CeleryStalker = new Flower("Celery Stalker", 8, "outdoor", "Spooky damage");
+export const LettuceSpray = new Flower("Lettus Spray", 9, "outdoor", "Restores HP");
+export const SeltzerWatercress = new Flower("Seltzer Watercress", 10, "outdoor", "Restores MP");
+export const WarLily = new Flower("War Lily", 11, "indoor", "+30 Monster Level", true);
+export const StealingMagnolia = new Flower("Stealing Magnolia", 12, "indoor", "+25 Item Drop", true);
+export const CannedSpinach = new Flower("Canned Spinach", 13, "indoor", "+5 Muscle Experience", true);
+export const Impatiens = new Flower("Impatiens", 14, "indoor", "+25 Initiative");
+export const SpiderPlant = new Flower("Spider Plant", 15, "indoor", "Poison");
+export const RedFern = new Flower("Red Fern", 16, "indoor", "Delevels enemies");
+export const BamBoo = new Flower("Bam BOO!", 17, "indoor", "Spooky damage");
+export const ArcticMoss = new Flower("Arctic Moss", 18, "indoor", "Cold damage");
+export const AloeGuvnor = new Flower("Aloe Guv'nor", 19, "indoor", "Restores HP");
+export const PitcherPlant = new Flower("Pitcher Plant", 20, "indoor", "Restores MP");
+export const BlusteryPuffball = new Flower("Blustery Puffball", 21, "underground", "+30 Monster Level", true);
+export const HornOfPlenty = new Flower("Horn of Plenty", 22, "underground", "+25 Item Drop", true);
+export const WizardsWig = new Flower("Wizard's Wig", 23, "underground", "+5 Mysticality Experience", true);
+export const ShuffleTruffle = new Flower("Shuffle Truffle", 24, "underground", "+25 Initiative");
+export const DisLichen = new Flower("Dis Lichen", 25, "underground", "Delevels enemies");
+export const LooseMorels = new Flower("Loose Morels", 26, "underground", "Sleaze damage");
+export const FoulToadstool = new Flower("Foul Toadstool", 27, "underground", "Stench damage");
+export const Chillterelle = new Flower("Chillterelle", 28, "underground", "Cold damage");
+export const Portlybella = new Flower("Portlybella", 29, "underground", "Retores HP");
+export const MaxHeadshroom = new Flower("Max Headshroom", 30, "underground", "Restores MP");
+export const Spankton = new Flower("Spankton", 31, "underwater", "Delevels enemies", true);
+export const Kelptomaniac = new Flower("Kelptomaniac", 32, "underwater", "+40 Item Drop", true);
+export const Crookweed = new Flower("Crookweed", 33, "underwater", "+60 Meat Drop", true);
+export const ElectricEelgrass = new Flower("Electric Eelgrass", 34, "underwater", "Blocks attacks");
+export const Duckweed = new Flower("Duckweed", 35, "underwater", "Protects once");
+export const OrcaOrchid = new Flower("Orca Orchid", 36, "underwater", "Physical damage");
+export const Sargassum = new Flower("Sargassum", 37, "underwater", "Stench damage");
+export const SubSeaRose = new Flower("Sub-Sea Rose", 38, "underwater", "Cold damage");
+export const Snori = new Flower("Snori", 39, "underwater", "Restores HP, Restores MP");
+export const UpSeaDaisy = new Flower("Up Sea Daisy", 40, "underwater", "+30 Experience");
+export const all = Object.freeze([
+    RabidDogwood,
+    Rutabeggar,
+    RadishRadish,
+    Artichoker,
+    SmokeRa,
+    SkunkCabbage,
+    DeadlyCinnamon,
+    CeleryStalker,
+    LettuceSpray,
+    SeltzerWatercress,
+    WarLily,
+    StealingMagnolia,
+    CannedSpinach,
+    Impatiens,
+    SpiderPlant,
+    RedFern,
+    BamBoo,
+    ArcticMoss,
+    AloeGuvnor,
+    PitcherPlant,
+    BlusteryPuffball,
+    HornOfPlenty,
+    WizardsWig,
+    ShuffleTruffle,
+    DisLichen,
+    LooseMorels,
+    FoulToadstool,
+    Chillterelle,
+    Portlybella,
+    MaxHeadshroom,
+    Spankton,
+    Kelptomaniac,
+    Crookweed,
+    ElectricEelgrass,
+    Duckweed,
+    OrcaOrchid,
+    Sargassum,
+    SubSeaRose,
+    Snori,
+    UpSeaDaisy,
+]);

package/dist/resources/2013/PulledTaffy.d.ts

@@ -0,0 +1,9 @@
+export declare const summonSkill: Skill;
+/**
+ * @returns true if the player can Summon Taffy
+ */
+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/2013/PulledTaffy.js

@@ -0,0 +1,33 @@
+import { get } from "../../property";
+import { $item, $skill } from "../../template-string";
+import { have as _have } from "../../lib";
+export const summonSkill = $skill `Summon Taffy`;
+/**
+ * @returns true if the player can Summon Taffy
+ */
+export function have() {
+    return _have(summonSkill);
+}
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export function expected() {
+    const rareSummons = get("_taffyRareSummons");
+    const yellowSummons = get("_taffyYellowSummons");
+    const onlyYellow = yellowSummons === 0 && rareSummons === 3;
+    const totalRareChance = rareSummons < 4 ? 1.0 / 2 ** (rareSummons + 1) : 0.0;
+    const commonChance = (1.0 - totalRareChance) / 4;
+    const rareChance = onlyYellow
+        ? 0.0
+        : totalRareChance / (3 - get("_taffyYellowSummons"));
+    const yellowChance = yellowSummons === 1 ? 0.0 : onlyYellow ? totalRareChance : rareChance;
+    return new Map([
+        [$item `pulled blue taffy`, commonChance],
+        [$item `pulled orange taffy`, commonChance],
+        [$item `pulled violet taffy`, commonChance],
+        [$item `pulled red taffy`, commonChance],
+        [$item `pulled indigo taffy`, rareChance],
+        [$item `pulled green taffy`, rareChance],
+        [$item `pulled yellow taffy`, yellowChance],
+    ]);
+}

package/dist/resources/2014/WinterGarden.js

@@ -1,48 +1,20 @@
-"use strict";
-
-require("core-js/modules/es.array.slice.js");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.have = have;
-exports.haveUnfinishedIceSculpture = haveUnfinishedIceSculpture;
-exports.isUnfinishedIceSculptureUsed = isUnfinishedIceSculptureUsed;
-exports.couldUseUnfinishedIceSculpture = couldUseUnfinishedIceSculpture;
-exports.getUnfinishedIceSculptureMonster = getUnfinishedIceSculptureMonster;
-exports.UnfinishedIceSculpture = void 0;
-
-var _Copier = require("../../Copier");
-
-var _property = require("../../property");
-
-var _lib = require("../../lib");
-
-var _templateString = require("../../template-string");
-
-var _templateObject, _templateObject2, _templateObject3, _templateObject4;
-
-function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
-function have() {
-  return (0, _lib.haveInCampground)((0, _templateString.$item)(_templateObject || (_templateObject = _taggedTemplateLiteral(["packet of winter seeds"]))));
+import { Copier } from "../../Copier";
+import { get } from "../../property";
+import { haveInCampground, have as haveItem } from "../../lib";
+import { $item } from "../../template-string";
+export function have() {
+    return haveInCampground($item `packet of winter seeds`);
 }
-
-function haveUnfinishedIceSculpture() {
-  return (0, _lib.have)((0, _templateString.$item)(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["unfinished ice sculpture"]))));
+export function haveUnfinishedIceSculpture() {
+    return haveItem($item `unfinished ice sculpture`);
 }
-
-function isUnfinishedIceSculptureUsed() {
-  return (0, _property.get)("_iceSculptureUsed");
+export function isUnfinishedIceSculptureUsed() {
+    return get("_iceSculptureUsed");
 }
-
-function couldUseUnfinishedIceSculpture() {
-  return (0, _lib.have)((0, _templateString.$item)(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["unfinished ice sculpture"])))) && !(0, _lib.have)((0, _templateString.$item)(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["ice sculpture"]))));
+export function couldUseUnfinishedIceSculpture() {
+    return (haveItem($item `unfinished ice sculpture`) && !haveItem($item `ice sculpture`));
 }
-
-function getUnfinishedIceSculptureMonster() {
-  return (0, _property.get)("iceSculptureMonster");
+export function getUnfinishedIceSculptureMonster() {
+    return get("iceSculptureMonster");
 }
-
-var UnfinishedIceSculpture = new _Copier.Copier(() => couldUseUnfinishedIceSculpture(), null, () => couldUseUnfinishedIceSculpture(), () => getUnfinishedIceSculptureMonster());
-exports.UnfinishedIceSculpture = UnfinishedIceSculpture;
+export const UnfinishedIceSculpture = new Copier(() => couldUseUnfinishedIceSculpture(), null, () => couldUseUnfinishedIceSculpture(), () => getUnfinishedIceSculptureMonster());