BlueGit

timfa questward

Files

questward / server / tests / origins.test.js

origins.test.js

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