BlueGit

timfa questward

Files

questward / server / tests / origins.test.js

origins.test.js

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