BlueGit

timfa questward

Files

questward / server / tests / crafting.test.js

crafting.test.js

crafting.test.js 13.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 { 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 smithingAfter = harness.stateDb.getSkills(character.character_id).xp.smithing ?? 0;
204 assert.ok(smithingAfter > smithingBefore);
205 }
206 finally
207 { harness.close(); }
208});
209
210test("smelting steel requires iron ore and coal", () =>
211{
212 const harness = makeSimulation({ workerCount: 1 });
213 try
214 {
215 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
216 const playerId = harness.simulation.spawnCharacter(1, character);
217 const record = harness.simulation.entityRecord(playerId);
218 const worker = harness.simulation.workers[record.workerId];
219 placeFurnace(worker, 9, 8);
220 setSkillLevel(worker, playerId, SkillId.smithing, tierSmeltSkillLevel(MaterialTier.steel));
221 giveInventory(harness, playerId, [
222 { itemId: ItemId.ironOre, quantity: 1 },
223 { itemId: ItemId.coal, quantity: 1 }
224 ]);
225
226 harness.simulation.enqueue(1, {
227 type: "start-craft",
228 characterId: character.character_id,
229 stationId: CraftingStationId.furnace,
230 recipeId: "smelt-steel"
231 });
232 harness.simulation.step();
233 advanceMs(harness, craftDurationMs(recipeDefinition("smelt-steel"), CRAFT_DURATION_MS));
234
235 const bag = harness.simulation.bagOf(playerId);
236 assert.equal(countItem(bag.inventory, ItemId.ironOre), 0);
237 assert.equal(countItem(bag.inventory, ItemId.coal), 0);
238 assert.equal(countItem(bag.inventory, ItemId.steelBar), 1);
239 }
240 finally
241 { harness.close(); }
242});
243
244test("craft rejects missing materials", () =>
245{
246 const harness = makeSimulation({ workerCount: 1 });
247 try
248 {
249 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
250 const playerId = harness.simulation.spawnCharacter(1, character);
251 const record = harness.simulation.entityRecord(playerId);
252 const worker = harness.simulation.workers[record.workerId];
253 placeFurnace(worker, 9, 8);
254 giveInventory(harness, playerId, [{ itemId: ItemId.copperOre, quantity: 1 }]);
255
256 harness.simulation.enqueue(1, {
257 type: "start-craft",
258 characterId: character.character_id,
259 stationId: CraftingStationId.furnace,
260 recipeId: "smelt-bronze"
261 });
262 const result = harness.simulation.step();
263 assert.ok(result.events.some((event) =>
264 event.type === "command-error" && /missing|materials/i.test(event.message ?? "")));
265 }
266 finally
267 { harness.close(); }
268});
269
270test("craft rejects low Smithing for iron bars", () =>
271{
272 const harness = makeSimulation({ workerCount: 1 });
273 try
274 {
275 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
276 const playerId = harness.simulation.spawnCharacter(1, character);
277 const record = harness.simulation.entityRecord(playerId);
278 const worker = harness.simulation.workers[record.workerId];
279 placeFurnace(worker, 9, 8);
280 giveInventory(harness, playerId, [{ itemId: ItemId.ironOre, quantity: 1 }]);
281
282 harness.simulation.enqueue(1, {
283 type: "start-craft",
284 characterId: character.character_id,
285 stationId: CraftingStationId.furnace,
286 recipeId: "smelt-iron"
287 });
288 const result = harness.simulation.step();
289 assert.ok(result.events.some((event) =>
290 event.type === "command-error" && /smithing|requires/i.test(event.message ?? "")));
291 }
292 finally
293 { harness.close(); }
294});
295
296test("craft rejects furnace recipes when not next to a furnace", () =>
297{
298 const harness = makeSimulation({ workerCount: 1 });
299 try
300 {
301 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
302 const playerId = harness.simulation.spawnCharacter(1, character);
303 giveInventory(harness, playerId, [
304 { itemId: ItemId.tinOre, quantity: 1 },
305 { itemId: ItemId.copperOre, quantity: 1 }
306 ]);
307
308 harness.simulation.enqueue(1, {
309 type: "start-craft",
310 characterId: character.character_id,
311 stationId: CraftingStationId.furnace,
312 recipeId: "smelt-bronze"
313 });
314 const result = harness.simulation.step();
315 assert.ok(result.events.some((event) =>
316 event.type === "command-error" && /station|next to/i.test(event.message ?? "")));
317 }
318 finally
319 { harness.close(); }
320});
321
322function placeStation (worker, tileX, tileY, typeId, state)
323{
324 const data = worker.world.chunkData(Math.floor(tileX / 16), Math.floor(tileY / 16));
325 const localX = tileX % 16;
326 const localY = tileY % 16;
327 data.blocks[localY * 16 + localX] = {
328 typeId,
329 state,
330 config: null
331 };
332}
333
334test("bronze pickaxe chain: pine log → handle, bar → head, assemble pickaxe", () =>
335{
336 const harness = makeSimulation({ workerCount: 1 });
337 try
338 {
339 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
340 const playerId = harness.simulation.spawnCharacter(1, character);
341 const record = harness.simulation.entityRecord(playerId);
342 const worker = harness.simulation.workers[record.workerId];
343 placeStation(worker, 9, 8, BlockType.woodworkingBench, "woodworking-bench");
344 placeStation(worker, 9, 9, BlockType.anvil, "anvil");
345 placeStation(worker, 8, 9, BlockType.craftingBench, "crafting-bench");
346 giveInventory(harness, playerId, [
347 { itemId: ItemId.pineLog, quantity: 1 },
348 { itemId: ItemId.bronzeBar, quantity: 1 }
349 ]);
350
351 harness.simulation.enqueue(1, {
352 type: "start-craft",
353 characterId: character.character_id,
354 stationId: CraftingStationId.woodworkingBench,
355 recipeId: "handle-pine"
356 });
357 advanceMs(harness, craftDurationMs(recipeDefinition("handle-pine"), CRAFT_DURATION_MS));
358 let bag = harness.simulation.bagOf(playerId);
359 assert.equal(countItem(bag.inventory, ItemId.pineHandle), 1);
360 assert.equal(countItem(bag.inventory, ItemId.pineLog), 0);
361
362 harness.simulation.enqueue(1, {
363 type: "start-craft",
364 characterId: character.character_id,
365 stationId: CraftingStationId.anvil,
366 recipeId: "pickaxe-head-bronze"
367 });
368 advanceMs(harness, craftDurationMs(recipeDefinition("pickaxe-head-bronze"), CRAFT_DURATION_MS));
369 bag = harness.simulation.bagOf(playerId);
370 assert.equal(countItem(bag.inventory, ItemId.bronzePickaxeHead), 1);
371 assert.equal(countItem(bag.inventory, ItemId.bronzeBar), 0);
372
373 harness.simulation.enqueue(1, {
374 type: "start-craft",
375 characterId: character.character_id,
376 stationId: CraftingStationId.craftingBench,
377 recipeId: "pickaxe-bronze"
378 });
379 advanceMs(harness, craftDurationMs(recipeDefinition("pickaxe-bronze"), CRAFT_DURATION_MS));
380 bag = harness.simulation.bagOf(playerId);
381 assert.equal(countItem(bag.inventory, ItemId.bronzePickaxe), 1);
382 assert.equal(countItem(bag.inventory, ItemId.pineHandle), 0);
383 assert.equal(countItem(bag.inventory, ItemId.bronzePickaxeHead), 0);
384 }
385 finally
386 { harness.close(); }
387});