BlueGit

timfa questward

Files

questward / server / tests / crafting.test.js

crafting.test.js

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