BlueGit

timfa questward

Files

questward / server / tests / origins.test.js

origins.test.js

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