357 lines
14 KiB
TypeScript
357 lines
14 KiB
TypeScript
import { content } from "@deadhead/content";
|
|
import type { LogEntry, SaveDocument } from "@deadhead/schema";
|
|
import { flightNet, pilotLevel, skillPointsAvailable } from "@deadhead/sim";
|
|
import { describe, expect, it } from "vitest";
|
|
import {
|
|
addPilot,
|
|
addShip,
|
|
edit,
|
|
newTestApp,
|
|
putBoard,
|
|
readSave,
|
|
setCredits,
|
|
signUpOwner,
|
|
testContract,
|
|
type TestApp,
|
|
} from "./support";
|
|
|
|
const HOUR = 60 * 60_000;
|
|
const DAY = 24 * HOUR;
|
|
const of = <K extends LogEntry["kind"]>(save: SaveDocument, kind: K) =>
|
|
save.logbook.filter((e): e is Extract<LogEntry, { kind: K }> => e.kind === kind);
|
|
|
|
/** An owner with the avatar's Courier at Earth; returns ids. */
|
|
async function owner(test: TestApp) {
|
|
const o = await signUpOwner(test.app);
|
|
await setCredits(test.app, 100_000);
|
|
return o;
|
|
}
|
|
|
|
/** Flies the avatar on a board contract and lets it land. */
|
|
async function deliver(test: TestApp, avatarId: string, shipId: string, over = {}) {
|
|
const contract = testContract({
|
|
offeredAt: test.clock.now,
|
|
expiresAt: test.clock.now + HOUR,
|
|
...over,
|
|
});
|
|
await putBoard(test.app, [contract], test.clock.now);
|
|
const { dispatch } = await test.app.call("createDispatch", {
|
|
kind: "contract",
|
|
contractId: contract.id,
|
|
shipId,
|
|
pilotId: avatarId,
|
|
});
|
|
test.clock.now = dispatch.arrivalAt + 1_000;
|
|
await test.app.call("getPlayerState", {});
|
|
return { contract, dispatch, save: await readSave(test.app) };
|
|
}
|
|
|
|
describe("logbook entries (Step 25.1, decision 0.5.141)", () => {
|
|
it("logs a delivery with its pilot, ship, route, payout, pilot pay, fuel, loan and XP", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
const { contract, dispatch, save } = await deliver(test, o.avatarId, o.shipId);
|
|
const [flight] = of(save, "flight");
|
|
expect(flight).toMatchObject({
|
|
id: `${dispatch.id}:flight`,
|
|
at: dispatch.arrivalAt,
|
|
pilotId: o.avatarId,
|
|
shipId: o.shipId,
|
|
dispatchId: dispatch.id,
|
|
deadhead: false,
|
|
independent: false,
|
|
originId: "earth",
|
|
destinationId: "moon",
|
|
goodId: contract.goodId,
|
|
massTonnes: contract.massTonnes,
|
|
shipper: contract.shipper,
|
|
payout: contract.payout,
|
|
pilotPay: 0,
|
|
fuelCost: dispatch.fuelCost,
|
|
loanRepayment: 0,
|
|
});
|
|
expect(flight!.xp).toBeGreaterThan(0);
|
|
expect(of(save, "flight")).toHaveLength(1);
|
|
});
|
|
|
|
it("logs a deadhead, the Auto top-up on landing, and fuel the player buys", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
await test.app.call("setRefuelPolicy", { shipId: o.shipId, policy: "auto" });
|
|
const { dispatch } = await test.app.call("createDispatch", {
|
|
kind: "reposition",
|
|
shipId: o.shipId,
|
|
pilotId: o.avatarId,
|
|
destinationId: "moon",
|
|
});
|
|
test.clock.now = dispatch.arrivalAt + 1_000;
|
|
await test.app.call("getPlayerState", {});
|
|
let save = await readSave(test.app);
|
|
expect(of(save, "flight")).toEqual([
|
|
expect.objectContaining({
|
|
deadhead: true,
|
|
payout: 0,
|
|
goodId: null,
|
|
fuelCost: dispatch.fuelCost,
|
|
}),
|
|
]);
|
|
expect(of(save, "refuel")).toEqual([
|
|
expect.objectContaining({
|
|
id: `${dispatch.id}:top-up`,
|
|
source: "top-up",
|
|
locationId: "moon",
|
|
}),
|
|
]);
|
|
|
|
await test.app.call("setRefuelPolicy", { shipId: o.shipId, policy: "manual" });
|
|
await edit(test.app, (s) => {
|
|
s.ships.find((x) => x.id === o.shipId)!.fuelFu -= 5;
|
|
});
|
|
await test.app.call("refuelShip", { shipId: o.shipId, amountFu: 5 });
|
|
save = await readSave(test.app);
|
|
const bought = of(save, "refuel").filter((e) => e.source === "bought");
|
|
expect(bought).toEqual([
|
|
expect.objectContaining({ shipId: o.shipId, pilotId: o.avatarId, locationId: "moon" }),
|
|
]);
|
|
expect(bought[0]!.boughtFu).toBeCloseTo(5);
|
|
expect(bought[0]!.cost).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("logs a rest the player orders and one forced by the duty limit", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
await test.app.call("restPilot", { pilotId: o.avatarId });
|
|
let save = await readSave(test.app);
|
|
const ordered = save.pilots.find((p) => p.id === o.avatarId)!.restEndsAt!;
|
|
expect(of(save, "rest")).toEqual([
|
|
expect.objectContaining({ pilotId: o.avatarId, at: test.clock.now, until: ordered }),
|
|
]);
|
|
|
|
test.clock.now = ordered + 1_000;
|
|
await edit(test.app, (s) => {
|
|
s.pilots.find((p) => p.id === o.avatarId)!.dutyHours = content.config.dutyLimitGameHours;
|
|
});
|
|
const { dispatch, save: after } = await deliver(test, o.avatarId, o.shipId);
|
|
save = after;
|
|
expect(of(save, "rest").at(-1)).toMatchObject({
|
|
id: `${dispatch.id}:rest`,
|
|
pilotId: o.avatarId,
|
|
});
|
|
});
|
|
|
|
it("logs an upgrade when its shop time ends", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
const { ship } = await test.app.call("startUpgrade", {
|
|
shipId: o.shipId,
|
|
upgradeId: "engines",
|
|
});
|
|
expect(of(await readSave(test.app), "upgrade")).toEqual([]);
|
|
test.clock.now = ship.inShopUntil! + 1_000;
|
|
await test.app.call("getPlayerState", {});
|
|
expect(of(await readSave(test.app), "upgrade")).toEqual([
|
|
expect.objectContaining({
|
|
at: ship.inShopUntil,
|
|
shipId: o.shipId,
|
|
pilotId: o.avatarId,
|
|
upgradeId: "engines",
|
|
level: 1,
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it("logs a discovery, a level-up with the skill points, and a goal ready to claim", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
let toLevel = 0;
|
|
while (pilotLevel(toLevel, content.config) < 1) toLevel++;
|
|
await edit(test.app, (s) => {
|
|
s.discoveredLocations = s.discoveredLocations.filter((d) => d.locationId !== "moon");
|
|
s.pilots.find((p) => p.id === o.avatarId)!.xp = toLevel - 1;
|
|
});
|
|
const { dispatch, save } = await deliver(test, o.avatarId, o.shipId, { firstContact: true });
|
|
expect(of(save, "discovery")).toEqual([
|
|
expect.objectContaining({ id: `${dispatch.id}:discovery`, locationId: "moon" }),
|
|
]);
|
|
expect(of(save, "level-up")).toEqual([
|
|
expect.objectContaining({
|
|
pilotId: o.avatarId,
|
|
level: 1,
|
|
skillPoints: skillPointsAvailable(1, 0, content.config),
|
|
}),
|
|
]);
|
|
const goals = of(save, "goal-ready");
|
|
expect(goals.length).toBeGreaterThan(0);
|
|
// Each goal once, however often the state is read.
|
|
await test.app.call("getPlayerState", {});
|
|
expect(of(await readSave(test.app), "goal-ready")).toEqual(goals);
|
|
});
|
|
|
|
it("prunes entries older than 7 days on save", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
await deliver(test, o.avatarId, o.shipId);
|
|
const old = of(await readSave(test.app), "flight")[0]!;
|
|
test.clock.now = old.at + 7 * DAY - HOUR;
|
|
await test.app.call("restPilot", { pilotId: o.avatarId });
|
|
expect((await readSave(test.app)).logbook.map((e) => e.id)).toContain(old.id);
|
|
test.clock.now = old.at + 7 * DAY + HOUR;
|
|
await test.app.call("getPlayerState", {});
|
|
const ids = (await readSave(test.app)).logbook.map((e) => e.id);
|
|
expect(ids).not.toContain(old.id);
|
|
expect(ids.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("writes the same entries in catch-up as in live play", async () => {
|
|
const once = newTestApp();
|
|
await owner(once);
|
|
await setCredits(once.app, content.config.independentPilots.dispatchOfficePrice + 50_000);
|
|
await once.app.call("buyDispatchOffice", {});
|
|
for (const id of ["pa", "pb"]) {
|
|
await addShip(once.app, { id: `ship-${id}`, modelId: "courier", name: `Courier ${id}` });
|
|
await addPilot(once.app, { id, name: `Pilot ${id}`, assignedShipId: `ship-${id}` });
|
|
await once.app.call("setPilotMode", { pilotId: id, mode: "independent" });
|
|
}
|
|
await once.app.call("startUpgrade", { shipId: "ship-pa", upgradeId: "engines" });
|
|
const { code } = await once.app.call("exportSave", {});
|
|
const live = newTestApp();
|
|
live.clock.now = once.clock.now;
|
|
await live.app.call("importSave", { code });
|
|
|
|
const end = once.clock.now + 6 * HOUR;
|
|
once.clock.now = end;
|
|
await once.app.call("getPlayerState", {});
|
|
while (live.clock.now < end) {
|
|
live.clock.now = Math.min(end, live.clock.now + 2 * 60_000);
|
|
await live.app.call("getPlayerState", {});
|
|
}
|
|
const a = (await readSave(once.app)).logbook;
|
|
expect(a.filter((e) => e.kind === "flight").length).toBeGreaterThan(10);
|
|
expect(a.some((e) => e.kind === "refuel" && e.source === "pilot")).toBe(true);
|
|
expect(a.some((e) => e.kind === "upgrade")).toBe(true);
|
|
expect((await readSave(live.app)).logbook).toEqual(a);
|
|
}, 60_000);
|
|
|
|
it("starts the next absence when the summary is closed", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
const start = (await readSave(test.app)).player.awaySince;
|
|
const { dispatch } = await deliver(test, o.avatarId, o.shipId);
|
|
await test.app.call("acknowledgeSummaries", { dispatchIds: [dispatch.id] });
|
|
const { player } = await readSave(test.app);
|
|
expect(player.lastAbsence).toEqual({ from: start, to: test.clock.now });
|
|
expect(player.awaySince).toBe(test.clock.now);
|
|
});
|
|
});
|
|
|
|
describe("net earnings (Step 25.2, decision 0.5.142)", () => {
|
|
it("matches the delivery summary: credits after pilot pay and loan, less the fuel used", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
await edit(test.app, (s) => {
|
|
s.company.loanBalance = 50_000;
|
|
});
|
|
const { dispatch, save } = await deliver(test, o.avatarId, o.shipId);
|
|
const summary = (await test.app.call("getPlayerState", {})).summaries.find(
|
|
(s) => s.dispatchId === dispatch.id,
|
|
)!;
|
|
const [entry] = of(save, "flight");
|
|
expect(summary.loanRepayment).toBeGreaterThan(0);
|
|
expect(flightNet(entry!)).toBe(summary.credits - summary.fuelCost);
|
|
});
|
|
});
|
|
|
|
describe("getLogbook and what needs the player (Step 25.3, decision 0.5.140)", () => {
|
|
it("returns the entries, this absence and the last one closed", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
const start = (await readSave(test.app)).player.awaySince;
|
|
const { dispatch } = await deliver(test, o.avatarId, o.shipId);
|
|
let book = await test.app.call("getLogbook", {});
|
|
expect(book.entries.map((e) => e.id)).toContain(`${dispatch.id}:flight`);
|
|
expect(book.absence).toEqual({ from: start, to: test.clock.now });
|
|
expect(book.lastAbsence).toBeNull();
|
|
|
|
const closed = test.clock.now;
|
|
await test.app.call("acknowledgeSummaries", { dispatchIds: [dispatch.id] });
|
|
test.clock.now += HOUR;
|
|
book = await test.app.call("getLogbook", {});
|
|
expect(book.lastAbsence).toEqual({ from: start, to: closed });
|
|
expect(book.absence).toEqual({ from: closed, to: test.clock.now });
|
|
});
|
|
|
|
it("finds a ship too low on fuel, one needing emergency fuel, and credits below the floor", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
await edit(test.app, (s) => {
|
|
s.ships.find((x) => x.id === o.shipId)!.fuelFu = 0;
|
|
});
|
|
let { problems } = await test.app.call("getLogbook", {});
|
|
// Earth sells fuel and the company can pay: a refuel away.
|
|
expect(problems).toEqual([{ kind: "low-fuel", shipId: o.shipId, locationId: "earth" }]);
|
|
|
|
await setCredits(test.app, content.config.independentPilots.dispatchOfficePrice);
|
|
await test.app.call("buyDispatchOffice", {});
|
|
await addShip(test.app, { id: "s2", modelId: "courier", name: "Wren" });
|
|
await addPilot(test.app, { id: "p2", name: "Ada", assignedShipId: "s2" });
|
|
await test.app.call("setPilotMode", { pilotId: "p2", mode: "independent" });
|
|
await setCredits(test.app, 0);
|
|
({ problems } = await test.app.call("getLogbook", {}));
|
|
expect(problems).toEqual([
|
|
{ kind: "emergency-fuel", shipId: o.shipId, locationId: "earth" },
|
|
{
|
|
kind: "below-floor",
|
|
credits: 0,
|
|
floor: content.config.independentPilots.defaultSpendingFloor,
|
|
},
|
|
]);
|
|
});
|
|
|
|
it("finds a Manual ship whose board has no job it can take", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
const heavy = testContract({ massTonnes: 10_000, expiresAt: test.clock.now + HOUR });
|
|
await putBoard(test.app, [heavy], test.clock.now);
|
|
expect((await test.app.call("getLogbook", {})).problems).toEqual([
|
|
{ kind: "no-jobs", shipId: o.shipId, locationId: "earth" },
|
|
]);
|
|
await putBoard(test.app, [testContract({ expiresAt: test.clock.now + HOUR })], test.clock.now);
|
|
await edit(test.app, (s) => {
|
|
s.contractBoards = s.contractBoards.slice(-1);
|
|
});
|
|
expect((await test.app.call("getLogbook", {})).problems).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("seen entries (Step 28.1, decision 0.5.163)", () => {
|
|
it("starts new entries unseen, marks them seen, and keeps that through a reload", async () => {
|
|
const test = newTestApp();
|
|
const o = await owner(test);
|
|
const { dispatch, save } = await deliver(test, o.avatarId, o.shipId);
|
|
const flightId = `${dispatch.id}:flight`;
|
|
expect(save.logbook.length).toBeGreaterThan(0);
|
|
expect(save.logbook.every((e) => !e.seen)).toBe(true);
|
|
|
|
const decidedAt = save.company.lastManualDecisionAt;
|
|
test.clock.now += 60_000;
|
|
expect(
|
|
await test.app.call("markLogbookSeen", { entryIds: [flightId, "no-such-entry"] }),
|
|
).toEqual({ marked: 1 });
|
|
// Again: nothing new to mark.
|
|
expect(await test.app.call("markLogbookSeen", { entryIds: [flightId] })).toEqual({ marked: 0 });
|
|
const after = await readSave(test.app);
|
|
expect(after.logbook.find((e) => e.id === flightId)!.seen).toBe(true);
|
|
expect(after.logbook.filter((e) => e.id !== flightId).every((e) => !e.seen)).toBe(true);
|
|
// Seeing a toast isn't a decision: it doesn't wake the fleet (CR-024).
|
|
expect(after.company.lastManualDecisionAt).toBe(decidedAt);
|
|
|
|
// A reload (the save exported and opened again) keeps it.
|
|
const { code } = await test.app.call("exportSave", {});
|
|
const reloaded = newTestApp();
|
|
reloaded.clock.now = test.clock.now;
|
|
await reloaded.app.call("importSave", { code });
|
|
const book = await reloaded.app.call("getLogbook", {});
|
|
expect(book.entries.find((e) => e.id === flightId)!.seen).toBe(true);
|
|
});
|
|
});
|