profectus/TMT-Demo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'feature/requirements-refactor'

Browse source
This commit is contained in:
thepaperpilot 2023-05-17 18:35:25 -05:00
commit 73f20d6eb5
7 changed files with 280 additions and 195 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/features/challenges/challenge.tsx
View file

@ -52,8 +52,6 @@ export interface ChallengeOptions {
reset?: GenericReset; reset?: GenericReset;
/** The requirement(s) to complete this challenge. */ /** The requirement(s) to complete this challenge. */
requirements: Requirements; requirements: Requirements;
/** Whether or not completing this challenge should grant multiple completions if requirements met. Requires {@link requirements} to be a requirement or array of requirements with {@link Requirement.canMaximize} true. */
maximize?: Computable<boolean>;
/** The maximum number of times the challenge can be completed. */ /** The maximum number of times the challenge can be completed. */
completionLimit?: Computable<DecimalSource>; completionLimit?: Computable<DecimalSource>;
/** Shows a marker on the corner of the feature. */ /** Shows a marker on the corner of the feature. */
@ -124,7 +122,6 @@ export type Challenge<T extends ChallengeOptions> = Replace<
visibility: GetComputableTypeWithDefault<T["visibility"], Visibility.Visible>; visibility: GetComputableTypeWithDefault<T["visibility"], Visibility.Visible>;
canStart: GetComputableTypeWithDefault<T["canStart"], true>; canStart: GetComputableTypeWithDefault<T["canStart"], true>;
requirements: GetComputableType<T["requirements"]>; requirements: GetComputableType<T["requirements"]>;
maximize: GetComputableType<T["maximize"]>;
completionLimit: GetComputableTypeWithDefault<T["completionLimit"], 1>; completionLimit: GetComputableTypeWithDefault<T["completionLimit"], 1>;
mark: GetComputableTypeWithDefault<T["mark"], Ref<boolean>>; mark: GetComputableTypeWithDefault<T["mark"], Ref<boolean>>;
classes: GetComputableType<T["classes"]>; classes: GetComputableType<T["classes"]>;
@ -210,10 +207,7 @@ export function createChallenge<T extends ChallengeOptions>(
} }
}; };
challenge.canComplete = computed(() => challenge.canComplete = computed(() =>
Decimal.max( maxRequirementsMet((challenge as GenericChallenge).requirements)
maxRequirementsMet((challenge as GenericChallenge).requirements),
unref((challenge as GenericChallenge).maximize) ? Decimal.dInf : 1
)
); );
challenge.complete = function (remainInChallenge?: boolean) { challenge.complete = function (remainInChallenge?: boolean) {
const genericChallenge = challenge as GenericChallenge; const genericChallenge = challenge as GenericChallenge;
@ -254,7 +248,6 @@ export function createChallenge<T extends ChallengeOptions>(
processComputable(challenge as T, "canStart"); processComputable(challenge as T, "canStart");
setDefault(challenge, "canStart", true); setDefault(challenge, "canStart", true);
processComputable(challenge as T, "maximize");
processComputable(challenge as T, "completionLimit"); processComputable(challenge as T, "completionLimit");
setDefault(challenge, "completionLimit", 1); setDefault(challenge, "completionLimit", 1);
processComputable(challenge as T, "mark"); processComputable(challenge as T, "mark");

9
src/features/repeatable.tsx
View file

@ -67,8 +67,6 @@ export interface RepeatableOptions {
mark?: Computable<boolean | string>; mark?: Computable<boolean | string>;
/** Toggles a smaller design for the feature. */ /** Toggles a smaller design for the feature. */
small?: Computable<boolean>; small?: Computable<boolean>;
/** Whether or not clicking this repeatable should attempt to maximize amount based on the requirements met. Requires {@link requirements} to be a requirement or array of requirements with {@link Requirement.canMaximize} true. */
maximize?: Computable<boolean>;
/** The display to use for this repeatable. */ /** The display to use for this repeatable. */
display?: Computable<RepeatableDisplay>; display?: Computable<RepeatableDisplay>;
} }
@ -87,7 +85,6 @@ export interface BaseRepeatable {
canClick: ProcessedComputable<boolean>; canClick: ProcessedComputable<boolean>;
/** /**
* How much amount can be increased by, or 1 if unclickable. * How much amount can be increased by, or 1 if unclickable.
* Capped at 1 if {@link RepeatableOptions.maximize} is false.
**/ **/
amountToIncrease: Ref<DecimalSource>; amountToIncrease: Ref<DecimalSource>;
/** A function that gets called when this repeatable is clicked. */ /** A function that gets called when this repeatable is clicked. */
@ -111,7 +108,6 @@ export type Repeatable<T extends RepeatableOptions> = Replace<
style: GetComputableType<T["style"]>; style: GetComputableType<T["style"]>;
mark: GetComputableType<T["mark"]>; mark: GetComputableType<T["mark"]>;
small: GetComputableType<T["small"]>; small: GetComputableType<T["small"]>;
maximize: GetComputableType<T["maximize"]>;
display: Ref<CoercableComponent>; display: Ref<CoercableComponent>;
} }
>; >;
@ -195,9 +191,7 @@ export function createRepeatable<T extends RepeatableOptions>(
return currClasses; return currClasses;
}); });
repeatable.amountToIncrease = computed(() => repeatable.amountToIncrease = computed(() =>
unref((repeatable as GenericRepeatable).maximize) Decimal.clampMin(maxRequirementsMet(repeatable.requirements), 1)
? maxRequirementsMet(repeatable.requirements)
: 1
); );
repeatable.canClick = computed(() => requirementsMet(repeatable.requirements)); repeatable.canClick = computed(() => requirementsMet(repeatable.requirements));
const onClick = repeatable.onClick; const onClick = repeatable.onClick;
@ -274,7 +268,6 @@ export function createRepeatable<T extends RepeatableOptions>(
processComputable(repeatable as T, "style"); processComputable(repeatable as T, "style");
processComputable(repeatable as T, "mark"); processComputable(repeatable as T, "mark");
processComputable(repeatable as T, "small"); processComputable(repeatable as T, "small");
processComputable(repeatable as T, "maximize");
for (const decorator of decorators) { for (const decorator of decorators) {
decorator.postConstruct?.(repeatable); decorator.postConstruct?.(repeatable);

134
src/game/formulas/formulas.ts
View file

@ -2,7 +2,7 @@ import { Resource } from "features/resources/resource";
import { NonPersistent } from "game/persistence"; import { NonPersistent } from "game/persistence";
import Decimal, { DecimalSource, format } from "util/bignum"; import Decimal, { DecimalSource, format } from "util/bignum";
import { Computable, ProcessedComputable, convertComputable } from "util/computed"; import { Computable, ProcessedComputable, convertComputable } from "util/computed";
import { ComputedRef, Ref, computed, ref, unref } from "vue"; import { Ref, computed, ref, unref } from "vue";
import * as ops from "./operations"; import * as ops from "./operations";
import type { import type {
EvaluateFunction, EvaluateFunction,
@ -1409,35 +1409,41 @@ export function printFormula(formula: FormulaSource): string {
} }
/** /**
* Utility for calculating the maximum amount of purchases possible with a given formula and resource. If {@link spendResources} is changed to false, the calculation will be much faster with higher numbers. * Utility for calculating the maximum amount of purchases possible with a given formula and resource. If {@link cumulativeCost} is changed to false, the calculation will be much faster with higher numbers.
* @param formula The formula to use for calculating buy max from * @param formula The formula to use for calculating buy max from
* @param resource The resource used when purchasing (is only read from) * @param resource The resource used when purchasing (is only read from)
* @param spendResources Whether or not to count spent resources on each purchase or not. If true, costs will be approximated for performance, skewing towards fewer purchases * @param cumulativeCost Whether or not to count spent resources on each purchase or not. If true, costs will be approximated for performance, skewing towards fewer purchases
* @param summedPurchases How many of the most expensive purchases should be manually summed for better accuracy. If unspecified uses 10 when spending resources and 0 when not * @param directSum How many of the most expensive purchases should be manually summed for better accuracy. If unspecified uses 10 when spending resources and 0 when not
* @param maxBulkAmount Cap on how many can be purchased at once. If equal to 1 or lte to {@link directSum} then the formula does not need to be invertible. Defaults to Infinity.
*/ */
export function calculateMaxAffordable( export function calculateMaxAffordable(
formula: InvertibleFormula, formula: GenericFormula,
resource: Resource, resource: Resource,
spendResources?: true, cumulativeCost: Computable<boolean> = true,
summedPurchases?: number directSum?: Computable<number>,
): ComputedRef<DecimalSource>; maxBulkAmount: Computable<DecimalSource> = Decimal.dInf
export function calculateMaxAffordable(
formula: InvertibleIntegralFormula,
resource: Resource,
spendResources: Computable<boolean>,
summedPurchases?: number
): ComputedRef<DecimalSource>;
export function calculateMaxAffordable(
formula: InvertibleFormula,
resource: Resource,
spendResources: Computable<boolean> = true,
summedPurchases?: number
) { ) {
const computedSpendResources = convertComputable(spendResources); const computedCumulativeCost = convertComputable(cumulativeCost);
const computedDirectSum = convertComputable(directSum);
const computedmaxBulkAmount = convertComputable(maxBulkAmount);
return computed(() => { return computed(() => {
let affordable; const maxBulkAmount = unref(computedmaxBulkAmount);
if (unref(computedSpendResources)) { if (Decimal.eq(maxBulkAmount, 1)) {
if (!formula.isIntegrable() || !formula.isIntegralInvertible()) { return Decimal.gte(resource.value, formula.evaluate()) ? Decimal.dOne : Decimal.dZero;
}
const cumulativeCost = unref(computedCumulativeCost);
const directSum = unref(computedDirectSum) ?? (cumulativeCost ? 10 : 0);
let affordable: DecimalSource = 0;
if (Decimal.gt(maxBulkAmount, directSum)) {
if (!formula.isInvertible()) {
console.error(
"Cannot calculate max affordable of non-invertible formula with more maxBulkAmount than directSum"
);
return 0;
}
if (cumulativeCost) {
if (!formula.isIntegralInvertible()) {
console.error( console.error(
"Cannot calculate max affordable of formula with non-invertible integral" "Cannot calculate max affordable of formula with non-invertible integral"
); );
@ -1446,23 +1452,27 @@ export function calculateMaxAffordable(
affordable = Decimal.floor( affordable = Decimal.floor(
formula.invertIntegral(Decimal.add(resource.value, formula.evaluateIntegral())) formula.invertIntegral(Decimal.add(resource.value, formula.evaluateIntegral()))
).sub(unref(formula.innermostVariable) ?? 0); ).sub(unref(formula.innermostVariable) ?? 0);
if (summedPurchases == null) {
summedPurchases = 10;
}
} else { } else {
if (!formula.isInvertible()) {
console.error("Cannot calculate max affordable of non-invertible formula");
return 0;
}
affordable = Decimal.floor(formula.invert(resource.value)); affordable = Decimal.floor(formula.invert(resource.value));
if (summedPurchases == null) {
summedPurchases = 0;
} }
} }
if (summedPurchases > 0 && Decimal.lt(calculateCost(formula, affordable, true, 0), 1e308)) { affordable = Decimal.clampMax(affordable, maxBulkAmount);
affordable = affordable.sub(summedPurchases).clampMin(0); if (directSum > 0) {
let summedCost = calculateCost(formula, affordable, true, 0); const preSumAffordable = affordable;
while (true) { affordable = Decimal.sub(affordable, directSum).clampMin(0);
let summedCost;
if (cumulativeCost) {
summedCost = calculateCost(formula as InvertibleFormula, affordable, true, 0);
} else {
summedCost = formula.evaluate(
Decimal.add(unref(formula.innermostVariable) ?? 0, affordable)
);
}
while (
Decimal.lt(affordable, maxBulkAmount) &&
Decimal.lt(affordable, Number.MAX_SAFE_INTEGER) &&
Decimal.add(preSumAffordable, 1).gte(affordable)
) {
const nextCost = formula.evaluate( const nextCost = formula.evaluate(
affordable.add(unref(formula.innermostVariable) ?? 0) affordable.add(unref(formula.innermostVariable) ?? 0)
); );
@ -1479,68 +1489,78 @@ export function calculateMaxAffordable(
} }
/** /**
* Utility for calculating the cost of a formula for a given amount of purchases. If {@link spendResources} is changed to false, the calculation will be much faster with higher numbers. * Utility for calculating the cost of a formula for a given amount of purchases. If {@link cumulativeCost} is changed to false, the calculation will be much faster with higher numbers.
* @param formula The formula to use for calculating buy max from * @param formula The formula to use for calculating buy max from
* @param amountToBuy The amount of purchases to calculate the cost for * @param amountToBuy The amount of purchases to calculate the cost for
* @param spendResources Whether or not to count spent resources on each purchase or not. If true, costs will be approximated for performance, skewing towards higher cost * @param cumulativeCost Whether or not to count spent resources on each purchase or not. If true, costs will be approximated for performance, skewing towards higher cost
* @param summedPurchases How many purchases to manually sum for improved accuracy. If not specified, defaults to 10 when spending resources and 0 when not * @param directSum How many purchases to manually sum for improved accuracy. If not specified, defaults to 10 when cost is cumulative and 0 when not
*/ */
export function calculateCost( export function calculateCost(
formula: InvertibleFormula, formula: InvertibleFormula,
amountToBuy: DecimalSource, amountToBuy: DecimalSource,
spendResources?: true, cumulativeCost?: true,
summedPurchases?: number directSum?: number
): DecimalSource; ): DecimalSource;
export function calculateCost( export function calculateCost(
formula: InvertibleIntegralFormula, formula: InvertibleIntegralFormula,
amountToBuy: DecimalSource, amountToBuy: DecimalSource,
spendResources: boolean, cumulativeCost: boolean,
summedPurchases?: number directSum?: number
): DecimalSource; ): DecimalSource;
export function calculateCost( export function calculateCost(
formula: InvertibleFormula, formula: InvertibleFormula,
amountToBuy: DecimalSource, amountToBuy: DecimalSource,
spendResources = true, cumulativeCost = true,
summedPurchases?: number directSum?: number
) { ) {
// Single purchase
if (Decimal.eq(amountToBuy, 1)) {
return formula.evaluate();
}
const origValue = unref(formula.innermostVariable) ?? 0; const origValue = unref(formula.innermostVariable) ?? 0;
let newValue = Decimal.add(amountToBuy, origValue); let newValue = Decimal.add(amountToBuy, origValue);
const targetValue = newValue; const targetValue = newValue;
summedPurchases ??= spendResources ? 10 : 0; directSum ??= cumulativeCost ? 10 : 0;
newValue = newValue.sub(summedPurchases).clampMin(origValue); newValue = newValue.sub(directSum).clampMin(origValue);
let cost: DecimalSource = 0; let cost: DecimalSource = 0;
if (spendResources) {
if (Decimal.gt(amountToBuy, summedPurchases)) { // Indirect sum
if (Decimal.gt(amountToBuy, directSum)) {
if (!formula.isInvertible()) {
console.error("Cannot calculate cost with indirect sum of non-invertible formula");
return 0;
}
if (cumulativeCost) {
if (!formula.isIntegrable()) { if (!formula.isIntegrable()) {
console.error( console.error(
"Cannot calculate cost with spending resources of non-integrable formula" "Cannot calculate cost with cumulative cost of non-integrable formula"
); );
return 0; return 0;
} }
cost = Decimal.sub(formula.evaluateIntegral(newValue), formula.evaluateIntegral()); cost = Decimal.sub(formula.evaluateIntegral(newValue), formula.evaluateIntegral());
}
if (targetValue.gt(1e308)) { if (targetValue.gt(1e308)) {
// Too large of a number for summedPurchases to make a difference, // Too large of a number for directSum to make a difference,
// just get the cost and multiply by summed purchases // just get the cost and multiply by summed purchases
return Decimal.add( return Decimal.add(
cost, cost,
Decimal.sub(targetValue, newValue).times(formula.evaluate(newValue)) Decimal.sub(targetValue, newValue).times(formula.evaluate(newValue))
); );
} }
for (let i = newValue.toNumber(); i < targetValue.toNumber(); i++) {
cost = Decimal.add(cost, formula.evaluate(i));
}
} else { } else {
cost = formula.evaluate(newValue); cost = formula.evaluate(newValue);
newValue = newValue.add(1); newValue = newValue.add(1);
if (targetValue.gt(1e308)) { if (targetValue.gt(1e308)) {
// Too large of a number for summedPurchases to make a difference, // Too large of a number for directSum to make a difference,
// just get the cost and multiply by summed purchases // just get the cost and multiply by summed purchases
return Decimal.sub(targetValue, newValue).add(1).times(cost); return Decimal.sub(targetValue, newValue).add(1).times(cost);
} }
}
}
// Direct sum
for (let i = newValue.toNumber(); i < targetValue.toNumber(); i++) { for (let i = newValue.toNumber(); i < targetValue.toNumber(); i++) {
cost = Decimal.add(cost, formula.evaluate(i)); cost = Decimal.add(cost, formula.evaluate(i));
} }
}
return cost; return cost;
} }

2
src/game/formulas/operations.ts
View file

@ -452,7 +452,7 @@ export function integratePow10(stack: SubstitutionStack, lhs: FormulaSource) {
export function invertPowBase(value: DecimalSource, lhs: FormulaSource, rhs: FormulaSource) { export function invertPowBase(value: DecimalSource, lhs: FormulaSource, rhs: FormulaSource) {
if (hasVariable(lhs)) { if (hasVariable(lhs)) {
return lhs.invert(Decimal.ln(value).div(unrefFormulaSource(rhs))); return lhs.invert(Decimal.ln(value).div(Decimal.ln(unrefFormulaSource(rhs))));
} else if (hasVariable(rhs)) { } else if (hasVariable(rhs)) {
return rhs.invert(Decimal.root(unrefFormulaSource(lhs), value)); return rhs.invert(Decimal.root(unrefFormulaSource(lhs), value));
} }

104
src/game/requirements.tsx
View file

@ -20,7 +20,7 @@ import { createLazyProxy } from "util/proxies";
import { joinJSX, renderJSX } from "util/vue"; import { joinJSX, renderJSX } from "util/vue";
import { computed, unref } from "vue"; import { computed, unref } from "vue";
import Formula, { calculateCost, calculateMaxAffordable } from "./formulas/formulas"; import Formula, { calculateCost, calculateMaxAffordable } from "./formulas/formulas";
import type { GenericFormula, InvertibleFormula } from "./formulas/types"; import type { GenericFormula } from "./formulas/types";
import { DefaultValue, Persistent } from "./persistence"; import { DefaultValue, Persistent } from "./persistence";
/** /**
@ -86,7 +86,15 @@ export interface CostRequirementOptions {
* When calculating multiple levels to be handled at once, whether it should consider resources used for each level as spent. Setting this to false causes calculations to be faster with larger numbers and supports more math functions. * When calculating multiple levels to be handled at once, whether it should consider resources used for each level as spent. Setting this to false causes calculations to be faster with larger numbers and supports more math functions.
* @see {Formula} * @see {Formula}
*/ */
spendResources?: Computable<boolean>; cumulativeCost?: Computable<boolean>;
/**
* Upper limit on levels that can be performed at once. Defaults to 1.
*/
maxBulkAmount?: Computable<DecimalSource>;
/**
* When calculating requirement for multiple levels, how many should be directly summed for increase accuracy. High numbers can cause lag. Defaults to 10 if cumulative cost, 0 otherwise.
*/
directSum?: Computable<number>;
/** /**
* Pass-through to {@link Requirement.pay}. May be required for maximizing support. * Pass-through to {@link Requirement.pay}. May be required for maximizing support.
* @see {@link cost} for restrictions on maximizing support. * @see {@link cost} for restrictions on maximizing support.
@ -100,7 +108,7 @@ export type CostRequirement = Replace<
cost: ProcessedComputable<DecimalSource> | GenericFormula; cost: ProcessedComputable<DecimalSource> | GenericFormula;
visibility: ProcessedComputable<Visibility.Visible | Visibility.None | boolean>; visibility: ProcessedComputable<Visibility.Visible | Visibility.None | boolean>;
requiresPay: ProcessedComputable<boolean>; requiresPay: ProcessedComputable<boolean>;
spendResources: ProcessedComputable<boolean>; cumulativeCost: ProcessedComputable<boolean>;
canMaximize: ProcessedComputable<boolean>; canMaximize: ProcessedComputable<boolean>;
} }
>; >;
@ -126,7 +134,12 @@ export function createCostRequirement<T extends CostRequirementOptions>(
{displayResource( {displayResource(
req.resource, req.resource,
req.cost instanceof Formula req.cost instanceof Formula
? calculateCost(req.cost, amount ?? 1, unref(req.spendResources) as boolean) ? calculateCost(
req.cost,
amount ?? 1,
unref(req.cumulativeCost) as boolean,
unref(req.directSum) as number
)
: unref(req.cost as ProcessedComputable<DecimalSource>) : unref(req.cost as ProcessedComputable<DecimalSource>)
)}{" "} )}{" "}
{req.resource.displayName} {req.resource.displayName}
@ -138,7 +151,12 @@ export function createCostRequirement<T extends CostRequirementOptions>(
{displayResource( {displayResource(
req.resource, req.resource,
req.cost instanceof Formula req.cost instanceof Formula
? calculateCost(req.cost, amount ?? 1, unref(req.spendResources) as boolean) ? calculateCost(
req.cost,
amount ?? 1,
unref(req.cumulativeCost) as boolean,
unref(req.directSum) as number
)
: unref(req.cost as ProcessedComputable<DecimalSource>) : unref(req.cost as ProcessedComputable<DecimalSource>)
)}{" "} )}{" "}
{req.resource.displayName} {req.resource.displayName}
@ -150,55 +168,63 @@ export function createCostRequirement<T extends CostRequirementOptions>(
processComputable(req as T, "cost"); processComputable(req as T, "cost");
processComputable(req as T, "requiresPay"); processComputable(req as T, "requiresPay");
setDefault(req, "requiresPay", true); setDefault(req, "requiresPay", true);
processComputable(req as T, "spendResources"); processComputable(req as T, "cumulativeCost");
setDefault(req, "spendResources", true); setDefault(req, "cumulativeCost", true);
processComputable(req as T, "maxBulkAmount");
setDefault(req, "maxBulkAmount", 1);
processComputable(req as T, "directSum");
setDefault(req, "pay", function (amount?: DecimalSource) { setDefault(req, "pay", function (amount?: DecimalSource) {
const cost = const cost =
req.cost instanceof Formula req.cost instanceof Formula
? calculateCost(req.cost, amount ?? 1, unref(req.spendResources) as boolean) ? calculateCost(
req.cost,
amount ?? 1,
unref(req.cumulativeCost) as boolean,
unref(req.directSum) as number
)
: unref(req.cost as ProcessedComputable<DecimalSource>); : unref(req.cost as ProcessedComputable<DecimalSource>);
req.resource.value = Decimal.sub(req.resource.value, cost).max(0); req.resource.value = Decimal.sub(req.resource.value, cost).max(0);
}); });
req.canMaximize = computed( req.canMaximize = computed(() => {
() => if (!(req.cost instanceof Formula)) {
req.cost instanceof Formula && return false;
req.cost.isInvertible() && }
(unref(req.spendResources) === false || req.cost.isIntegrable()) const maxBulkAmount = unref(req.maxBulkAmount as ProcessedComputable<DecimalSource>);
); if (Decimal.lte(maxBulkAmount, 1)) {
return false;
}
const cumulativeCost = unref(req.cumulativeCost as ProcessedComputable<boolean>);
const directSum =
unref(req.directSum as ProcessedComputable<number>) ?? (cumulativeCost ? 10 : 0);
if (Decimal.lte(maxBulkAmount, directSum)) {
return true;
}
if (!req.cost.isInvertible()) {
return false;
}
if (cumulativeCost === true && !req.cost.isIntegrable()) {
return false;
}
return true;
});
if (req.cost instanceof Formula && req.cost.isInvertible()) { if (req.cost instanceof Formula) {
const maxAffordable = calculateMaxAffordable( req.requirementMet = calculateMaxAffordable(
req.cost, req.cost,
req.resource, req.resource,
unref(req.spendResources) as boolean req.cumulativeCost ?? true,
req.directSum,
req.maxBulkAmount
); );
req.requirementMet = computed(() => {
if (unref(req.canMaximize)) {
return maxAffordable.value;
} else { } else {
if (req.cost instanceof Formula) { req.requirementMet = computed(() =>
return Decimal.gte(req.resource.value, req.cost.evaluate()); Decimal.gte(
} else {
return Decimal.gte(
req.resource.value, req.resource.value,
unref(req.cost as ProcessedComputable<DecimalSource>) unref(req.cost as ProcessedComputable<DecimalSource>)
)
); );
} }
}
});
} else {
req.requirementMet = computed(() => {
if (req.cost instanceof Formula) {
return Decimal.gte(req.resource.value, req.cost.evaluate());
} else {
return Decimal.gte(
req.resource.value,
unref(req.cost as ProcessedComputable<DecimalSource>)
);
}
});
}
return req as CostRequirement; return req as CostRequirement;
}); });
@ -328,7 +354,7 @@ export function payByDivision(this: CostRequirement, amount?: DecimalSource) {
? calculateCost( ? calculateCost(
this.cost, this.cost,
amount ?? 1, amount ?? 1,
unref(this.spendResources as ProcessedComputable<boolean> | undefined) ?? true unref(this.cumulativeCost as ProcessedComputable<boolean> | undefined) ?? true
) )
: unref(this.cost as ProcessedComputable<DecimalSource>); : unref(this.cost as ProcessedComputable<DecimalSource>);
this.resource.value = Decimal.div(this.resource.value, cost); this.resource.value = Decimal.div(this.resource.value, cost);

44
tests/game/formulas.test.ts
View file

@ -1074,13 +1074,20 @@ describe("Buy Max", () => {
beforeAll(() => { beforeAll(() => {
resource = createResource(ref(100000)); resource = createResource(ref(100000));
}); });
describe("Without spending", () => { describe("Without cumulative cost", () => {
test("errors on formula with non-invertible integral", () => { test("Errors on calculating max affordable of non-invertible formula", () => {
// eslint-disable-next-line @typescript-eslint/ban-ts-comment const purchases = ref(1);
/* @ts-ignore */ const variable = Formula.variable(purchases);
const maxAffordable = calculateMaxAffordable(Formula.neg(10), resource, false); const formula = Formula.abs(variable);
const maxAffordable = calculateMaxAffordable(formula, resource, false);
expect(() => maxAffordable.value).toLogError(); expect(() => maxAffordable.value).toLogError();
}); });
test("Errors on calculating cost of non-invertible formula", () => {
const purchases = ref(1);
const variable = Formula.variable(purchases);
const formula = Formula.abs(variable);
expect(() => calculateCost(formula, 5, false, 0)).toLogError();
});
test("Calculates max affordable and cost correctly", () => { test("Calculates max affordable and cost correctly", () => {
const variable = Formula.variable(0); const variable = Formula.variable(0);
const formula = Formula.pow(1.05, variable).times(100); const formula = Formula.pow(1.05, variable).times(100);
@ -1090,7 +1097,7 @@ describe("Buy Max", () => {
Decimal.pow(1.05, 141).times(100) Decimal.pow(1.05, 141).times(100)
); );
}); });
test("Calculates max affordable and cost correctly with summing last purchases", () => { test("Calculates max affordable and cost correctly with direct sum", () => {
const variable = Formula.variable(0); const variable = Formula.variable(0);
const formula = Formula.pow(1.05, variable).times(100); const formula = Formula.pow(1.05, variable).times(100);
const maxAffordable = calculateMaxAffordable(formula, resource, false, 4); const maxAffordable = calculateMaxAffordable(formula, resource, false, 4);
@ -1103,11 +1110,20 @@ describe("Buy Max", () => {
expect(calculatedCost).compare_tolerance(actualCost); expect(calculatedCost).compare_tolerance(actualCost);
}); });
}); });
describe("With spending", () => { describe("With cumulative cost", () => {
test("errors on calculating max affordable of non-invertible formula", () => { test("Errors on calculating max affordable of non-invertible formula", () => {
const maxAffordable = calculateMaxAffordable(Formula.abs(10), resource); const purchases = ref(1);
const variable = Formula.variable(purchases);
const formula = Formula.abs(variable);
const maxAffordable = calculateMaxAffordable(formula, resource, true);
expect(() => maxAffordable.value).toLogError(); expect(() => maxAffordable.value).toLogError();
}); });
test("Errors on calculating cost of non-invertible formula", () => {
const purchases = ref(1);
const variable = Formula.variable(purchases);
const formula = Formula.abs(variable);
expect(() => calculateCost(formula, 5, true, 0)).toLogError();
});
test("Estimates max affordable and cost correctly with 0 purchases", () => { test("Estimates max affordable and cost correctly with 0 purchases", () => {
const purchases = ref(0); const purchases = ref(0);
const variable = Formula.variable(purchases); const variable = Formula.variable(purchases);
@ -1164,7 +1180,7 @@ describe("Buy Max", () => {
Decimal.sub(actualCost, calculatedCost).abs().div(actualCost).toNumber() Decimal.sub(actualCost, calculatedCost).abs().div(actualCost).toNumber()
).toBeLessThan(0.1); ).toBeLessThan(0.1);
}); });
test("Estimates max affordable and cost more accurately with summing last purchases", () => { test("Estimates max affordable and cost more accurately with direct sum", () => {
const purchases = ref(1); const purchases = ref(1);
const variable = Formula.variable(purchases); const variable = Formula.variable(purchases);
const formula = Formula.pow(1.05, variable).times(100); const formula = Formula.pow(1.05, variable).times(100);
@ -1191,7 +1207,7 @@ describe("Buy Max", () => {
Decimal.sub(actualCost, calculatedCost).abs().div(actualCost).toNumber() Decimal.sub(actualCost, calculatedCost).abs().div(actualCost).toNumber()
).toBeLessThan(0.02); ).toBeLessThan(0.02);
}); });
test("Handles summing purchases when making few purchases", () => { test("Handles direct sum when making few purchases", () => {
const purchases = ref(90); const purchases = ref(90);
const variable = Formula.variable(purchases); const variable = Formula.variable(purchases);
const formula = Formula.pow(1.05, variable).times(100); const formula = Formula.pow(1.05, variable).times(100);
@ -1219,7 +1235,7 @@ describe("Buy Max", () => {
// Since we're summing all the purchases this should be equivalent // Since we're summing all the purchases this should be equivalent
expect(calculatedCost).compare_tolerance(actualCost); expect(calculatedCost).compare_tolerance(actualCost);
}); });
test("Handles summing purchases when making very few purchases", () => { test("Handles direct sum when making very few purchases", () => {
const purchases = ref(0); const purchases = ref(0);
const variable = Formula.variable(purchases); const variable = Formula.variable(purchases);
const formula = variable.add(1); const formula = variable.add(1);
@ -1237,7 +1253,7 @@ describe("Buy Max", () => {
// Since we're summing all the purchases this should be equivalent // Since we're summing all the purchases this should be equivalent
expect(calculatedCost).compare_tolerance(actualCost); expect(calculatedCost).compare_tolerance(actualCost);
}); });
test("Handles summing purchases when over e308 purchases", () => { test("Handles direct sum when over e308 purchases", () => {
resource.value = "1ee308"; resource.value = "1ee308";
const purchases = ref(0); const purchases = ref(0);
const variable = Formula.variable(purchases); const variable = Formula.variable(purchases);
@ -1248,7 +1264,7 @@ describe("Buy Max", () => {
expect(Decimal.isFinite(calculatedCost)).toBe(true); expect(Decimal.isFinite(calculatedCost)).toBe(true);
resource.value = 100000; resource.value = 100000;
}); });
test("Handles summing purchases of non-integrable formula", () => { test("Handles direct sum of non-integrable formula", () => {
const purchases = ref(0); const purchases = ref(0);
const formula = Formula.variable(purchases).abs(); const formula = Formula.variable(purchases).abs();
expect(() => calculateCost(formula, 10)).not.toLogError(); expect(() => calculateCost(formula, 10)).not.toLogError();

121
tests/game/requirements.test.ts
View file

@ -11,6 +11,7 @@ import {
Requirement, Requirement,
requirementsMet requirementsMet
} from "game/requirements"; } from "game/requirements";
import Decimal from "util/bignum";
import { beforeAll, describe, expect, test } from "vitest"; import { beforeAll, describe, expect, test } from "vitest";
import { isRef, ref, unref } from "vue"; import { isRef, ref, unref } from "vue";
import "../utils"; import "../utils";
@ -26,8 +27,7 @@ describe("Creating cost requirement", () => {
beforeAll(() => { beforeAll(() => {
requirement = createCostRequirement(() => ({ requirement = createCostRequirement(() => ({
resource, resource,
cost: 10, cost: 10
spendResources: false
})); }));
}); });
@ -44,7 +44,7 @@ describe("Creating cost requirement", () => {
}); });
test("is visible", () => expect(requirement.visibility).toBe(Visibility.Visible)); test("is visible", () => expect(requirement.visibility).toBe(Visibility.Visible));
test("requires pay", () => expect(requirement.requiresPay).toBe(true)); test("requires pay", () => expect(requirement.requiresPay).toBe(true));
test("does not spend resources", () => expect(requirement.spendResources).toBe(false)); test("does not spend resources", () => expect(requirement.cumulativeCost).toBe(true));
test("cannot maximize", () => expect(unref(requirement.canMaximize)).toBe(false)); test("cannot maximize", () => expect(unref(requirement.canMaximize)).toBe(false));
}); });
@ -56,8 +56,9 @@ describe("Creating cost requirement", () => {
cost: Formula.variable(resource).times(10), cost: Formula.variable(resource).times(10),
visibility: Visibility.None, visibility: Visibility.None,
requiresPay: false, requiresPay: false,
maximize: true, cumulativeCost: false,
spendResources: true, maxBulkAmount: Decimal.dInf,
directSum: 5,
// eslint-disable-next-line @typescript-eslint/no-empty-function // eslint-disable-next-line @typescript-eslint/no-empty-function
pay() {} pay() {}
})); }));
@ -69,15 +70,18 @@ describe("Creating cost requirement", () => {
requirement.pay.length === 1); requirement.pay.length === 1);
test("is not visible", () => expect(requirement.visibility).toBe(Visibility.None)); test("is not visible", () => expect(requirement.visibility).toBe(Visibility.None));
test("does not require pay", () => expect(requirement.requiresPay).toBe(false)); test("does not require pay", () => expect(requirement.requiresPay).toBe(false));
test("spends resources", () => expect(requirement.spendResources).toBe(true)); test("spends resources", () => expect(requirement.cumulativeCost).toBe(false));
test("can maximize", () => expect(unref(requirement.canMaximize)).toBe(true)); test("can maximize", () => expect(unref(requirement.canMaximize)).toBe(true));
test("maxBulkAmount is set", () =>
expect(unref(requirement.maxBulkAmount)).compare_tolerance(Decimal.dInf));
test("directSum is set", () => expect(unref(requirement.directSum)).toBe(5));
}); });
test("Requirement met when meeting the cost", () => { test("Requirement met when meeting the cost", () => {
const requirement = createCostRequirement(() => ({ const requirement = createCostRequirement(() => ({
resource, resource,
cost: 10, cost: 10,
spendResources: false cumulativeCost: false
})); }));
expect(unref(requirement.requirementMet)).toBe(true); expect(unref(requirement.requirementMet)).toBe(true);
}); });
@ -86,13 +90,23 @@ describe("Creating cost requirement", () => {
const requirement = createCostRequirement(() => ({ const requirement = createCostRequirement(() => ({
resource, resource,
cost: 100, cost: 100,
spendResources: false cumulativeCost: false
})); }));
expect(unref(requirement.requirementMet)).toBe(false); expect(unref(requirement.requirementMet)).toBe(false);
}); });
describe("canMaximize works correctly", () => { describe("canMaximize works correctly", () => {
test("Cost function cannot maximize", () => test("Cost function cannot maximize", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
cost: () => 10,
maxBulkAmount: Decimal.dInf
})).canMaximize
)
).toBe(false));
test("Integrable formula cannot maximize if maxBulkAmount is left at 1", () =>
expect( expect(
unref( unref(
createCostRequirement(() => ({ createCostRequirement(() => ({
@ -101,82 +115,104 @@ describe("Creating cost requirement", () => {
})).canMaximize })).canMaximize
) )
).toBe(false)); ).toBe(false));
test("Non-invertible formula cannot maximize", () => test("Non-invertible formula cannot maximize when max bulk amount is above direct sum", () =>
expect( expect(
unref( unref(
createCostRequirement(() => ({ createCostRequirement(() => ({
resource, resource,
cost: Formula.variable(resource).abs() cost: Formula.variable(resource).abs(),
maxBulkAmount: Decimal.dInf
})).canMaximize })).canMaximize
) )
).toBe(false)); ).toBe(false));
test("Invertible formula can maximize if spendResources is false", () => test("Non-invertible formula can maximize when max bulk amount is lte direct sum", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
cost: Formula.variable(resource).abs(),
maxBulkAmount: 20,
directSum: 20
})).canMaximize
)
).toBe(true));
test("Invertible formula can maximize if cumulativeCost is false", () =>
expect( expect(
unref( unref(
createCostRequirement(() => ({ createCostRequirement(() => ({
resource, resource,
cost: Formula.variable(resource).lambertw(), cost: Formula.variable(resource).lambertw(),
spendResources: false cumulativeCost: false,
maxBulkAmount: Decimal.dInf
})).canMaximize })).canMaximize
) )
).toBe(true)); ).toBe(true));
test("Invertible formula cannot maximize if spendResources is true", () => test("Invertible formula cannot maximize if cumulativeCost is true", () =>
expect( expect(
unref( unref(
createCostRequirement(() => ({ createCostRequirement(() => ({
resource, resource,
cost: Formula.variable(resource).lambertw(), cost: Formula.variable(resource).lambertw(),
spendResources: true cumulativeCost: true,
maxBulkAmount: Decimal.dInf
})).canMaximize })).canMaximize
) )
).toBe(false)); ).toBe(false));
test("Integrable formula can maximize if spendResources is false", () => test("Integrable formula can maximize if cumulativeCost is false", () =>
expect( expect(
unref( unref(
createCostRequirement(() => ({ createCostRequirement(() => ({
resource, resource,
cost: Formula.variable(resource).pow(2), cost: Formula.variable(resource).pow(2),
spendResources: false cumulativeCost: false,
maxBulkAmount: Decimal.dInf
})).canMaximize })).canMaximize
) )
).toBe(true)); ).toBe(true));
test("Integrable formula can maximize if spendResources is true", () => test("Integrable formula can maximize if cumulativeCost is true", () =>
expect( expect(
unref( unref(
createCostRequirement(() => ({ createCostRequirement(() => ({
resource, resource,
cost: Formula.variable(resource).pow(2), cost: Formula.variable(resource).pow(2),
spendResources: true cumulativeCost: true,
maxBulkAmount: Decimal.dInf
})).canMaximize })).canMaximize
) )
).toBe(true)); ).toBe(true));
}); });
test("Requirements met capped by maxBulkAmount", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
cost: Formula.variable(resource).times(0.0001),
maxBulkAmount: 10,
cumulativeCost: false
})).requirementMet
)
).compare_tolerance(10));
}); });
describe("Creating visibility requirement", () => { test("Creating visibility requirement", () => {
test("Requirement met when visible", () => { const visibility = ref<Visibility.None | Visibility.Visible | boolean>(Visibility.Visible);
const requirement = createVisibilityRequirement({ visibility: Visibility.Visible }); const requirement = createVisibilityRequirement({ visibility });
expect(unref(requirement.requirementMet)).toBe(true); expect(unref(requirement.requirementMet)).toBe(true);
}); visibility.value = true;
test("Requirement not met when not visible", () => {
let requirement = createVisibilityRequirement({ visibility: Visibility.None });
expect(unref(requirement.requirementMet)).toBe(false);
requirement = createVisibilityRequirement({ visibility: false });
expect(unref(requirement.requirementMet)).toBe(false);
});
});
describe("Creating boolean requirement", () => {
test("Requirement met when true", () => {
const requirement = createBooleanRequirement(ref(true));
expect(unref(requirement.requirementMet)).toBe(true); expect(unref(requirement.requirementMet)).toBe(true);
}); visibility.value = Visibility.None;
expect(unref(requirement.requirementMet)).toBe(false);
test("Requirement not met when false", () => { visibility.value = false;
const requirement = createBooleanRequirement(ref(false));
expect(unref(requirement.requirementMet)).toBe(false); expect(unref(requirement.requirementMet)).toBe(false);
}); });
test("Creating boolean requirement", () => {
const req = ref(true);
const requirement = createBooleanRequirement(req);
expect(unref(requirement.requirementMet)).toBe(true);
req.value = false;
expect(unref(requirement.requirementMet)).toBe(false);
}); });
describe("Checking all requirements met", () => { describe("Checking all requirements met", () => {
@ -208,7 +244,7 @@ describe("Checking maximum levels of requirements met", () => {
createCostRequirement(() => ({ createCostRequirement(() => ({
resource: createResource(ref(10)), resource: createResource(ref(10)),
cost: Formula.variable(0), cost: Formula.variable(0),
spendResources: false cumulativeCost: false
})) }))
]; ];
expect(maxRequirementsMet(requirements)).compare_tolerance(0); expect(maxRequirementsMet(requirements)).compare_tolerance(0);
@ -220,7 +256,8 @@ describe("Checking maximum levels of requirements met", () => {
createCostRequirement(() => ({ createCostRequirement(() => ({
resource: createResource(ref(10)), resource: createResource(ref(10)),
cost: Formula.variable(0), cost: Formula.variable(0),
spendResources: false cumulativeCost: false,
maxBulkAmount: Decimal.dInf
})) }))
]; ];
expect(maxRequirementsMet(requirements)).compare_tolerance(10); expect(maxRequirementsMet(requirements)).compare_tolerance(10);
@ -233,12 +270,12 @@ test("Paying requirements", () => {
resource, resource,
cost: 10, cost: 10,
requiresPay: false, requiresPay: false,
spendResources: false cumulativeCost: false
})); }));
const payment = createCostRequirement(() => ({ const payment = createCostRequirement(() => ({
resource, resource,
cost: 10, cost: 10,
spendResources: false cumulativeCost: false
})); }));
payRequirements([noPayment, payment]); payRequirements([noPayment, payment]);
expect(resource.value).compare_tolerance(90); expect(resource.value).compare_tolerance(90);