BlueGit

timfa questward

Files

questward / server / tests / origins.test.js

origins.test.js

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