BlueGit

timfa questward

Files

questward / server / tests / crafting.test.js

crafting.test.js

crafting.test.js 16.8 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { BlockType, blockDefinition } from "../../shared/definitions/tiles.js";
4import { CraftingStationId, CRAFT_DURATION_MS } from "../../shared/definitions/craftingStations.js";
5import { ItemId } from "../../shared/definitions/items.js";
6import { ArmourItemId } from "../../shared/definitions/armourItems.js";
7import { SkillId } from "../../shared/definitions/skills.js";
8import {
9 MaterialTier,
10 GatherMaterialId,
11 tierSmeltSkillLevel,
12 smeltingDurationMs,
13 associatedBarTier
14} from "../../shared/definitions/materialTiers.js";
15import { craftDurationMs } from "../../shared/definitions/gathering.js";
16import { recipesForStation, recipeDefinition } from "../../shared/crafting/stationRecipes.js";
17import { emptyEquipment, emptySlots } from "../../shared/items/inventory.js";
18import { totalXpForLevel } from "../../shared/skills/progression.js";
19import { makeCharacter, makeSimulation } from "./helpers/simulationHarness.js";
20import { Component } from "../src/ecs/components.js";
21
22function countItem (slots, itemId)
23{
24 return (slots ?? []).reduce((sum, slot) =>
25 {
26 if (slot?.itemId === itemId)
27 { return sum + (slot.quantity | 0); }
28 return sum;
29 }, 0);
30}
31
32function placeFurnace (worker, tileX, tileY)
33{
34 const data = worker.world.chunkData(Math.floor(tileX / 16), Math.floor(tileY / 16));
35 const localX = tileX % 16;
36 const localY = tileY % 16;
37 data.blocks[localY * 16 + localX] = {
38 typeId: BlockType.furnace,
39 state: "furnace",
40 config: null
41 };
42}
43
44function setSkillLevel (worker, playerId, skillId, level)
45{
46 const handle = worker.world.ecs.handleOf(playerId);
47 const skills = worker.world.ecs.get(handle, Component.skills);
48 skills.xp[skillId] = totalXpForLevel(level);
49}
50
51function giveInventory (harness, playerId, items)
52{
53 const inventory = emptySlots();
54 items.forEach((stack, index) =>
55 {
56 inventory[index] = { itemId: stack.itemId, quantity: stack.quantity };
57 });
58 harness.simulation.applyBag(playerId, {
59 inventory,
60 equipment: emptyEquipment(),
61 vault: [],
62 vaultReserved: []
63 });
64}
65
66function advanceMs (harness, ms)
67{
68 const ticks = Math.ceil(ms / 50) + 3;
69 for (let i = 0; i < ticks; i++)
70 {
71 harness.advance(50);
72 harness.simulation.step();
73 }
74}
75
76test("furnace recipes: bronze is tin+copper; steel is iron+coal; high tiers need coal", () =>
77{
78 assert.equal(blockDefinition(BlockType.furnace)?.key, "furnace");
79 const bronze = recipeDefinition("smelt-bronze");
80 assert.deepEqual(bronze.inputs.map((row) => row.itemId).sort(), [
81 ItemId.copperOre,
82 ItemId.tinOre
83 ].sort());
84 assert.equal(bronze.output.itemId, ItemId.bronzeBar);
85 assert.equal(bronze.minSkillLevel, tierSmeltSkillLevel(MaterialTier.bronze));
86
87 const steel = recipesForStation(CraftingStationId.furnace)
88 .find((recipe) => recipe.recipeId === "smelt-steel");
89 assert.ok(steel);
90 assert.deepEqual(steel.inputs.map((row) => row.itemId).sort(), [
91 ItemId.coal,
92 ItemId.ironOre
93 ].sort());
94 assert.equal(steel.output.itemId, ItemId.steelBar);
95
96 const silver = recipesForStation(CraftingStationId.furnace)
97 .find((recipe) => recipe.recipeId === "smelt-silver");
98 assert.ok(silver);
99 assert.deepEqual(silver.inputs.map((row) => row.itemId), [ItemId.silverOre]);
100 assert.equal(silver.output.itemId, ItemId.silverBar);
101 assert.equal(silver.minSkillLevel, tierSmeltSkillLevel(GatherMaterialId.silver));
102
103 const gold = recipesForStation(CraftingStationId.furnace)
104 .find((recipe) => recipe.recipeId === "smelt-gold");
105 assert.ok(gold);
106 assert.deepEqual(gold.inputs.map((row) => row.itemId), [ItemId.goldOre]);
107 assert.equal(gold.output.itemId, ItemId.goldBar);
108 assert.equal(gold.minSkillLevel, tierSmeltSkillLevel(GatherMaterialId.gold));
109
110 const adamantium = recipeDefinition("smelt-adamantium");
111 assert.deepEqual(adamantium.inputs, [
112 { itemId: ItemId.adamantiumOre, quantity: 1 },
113 { itemId: ItemId.coal, quantity: 1 }
114 ]);
115 const orichalcum = recipeDefinition("smelt-orichalcum");
116 assert.deepEqual(orichalcum.inputs, [
117 { itemId: ItemId.orichalcumOre, quantity: 1 },
118 { itemId: ItemId.coal, quantity: 3 }
119 ]);
120 const dragon = recipeDefinition("smelt-dragon");
121 assert.deepEqual(dragon.inputs, [
122 { itemId: ItemId.dragonOre, quantity: 1 },
123 { itemId: ItemId.coal, quantity: 5 }
124 ]);
125});
126
127test("tin copper coal map to associated bar tiers for smelt duration", () =>
128{
129 assert.equal(associatedBarTier(GatherMaterialId.tin), MaterialTier.bronze);
130 assert.equal(associatedBarTier(GatherMaterialId.copper), MaterialTier.bronze);
131 assert.equal(associatedBarTier(GatherMaterialId.coal), MaterialTier.steel);
132 assert.equal(associatedBarTier(GatherMaterialId.silver), GatherMaterialId.silver);
133 assert.equal(associatedBarTier(GatherMaterialId.gold), GatherMaterialId.gold);
134 assert.equal(smeltingDurationMs(MaterialTier.bronze), 2000);
135 assert.equal(smeltingDurationMs(GatherMaterialId.tin), 2000);
136 assert.equal(smeltingDurationMs(MaterialTier.steel), 6000);
137 assert.equal(smeltingDurationMs(GatherMaterialId.coal), 6000);
138 assert.equal(smeltingDurationMs(GatherMaterialId.silver), 4000);
139 assert.equal(smeltingDurationMs(GatherMaterialId.gold), 6000);
140 assert.equal(craftDurationMs(recipeDefinition("smelt-bronze"), CRAFT_DURATION_MS), 2000);
141 assert.equal(craftDurationMs(recipeDefinition("smelt-steel"), CRAFT_DURATION_MS), 6000);
142 assert.equal(craftDurationMs(recipeDefinition("smelt-silver"), CRAFT_DURATION_MS), 4000);
143 assert.equal(craftDurationMs(recipeDefinition("smelt-gold"), CRAFT_DURATION_MS), 6000);
144});
145
146test("open furnace near station emits shove and station-open", () =>
147{
148 const harness = makeSimulation({ workerCount: 1 });
149 try
150 {
151 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
152 const playerId = harness.simulation.spawnCharacter(1, character);
153 const record = harness.simulation.entityRecord(playerId);
154 const worker = harness.simulation.workers[record.workerId];
155 placeFurnace(worker, 9, 8);
156
157 harness.simulation.enqueue(1, {
158 type: "open-station",
159 characterId: character.character_id,
160 stationId: CraftingStationId.furnace
161 });
162 const result = harness.simulation.step();
163 assert.ok(result.events.some((event) => event.type === "tile-shove"));
164 assert.ok(result.events.some((event) =>
165 event.type === "station-open" && event.stationId === CraftingStationId.furnace));
166 }
167 finally
168 { harness.close(); }
169});
170
171test("open leatherworking table near station emits station-open", () =>
172{
173 const harness = makeSimulation({ workerCount: 1 });
174 try
175 {
176 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
177 const playerId = harness.simulation.spawnCharacter(1, character);
178 const record = harness.simulation.entityRecord(playerId);
179 const worker = harness.simulation.workers[record.workerId];
180 const data = worker.world.chunkData(Math.floor(9 / 16), Math.floor(8 / 16));
181 data.blocks[8 * 16 + 9] = {
182 typeId: BlockType.leatherworkingTable,
183 state: "leatherworking-table",
184 config: null
185 };
186
187 harness.simulation.enqueue(1, {
188 type: "open-station",
189 characterId: character.character_id,
190 stationId: CraftingStationId.leatherworkingStation
191 });
192 const result = harness.simulation.step();
193 assert.ok(result.events.some((event) =>
194 event.type === "station-open" && event.stationId === CraftingStationId.leatherworkingStation));
195 }
196 finally
197 { harness.close(); }
198});
199
200test("smelting bronze consumes tin and copper, grants bar and Smithing XP", () =>
201{
202 const harness = makeSimulation({ workerCount: 1 });
203 try
204 {
205 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
206 const playerId = harness.simulation.spawnCharacter(1, character);
207 const record = harness.simulation.entityRecord(playerId);
208 const worker = harness.simulation.workers[record.workerId];
209 placeFurnace(worker, 9, 8);
210 giveInventory(harness, playerId, [
211 { itemId: ItemId.tinOre, quantity: 1 },
212 { itemId: ItemId.copperOre, quantity: 1 }
213 ]);
214
215 harness.simulation.enqueue(1, {
216 type: "start-craft",
217 characterId: character.character_id,
218 stationId: CraftingStationId.furnace,
219 recipeId: "smelt-bronze"
220 });
221 const start = harness.simulation.step();
222 assert.ok(start.events.some((event) => event.type === "tile-shove"));
223 assert.ok(start.events.some((event) =>
224 event.type === "item-bubble" && event.itemId === ItemId.bronzeBar));
225
226 const smithingBefore = harness.stateDb.getSkills(character.character_id).xp.smithing ?? 0;
227 advanceMs(harness, craftDurationMs(recipeDefinition("smelt-bronze"), CRAFT_DURATION_MS));
228
229 const bag = harness.simulation.bagOf(playerId);
230 assert.equal(countItem(bag.inventory, ItemId.tinOre), 0);
231 assert.equal(countItem(bag.inventory, ItemId.copperOre), 0);
232 assert.equal(countItem(bag.inventory, ItemId.bronzeBar), 1);
233 const bar = (bag.inventory ?? []).find((slot) => slot?.itemId === ItemId.bronzeBar);
234 assert.equal(bar?.origins?.[0]?.origin?.verb, "Forged");
235 assert.match(bar?.origins?.[0]?.origin?.displayName ?? "", /^Ada/);
236 const smithingAfter = harness.stateDb.getSkills(character.character_id).xp.smithing ?? 0;
237 assert.ok(smithingAfter > smithingBefore);
238 }
239 finally
240 { harness.close(); }
241});
242
243test("smelting steel requires iron ore and coal", () =>
244{
245 const harness = makeSimulation({ workerCount: 1 });
246 try
247 {
248 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
249 const playerId = harness.simulation.spawnCharacter(1, character);
250 const record = harness.simulation.entityRecord(playerId);
251 const worker = harness.simulation.workers[record.workerId];
252 placeFurnace(worker, 9, 8);
253 setSkillLevel(worker, playerId, SkillId.smithing, tierSmeltSkillLevel(MaterialTier.steel));
254 giveInventory(harness, playerId, [
255 { itemId: ItemId.ironOre, quantity: 1 },
256 { itemId: ItemId.coal, quantity: 1 }
257 ]);
258
259 harness.simulation.enqueue(1, {
260 type: "start-craft",
261 characterId: character.character_id,
262 stationId: CraftingStationId.furnace,
263 recipeId: "smelt-steel"
264 });
265 harness.simulation.step();
266 advanceMs(harness, craftDurationMs(recipeDefinition("smelt-steel"), CRAFT_DURATION_MS));
267
268 const bag = harness.simulation.bagOf(playerId);
269 assert.equal(countItem(bag.inventory, ItemId.ironOre), 0);
270 assert.equal(countItem(bag.inventory, ItemId.coal), 0);
271 assert.equal(countItem(bag.inventory, ItemId.steelBar), 1);
272 }
273 finally
274 { harness.close(); }
275});
276
277test("craft rejects missing materials", () =>
278{
279 const harness = makeSimulation({ workerCount: 1 });
280 try
281 {
282 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
283 const playerId = harness.simulation.spawnCharacter(1, character);
284 const record = harness.simulation.entityRecord(playerId);
285 const worker = harness.simulation.workers[record.workerId];
286 placeFurnace(worker, 9, 8);
287 giveInventory(harness, playerId, [{ itemId: ItemId.copperOre, quantity: 1 }]);
288
289 harness.simulation.enqueue(1, {
290 type: "start-craft",
291 characterId: character.character_id,
292 stationId: CraftingStationId.furnace,
293 recipeId: "smelt-bronze"
294 });
295 const result = harness.simulation.step();
296 assert.ok(result.events.some((event) =>
297 event.type === "command-error" && /missing|materials/i.test(event.message ?? "")));
298 }
299 finally
300 { harness.close(); }
301});
302
303test("craft rejects low Smithing for iron bars", () =>
304{
305 const harness = makeSimulation({ workerCount: 1 });
306 try
307 {
308 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
309 const playerId = harness.simulation.spawnCharacter(1, character);
310 const record = harness.simulation.entityRecord(playerId);
311 const worker = harness.simulation.workers[record.workerId];
312 placeFurnace(worker, 9, 8);
313 giveInventory(harness, playerId, [{ itemId: ItemId.ironOre, quantity: 1 }]);
314
315 harness.simulation.enqueue(1, {
316 type: "start-craft",
317 characterId: character.character_id,
318 stationId: CraftingStationId.furnace,
319 recipeId: "smelt-iron"
320 });
321 const result = harness.simulation.step();
322 assert.ok(result.events.some((event) =>
323 event.type === "command-error" && /smithing|requires/i.test(event.message ?? "")));
324 }
325 finally
326 { harness.close(); }
327});
328
329test("craft rejects furnace recipes when not next to a furnace", () =>
330{
331 const harness = makeSimulation({ workerCount: 1 });
332 try
333 {
334 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
335 const playerId = harness.simulation.spawnCharacter(1, character);
336 giveInventory(harness, playerId, [
337 { itemId: ItemId.tinOre, quantity: 1 },
338 { itemId: ItemId.copperOre, quantity: 1 }
339 ]);
340
341 harness.simulation.enqueue(1, {
342 type: "start-craft",
343 characterId: character.character_id,
344 stationId: CraftingStationId.furnace,
345 recipeId: "smelt-bronze"
346 });
347 const result = harness.simulation.step();
348 assert.ok(result.events.some((event) =>
349 event.type === "command-error" && /station|next to/i.test(event.message ?? "")));
350 }
351 finally
352 { harness.close(); }
353});
354
355function placeStation (worker, tileX, tileY, typeId, state)
356{
357 const data = worker.world.chunkData(Math.floor(tileX / 16), Math.floor(tileY / 16));
358 const localX = tileX % 16;
359 const localY = tileY % 16;
360 data.blocks[localY * 16 + localX] = {
361 typeId,
362 state,
363 config: null
364 };
365}
366
367test("bronze pickaxe chain: pine log → handle, bar → head, assemble pickaxe", () =>
368{
369 const harness = makeSimulation({ workerCount: 1 });
370 try
371 {
372 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
373 const playerId = harness.simulation.spawnCharacter(1, character);
374 const record = harness.simulation.entityRecord(playerId);
375 const worker = harness.simulation.workers[record.workerId];
376 placeStation(worker, 9, 8, BlockType.woodworkingBench, "woodworking-bench");
377 placeStation(worker, 9, 9, BlockType.anvil, "anvil");
378 placeStation(worker, 8, 9, BlockType.craftingBench, "crafting-bench");
379 giveInventory(harness, playerId, [
380 { itemId: ItemId.pineLog, quantity: 1 },
381 { itemId: ItemId.bronzeBar, quantity: 1 }
382 ]);
383
384 harness.simulation.enqueue(1, {
385 type: "start-craft",
386 characterId: character.character_id,
387 stationId: CraftingStationId.woodworkingBench,
388 recipeId: "handle-pine"
389 });
390 advanceMs(harness, craftDurationMs(recipeDefinition("handle-pine"), CRAFT_DURATION_MS));
391 let bag = harness.simulation.bagOf(playerId);
392 assert.equal(countItem(bag.inventory, ItemId.pineHandle), 1);
393 assert.equal(countItem(bag.inventory, ItemId.pineLog), 0);
394 const handle = (bag.inventory ?? []).find((slot) => slot?.itemId === ItemId.pineHandle);
395 assert.equal(handle?.origins?.[0]?.origin?.verb, "Carved");
396
397 harness.simulation.enqueue(1, {
398 type: "start-craft",
399 characterId: character.character_id,
400 stationId: CraftingStationId.anvil,
401 recipeId: "pickaxe-head-bronze"
402 });
403 advanceMs(harness, craftDurationMs(recipeDefinition("pickaxe-head-bronze"), CRAFT_DURATION_MS));
404 bag = harness.simulation.bagOf(playerId);
405 assert.equal(countItem(bag.inventory, ItemId.bronzePickaxeHead), 1);
406 assert.equal(countItem(bag.inventory, ItemId.bronzeBar), 0);
407 const head = (bag.inventory ?? []).find((slot) => slot?.itemId === ItemId.bronzePickaxeHead);
408 assert.equal(head?.origins?.[0]?.origin?.verb, "Smithed");
409
410 harness.simulation.enqueue(1, {
411 type: "start-craft",
412 characterId: character.character_id,
413 stationId: CraftingStationId.craftingBench,
414 recipeId: "pickaxe-bronze"
415 });
416 advanceMs(harness, craftDurationMs(recipeDefinition("pickaxe-bronze"), CRAFT_DURATION_MS));
417 bag = harness.simulation.bagOf(playerId);
418 assert.equal(countItem(bag.inventory, ItemId.bronzePickaxe), 1);
419 assert.equal(countItem(bag.inventory, ItemId.pineHandle), 0);
420 assert.equal(countItem(bag.inventory, ItemId.bronzePickaxeHead), 0);
421 const pickaxe = (bag.inventory ?? []).find((slot) => slot?.itemId === ItemId.bronzePickaxe);
422 assert.equal(pickaxe?.origins?.[0]?.origin?.verb, "Assembled");
423 assert.match(pickaxe?.origins?.[0]?.origin?.displayName ?? "", /^Ada/);
424 }
425 finally
426 { harness.close(); }
427});
428
429test("anvil armour recipes use bar counts per piece", () =>
430{
431 const chest = recipeDefinition("armour-chestplate-bronze");
432 assert.ok(chest);
433 assert.equal(chest.stationId, CraftingStationId.anvil);
434 assert.equal(chest.output.itemId, ArmourItemId.bronzeChestplate);
435 assert.deepEqual(chest.inputs, [{ itemId: ItemId.bronzeBar, quantity: 6 }]);
436
437 const greaves = recipeDefinition("armour-greaves-iron");
438 assert.deepEqual(greaves.inputs, [{ itemId: ItemId.ironBar, quantity: 4 }]);
439
440 const boots = recipeDefinition("armour-boots-steel");
441 assert.deepEqual(boots.inputs, [{ itemId: ItemId.steelBar, quantity: 2 }]);
442
443 const helmet = recipeDefinition("armour-helmet-mithril");
444 assert.deepEqual(helmet.inputs, [{ itemId: ItemId.mithrilBar, quantity: 2 }]);
445
446 const fullHelm = recipeDefinition("armour-full-helm-adamantium");
447 assert.deepEqual(fullHelm.inputs, [{ itemId: ItemId.adamantiumBar, quantity: 3 }]);
448
449 const horned = recipeDefinition("armour-horned-helm-orichalcum");
450 assert.deepEqual(horned.inputs, [
451 { itemId: ItemId.orichalcumBar, quantity: 2 },
452 { itemId: ItemId.bones, quantity: 1 }
453 ]);
454
455 const anvilArmour = recipesForStation(CraftingStationId.anvil)
456 .filter((recipe) => recipe.recipeId.startsWith("armour-"));
457 assert.equal(anvilArmour.length, 7 * 6);
458});