libram 0.5.4 → 0.5.8

package/dist/resources/action.js

@@ -1,154 +0,0 @@
-import { useFamiliar } from "kolmafia";
-import { Macro } from "../combat";
-import { Requirement } from "../maximize";
-import { sum } from "../utils";
-function mergeConstraints(...allConstraints) {
-    const familiars = allConstraints.map((constraints) => constraints.familiar);
-    if (familiars.length > 1) {
-        // Inconsistent requirements.
-        return null;
-    }
-    return {
-        equipmentRequirements: () => Requirement.merge([
-            ...allConstraints.map((constraints) => constraints.equipmentRequirements?.() ?? new Requirement([], {})),
-        ]),
-        preparation: () => {
-            let success = true;
-            for (const constraints of allConstraints) {
-                success =
-                    success && (!constraints.preparation || constraints.preparation());
-            }
-            return success;
-        },
-        familiar: familiars[0],
-        cost: () => sum(allConstraints, (constraints) => constraints.cost?.() ?? 0),
-    };
-}
-/**
- * A basic of an action resource in the game (e.g. a free run or free kill).
- */
-export class ActionSource {
-    source;
-    potential; // Infinity: unlimited
-    macro;
-    constraints;
-    /**
-     *
-     * @param source Source of the action (e.g. item or skill needed).
-     * @param potential Function returning how many times this action can be used.
-     * @param macro Macro to execute this action in combat.
-     * @param constraints Constraints required for this action to be available.
-     */
-    constructor(source, potential, macro, constraints = {}) {
-        this.source = source;
-        this.potential = potential;
-        this.macro = macro;
-        this.constraints = constraints;
-    }
-    /**
-     * @returns Name of the action source.
-     */
-    name() {
-        return this.source.toString();
-    }
-    /**
-     * @returns Whether the action is available.
-     */
-    available() {
-        return this.potential() > 0;
-    }
-    /**
-     * @returns Cost in meat per usage of the action.
-     */
-    cost() {
-        return this.constraints.cost ? this.constraints.cost() : 0;
-    }
-    /**
-     * @returns Whether the action costs 0 meat to use.
-     */
-    isFree() {
-        return !this.cost || this.cost() === 0;
-    }
-    /**
-     * @returns Whether unlimited uses of the action are available.
-     */
-    isUnlimited() {
-        return this.potential() === Infinity;
-    }
-    /**
-     * Create a compound action source with merged constraints.
-     * @param others Other actions to have available.
-     * @returns Merged constraints, or null if they are inconsistent.
-     */
-    merge(...others) {
-        const actions = [this, ...others];
-        const constraints = mergeConstraints(...actions.map((action) => action.constraints));
-        if (constraints === null) {
-            // Inconsistent constraints - no path forward here.
-            return null;
-        }
-        return new ActionSource(this.source, () => sum(actions, (action) => action.potential()), Macro.step(...actions.map((action) => action.macro)), constraints);
-    }
-    /**
-     * Perform all preparation necessary to make this action available.
-     * @param otherRequirements Any other equipment requirements.
-     * @returns Whether preparation succeeded.
-     */
-    prepare(otherRequirements) {
-        if (this.constraints.familiar?.()) {
-            if (!useFamiliar(this.constraints.familiar()))
-                return false;
-        }
-        if (this.constraints.equipmentRequirements) {
-            const requirement = otherRequirements
-                ? otherRequirements.merge(this.constraints.equipmentRequirements())
-                : this.constraints.equipmentRequirements();
-            if (!requirement.maximize())
-                return false;
-        }
-        if (this.constraints.preparation)
-            return this.constraints.preparation();
-        return true;
-    }
-    /**
-     * Perform all preparation necessary to make this action available.
-     * Throws an error if preparation fails.
-     * @param otherRequirements Any other equipment requirements.
-     */
-    ensure(otherRequirements) {
-        if (!this.prepare(otherRequirements)) {
-            throw new Error(`Failed to prepare action ${this.name()}.`);
-        }
-    }
-}
-function filterAction(action, constraints) {
-    return (action.available() &&
-        !(constraints.requireFamiliar?.() && !action.constraints.familiar) &&
-        !(constraints.requireUnlimited?.() && !action.isUnlimited()) &&
-        !(constraints.noFamiliar?.() && action.constraints.familiar) &&
-        !(constraints.noRequirements?.() && action.constraints.equipmentRequirements) &&
-        !(constraints.noPreparation?.() && action.constraints.preparation) &&
-        action.cost() <= (constraints.maximumCost?.() ?? 0));
-}
-/**
- * Find an available action source subject to constraints.
- * @param actions Action source list.
- * @param constraints Preexisting constraints that restrict possible sources.
- * @returns Available action source satisfying constraints, or null.
- */
-export function findActionSource(actions, constraints = {}) {
-    return (actions
-        .filter((actions) => filterAction(actions, constraints))
-        .sort((a, b) => a.cost() - b.cost())[0] ?? null);
-}
-/**
- * Count available action sources subject to constraints. Note that, if
- * constraints.maximumCost is high enough, this will return Infinity.
- * @param actions Action source list.
- * @param constraints Preexisting constraints that restrict possible sources.
- * @returns Count of available action sources.
- */
-export function actionSourcesAvailable(actions, constraints = {}) {
-    // TODO: This will overcount if any Actions share a counter
-    return sum(actions.filter((action) => filterAction(action, constraints ?? {})), (action) => action.potential());
-}