BlueGit

timfa questward

Files

questward / server / tests / origins.test.js

origins.test.js

origins.test.js 5.9 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import {
4 ItemOriginKind,
5 GatherOriginVerb,
6 CraftOriginVerb,
7 gatherOrigin,
8 craftOrigin,
9 craftOriginVerbForStation,
10 originLabel,
11 formatOriginBreakdown,
12 mergeOriginLists,
13 splitOrigins
14} from "../../shared/items/origin.js";
15import { CraftingStationId } from "../../shared/definitions/craftingStations.js";
16import { emptySlots, insertStack, takeFromSlot, insertStackGrowable, singleItemFromStack } from "../../shared/items/inventory.js";
17import { stackRulesFor } from "../../shared/items/stackRules.js";
18import { ItemId, itemDefinition } from "../../shared/definitions/items.js";
19
20const crafterA = craftOrigin(CraftOriginVerb.made, "Ada");
21const crafterB = craftOrigin(CraftOriginVerb.made, "Bob");
22
23test("gathered origins use Mined by / Felled by labels", () =>
24{
25 const mined = gatherOrigin(GatherOriginVerb.mined, "Ada Miner");
26 assert.equal(originLabel(mined), "Mined by Ada Miner");
27 assert.equal(formatOriginBreakdown({
28 itemId: ItemId.copperOre,
29 quantity: 2,
30 origins: [{ origin: mined, quantity: 2 }]
31 }), "2 Mined by Ada Miner");
32 assert.equal(originLabel(gatherOrigin(GatherOriginVerb.felled, "Bob")), "Felled by Bob");
33});
34
35test("craft origins use station verbs", () =>
36{
37 assert.equal(craftOriginVerbForStation(CraftingStationId.furnace), CraftOriginVerb.forged);
38 assert.equal(craftOriginVerbForStation(CraftingStationId.anvil), CraftOriginVerb.smithed);
39 assert.equal(craftOriginVerbForStation(CraftingStationId.woodworkingBench), CraftOriginVerb.carved);
40 assert.equal(craftOriginVerbForStation(CraftingStationId.craftingBench), CraftOriginVerb.assembled);
41 assert.equal(originLabel(craftOrigin(CraftOriginVerb.forged, "Ada")), "Forged by Ada");
42 assert.equal(originLabel(craftOrigin(CraftOriginVerb.smithed, "Ada")), "Smithed by Ada");
43 assert.equal(originLabel(craftOrigin(CraftOriginVerb.carved, "Ada")), "Carved by Ada");
44 assert.equal(originLabel(craftOrigin(CraftOriginVerb.assembled, "Ada")), "Assembled by Ada");
45 assert.equal(originLabel({ kind: ItemOriginKind.shop, displayName: "Bob Shop" }), "Bought from Bob Shop");
46});
47
48test("mixed-origin stacks merge and show a breakdown label", () =>
49{
50 const slots = emptySlots();
51 const def = itemDefinition(ItemId.apple);
52 const first = insertStack(slots, {
53 itemId: ItemId.apple,
54 quantity: 5,
55 origins: [{ origin: crafterA, quantity: 5 }]
56 }, def);
57 const second = insertStack(first.slots, {
58 itemId: ItemId.apple,
59 quantity: 3,
60 origins: [{ origin: crafterB, quantity: 3 }]
61 }, def);
62 assert.equal(second.ok, true);
63 assert.equal(second.slots[0].quantity, 8);
64 assert.equal(formatOriginBreakdown(second.slots[0]), "5 Made by Ada, 3 Made by Bob");
65});
66
67test("splitting a stack distributes origins FIFO", () =>
68{
69 const slots = emptySlots();
70 const def = itemDefinition(ItemId.apple);
71 const inserted = insertStack(slots, {
72 itemId: ItemId.apple,
73 quantity: 8,
74 origins: [
75 { origin: crafterA, quantity: 5 },
76 { origin: crafterB, quantity: 3 }
77 ]
78 }, def);
79 const taken = takeFromSlot(inserted.slots, 0, 6);
80 assert.equal(taken.taken.quantity, 6);
81 assert.deepEqual(taken.taken.origins, [
82 { origin: crafterA, quantity: 5 },
83 { origin: crafterB, quantity: 1 }
84 ]);
85 assert.deepEqual(taken.slots[0].origins, [
86 { origin: crafterB, quantity: 2 }
87 ]);
88});
89
90test("equipment stacks only in inventory, but can stack in the vault", () =>
91{
92 const shirt = itemDefinition(ItemId.clothShirt);
93 const invRules = stackRulesFor(shirt, { inVault: false });
94 const vaultRules = stackRulesFor(shirt, { inVault: true });
95 assert.equal(invRules.maxStackSize, 1);
96 assert.equal(invRules.stackable, false);
97 assert.equal(vaultRules.stackable, true);
98 assert.equal(vaultRules.maxStackSize, Number.POSITIVE_INFINITY);
99
100 const inv = insertStack(emptySlots(), { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
101 const invSecond = insertStack(inv.slots, { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
102 assert.equal(invSecond.slots.filter(Boolean).length, 2);
103
104 const vault = insertStackGrowable([], { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
105 const vaultSecond = insertStackGrowable(vault.slots, { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
106 assert.equal(vaultSecond.slots.length, 1);
107 assert.equal(vaultSecond.slots[0].quantity, 2);
108});
109
110test("unique items never stack, even in the vault", () =>
111{
112 const letter = itemDefinition(ItemId.letter);
113 const vaultRules = stackRulesFor(letter, { inVault: true });
114 assert.equal(vaultRules.uniqueInstance, true);
115 assert.equal(vaultRules.stackable, false);
116
117 const first = insertStackGrowable([], {
118 itemId: ItemId.letter,
119 quantity: 1,
120 instance: { kind: "letter", letterId: "a", body: "Hi" }
121 }, letter);
122 const second = insertStackGrowable(first.slots, {
123 itemId: ItemId.letter,
124 quantity: 1,
125 instance: { kind: "letter", letterId: "b", body: "Bye" }
126 }, letter);
127 assert.equal(second.slots.length, 2);
128});
129
130test("mergeOriginLists combines matching crafters", () =>
131{
132 const merged = mergeOriginLists(
133 [{ origin: crafterA, quantity: 2 }],
134 [{ origin: crafterA, quantity: 3 }, { origin: crafterB, quantity: 1 }]
135 );
136 assert.deepEqual(merged, [
137 { origin: crafterA, quantity: 5 },
138 { origin: crafterB, quantity: 1 }
139 ]);
140 const split = splitOrigins(merged, 6);
141 assert.deepEqual(split.taken, [
142 { origin: crafterA, quantity: 5 },
143 { origin: crafterB, quantity: 1 }
144 ]);
145});
146
147test("unequip-style insert merges stackable items within max stack size", () =>
148{
149 const def = itemDefinition(ItemId.apple);
150 const origin = { kind: ItemOriginKind.crafted, displayName: "Ada" };
151 let slots = emptySlots();
152 slots[0] = { itemId: ItemId.apple, quantity: 5, origins: [{ origin, quantity: 5 }] };
153 const worn = singleItemFromStack({
154 itemId: ItemId.apple,
155 quantity: 1,
156 origins: [{ origin, quantity: 1 }]
157 });
158 const inserted = insertStack(slots, worn, def);
159 assert.equal(inserted.ok, true);
160 assert.equal(inserted.slots[0].quantity, 6);
161 assert.equal(inserted.slots.filter(Boolean).length, 1);
162});