Profectus/tests/game/requirements.test.ts

283 lines
10 KiB
TypeScript
Raw Normal View History

2023-02-07 14:31:09 +00:00
import { Visibility } from "features/feature";
import { createResource, Resource } from "features/resources/resource";
import Formula from "game/formulas/formulas";
2023-02-07 14:31:09 +00:00
import {
2023-03-21 05:15:28 +00:00
CostRequirement,
2023-02-07 14:31:09 +00:00
createBooleanRequirement,
createCostRequirement,
createVisibilityRequirement,
maxRequirementsMet,
payRequirements,
Requirement,
requirementsMet
} from "game/requirements";
import Decimal from "util/bignum";
2023-02-07 14:31:09 +00:00
import { beforeAll, describe, expect, test } from "vitest";
import { isRef, ref, unref } from "vue";
import "../utils";
describe("Creating cost requirement", () => {
let resource: Resource;
beforeAll(() => {
resource = createResource(ref(10));
});
2023-02-07 14:31:09 +00:00
describe("Minimal requirement", () => {
2023-03-21 05:15:28 +00:00
let requirement: CostRequirement;
2023-02-07 14:31:09 +00:00
beforeAll(() => {
requirement = createCostRequirement(() => ({
resource,
cost: 10
2023-02-07 14:31:09 +00:00
}));
});
2023-03-21 05:15:28 +00:00
test("resource pass-through", () => expect(requirement.resource).toBe(resource));
test("cost pass-through", () => expect(requirement.cost).toBe(10));
2023-02-07 14:31:09 +00:00
test("partialDisplay exists", () =>
expect(typeof requirement.partialDisplay).toBe("function"));
test("display exists", () => expect(typeof requirement.display).toBe("function"));
test("pay exists", () => expect(typeof requirement.pay).toBe("function"));
test("requirementMet exists", () => {
expect(requirement.requirementMet).not.toBeNull();
expect(isRef(requirement.requirementMet)).toBe(true);
});
test("is visible", () => expect(requirement.visibility).toBe(Visibility.Visible));
test("requires pay", () => expect(requirement.requiresPay).toBe(true));
test("does not spend resources", () => expect(requirement.cumulativeCost).toBe(true));
test("cannot maximize", () => expect(unref(requirement.canMaximize)).toBe(false));
2023-02-07 14:31:09 +00:00
});
describe("Fully customized", () => {
2023-03-21 05:15:28 +00:00
let requirement: CostRequirement;
2023-02-07 14:31:09 +00:00
beforeAll(() => {
requirement = createCostRequirement(() => ({
resource,
2023-03-21 05:15:28 +00:00
cost: Formula.variable(resource).times(10),
2023-02-07 14:31:09 +00:00
visibility: Visibility.None,
requiresPay: false,
cumulativeCost: false,
maxBulkAmount: Decimal.dInf,
directSum: 5,
2023-02-07 14:31:09 +00:00
// eslint-disable-next-line @typescript-eslint/no-empty-function
pay() {}
}));
});
test("pay is empty function", () =>
requirement.pay != null &&
typeof requirement.pay === "function" &&
requirement.pay.length === 1);
test("is not visible", () => expect(requirement.visibility).toBe(Visibility.None));
test("does not require pay", () => expect(requirement.requiresPay).toBe(false));
test("spends resources", () => expect(requirement.cumulativeCost).toBe(false));
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));
2023-02-07 14:31:09 +00:00
});
test("Requirement met when meeting the cost", () => {
const requirement = createCostRequirement(() => ({
resource,
2023-03-21 05:15:28 +00:00
cost: 10,
cumulativeCost: false
2023-02-07 14:31:09 +00:00
}));
expect(unref(requirement.requirementMet)).toBe(true);
});
test("Requirement not met when not meeting the cost", () => {
const requirement = createCostRequirement(() => ({
resource,
2023-03-21 05:15:28 +00:00
cost: 100,
cumulativeCost: false
2023-02-07 14:31:09 +00:00
}));
expect(unref(requirement.requirementMet)).toBe(false);
});
describe("canMaximize works correctly", () => {
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(
unref(
createCostRequirement(() => ({
resource,
cost: () => 10
})).canMaximize
)
).toBe(false));
test("Non-invertible formula cannot maximize when max bulk amount is above direct sum", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
cost: Formula.variable(resource).abs(),
maxBulkAmount: Decimal.dInf
})).canMaximize
)
).toBe(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(
unref(
createCostRequirement(() => ({
resource,
cost: Formula.variable(resource).lambertw(),
cumulativeCost: false,
maxBulkAmount: Decimal.dInf
})).canMaximize
)
).toBe(true));
test("Invertible formula cannot maximize if cumulativeCost is true", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
cost: Formula.variable(resource).lambertw(),
cumulativeCost: true,
maxBulkAmount: Decimal.dInf
})).canMaximize
)
).toBe(false));
test("Integrable formula can maximize if cumulativeCost is false", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
cost: Formula.variable(resource).pow(2),
cumulativeCost: false,
maxBulkAmount: Decimal.dInf
})).canMaximize
)
).toBe(true));
test("Integrable formula can maximize if cumulativeCost is true", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
cost: Formula.variable(resource).pow(2),
cumulativeCost: true,
maxBulkAmount: Decimal.dInf
})).canMaximize
)
).toBe(true));
});
2023-02-07 14:31:09 +00:00
test("Requirements met capped by maxBulkAmount", () =>
expect(
unref(
createCostRequirement(() => ({
resource,
2023-05-15 12:40:00 +00:00
cost: Formula.variable(resource).times(0.0001),
maxBulkAmount: 10,
cumulativeCost: false
})).requirementMet
)
).compare_tolerance(10));
2023-02-07 14:31:09 +00:00
});
test("Creating visibility requirement", () => {
const visibility = ref<Visibility.None | Visibility.Visible | boolean>(Visibility.Visible);
const requirement = createVisibilityRequirement({ visibility });
expect(unref(requirement.requirementMet)).toBe(true);
visibility.value = true;
expect(unref(requirement.requirementMet)).toBe(true);
visibility.value = Visibility.None;
expect(unref(requirement.requirementMet)).toBe(false);
visibility.value = false;
expect(unref(requirement.requirementMet)).toBe(false);
});
2023-02-07 14:31:09 +00:00
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);
2023-02-07 14:31:09 +00:00
});
describe("Checking all requirements met", () => {
let metRequirement: Requirement;
let unmetRequirement: Requirement;
beforeAll(() => {
metRequirement = createBooleanRequirement(true);
unmetRequirement = createBooleanRequirement(false);
});
test("Returns true if no requirements", () => {
expect(requirementsMet([])).toBe(true);
});
test("Returns true if all requirements met", () => {
expect(requirementsMet([metRequirement, metRequirement])).toBe(true);
});
test("Returns false if any requirements unmet", () => {
expect(requirementsMet([metRequirement, unmetRequirement])).toBe(false);
});
});
describe("Checking maximum levels of requirements met", () => {
test("Returns 0 if any requirement is not met", () => {
const requirements = [
createBooleanRequirement(false),
createBooleanRequirement(true),
createCostRequirement(() => ({
resource: createResource(ref(10)),
2023-03-21 05:15:28 +00:00
cost: Formula.variable(0),
cumulativeCost: false
2023-02-07 14:31:09 +00:00
}))
];
2023-02-09 13:41:58 +00:00
expect(maxRequirementsMet(requirements)).compare_tolerance(0);
2023-02-07 14:31:09 +00:00
});
test("Returns correct number of requirements met", () => {
const requirements = [
createBooleanRequirement(true),
createCostRequirement(() => ({
resource: createResource(ref(10)),
2023-03-21 05:15:28 +00:00
cost: Formula.variable(0),
cumulativeCost: false,
maxBulkAmount: Decimal.dInf
2023-02-07 14:31:09 +00:00
}))
];
2023-02-09 13:41:58 +00:00
expect(maxRequirementsMet(requirements)).compare_tolerance(10);
2023-02-07 14:31:09 +00:00
});
});
test("Paying requirements", () => {
const resource = createResource(ref(100));
const noPayment = createCostRequirement(() => ({
resource,
cost: 10,
2023-03-21 05:15:28 +00:00
requiresPay: false,
cumulativeCost: false
2023-02-07 14:31:09 +00:00
}));
const payment = createCostRequirement(() => ({
resource,
2023-03-21 05:15:28 +00:00
cost: 10,
cumulativeCost: false
2023-02-07 14:31:09 +00:00
}));
payRequirements([noPayment, payment]);
expect(resource.value).compare_tolerance(90);
});