BlueGit

timfa questward

Files

questward / server / tests / woodcutting.test.js

woodcutting.test.js

woodcutting.test.js 6.6 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { WoodTier, tierRank } from "../../shared/definitions/materialTiers.js";
4import {
5 canChopWood,
6 woodcuttingDurationMs,
7 treeExhaustDurationMs,
8 logItemIdForWoodTier
9} from "../../shared/definitions/gathering.js";
10import { ItemId, itemDefinition } from "../../shared/definitions/items.js";
11import { SkillId } from "../../shared/definitions/skills.js";
12import { BlockType, isChopableTreeBlock, woodTierForTreeBlock } from "../../shared/definitions/tiles.js";
13import { SeasonId, resolveSeasonalVisualState, treeStumpStateForSeason } from "../../shared/world/season.js";
14import { ItemOriginKind, GatherOriginVerb } from "../../shared/items/origin.js";
15import { totalXpForLevel } from "../../shared/skills/progression.js";
16import { makeCharacter, makeSimulation } from "./helpers/simulationHarness.js";
17import { Component } from "../src/ecs/components.js";
18
19function countItem (slots, itemId)
20{
21 return (slots ?? []).reduce((sum, slot) =>
22 {
23 if (slot?.itemId === itemId)
24 { return sum + (slot.quantity | 0); }
25 return sum;
26 }, 0);
27}
28
29function placeTree (worker, tileX, tileY, state = SeasonId.summer)
30{
31 const data = worker.world.chunkData(Math.floor(tileX / 16), Math.floor(tileY / 16));
32 const localX = tileX % 16;
33 const localY = tileY % 16;
34 const index = localY * 16 + localX;
35 data.blocks[index] = { typeId: BlockType.pineTree, state, config: null };
36 return { data, index };
37}
38
39function bagAxe (worker, playerId, itemId)
40{
41 const handle = worker.world.ecs.handleOf(playerId);
42 const inventory = worker.world.ecs.get(handle, Component.inventory);
43 inventory.slots[0] = { itemId, quantity: 1 };
44}
45
46function setSkillLevel (worker, playerId, skillId, level)
47{
48 const handle = worker.world.ecs.handleOf(playerId);
49 const skills = worker.world.ecs.get(handle, Component.skills);
50 skills.xp[skillId] = totalXpForLevel(level);
51}
52
53function advanceMs (harness, ms)
54{
55 const ticks = Math.ceil(ms / 50) + 3;
56 for (let i = 0; i < ticks; i++)
57 {
58 harness.advance(50);
59 harness.simulation.step();
60 }
61}
62
63test("pine tree yields pine logs and uses axe gates", () =>
64{
65 assert.equal(woodTierForTreeBlock(BlockType.pineTree), WoodTier.pine);
66 assert.equal(logItemIdForWoodTier(WoodTier.pine), ItemId.pineLog);
67 assert.equal(itemDefinition(ItemId.bronzeAxe)?.equipment?.kind, "axeTool");
68 assert.equal(canChopWood(1, WoodTier.pine, WoodTier.pine).ok, true);
69 assert.equal(canChopWood(1, WoodTier.pine, WoodTier.birch).ok, false);
70 assert.equal(woodcuttingDurationMs(WoodTier.pine, WoodTier.pine), 5000);
71 assert.equal(treeExhaustDurationMs(WoodTier.pine), 10_000);
72});
73
74test("seasonal stump state follows calendar season", () =>
75{
76 const states = ["fall", "fall-stump", "summer", "summer-stump", "winter", "winter-stump"];
77 assert.equal(
78 resolveSeasonalVisualState(states, "summer-stump", SeasonId.winter),
79 "winter-stump"
80 );
81 assert.equal(
82 resolveSeasonalVisualState(states, "summer", SeasonId.fall),
83 SeasonId.fall
84 );
85 assert.equal(treeStumpStateForSeason(SeasonId.summer), "summer-stump");
86 assert.equal(isChopableTreeBlock({ typeId: BlockType.pineTree, state: "summer" }), true);
87 assert.equal(isChopableTreeBlock({ typeId: BlockType.pineTree, state: "summer-stump" }), false);
88});
89
90test("chopping without an axe is rejected", () =>
91{
92 const harness = makeSimulation({ workerCount: 1 });
93 try
94 {
95 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
96 const playerId = harness.simulation.spawnCharacter(1, character);
97 const record = harness.simulation.entityRecord(playerId);
98 const worker = harness.simulation.workers[record.workerId];
99 placeTree(worker, 9, 8);
100
101 harness.simulation.enqueue(1, {
102 type: "chop",
103 characterId: character.character_id,
104 tileX: 9,
105 tileY: 8
106 });
107 const result = harness.simulation.step();
108 assert.ok(result.events.some((event) =>
109 event.type === "command-error"
110 && event.message === "You need an axe to chop this!"));
111 }
112 finally
113 { harness.close(); }
114});
115
116test("chopping a pine tree yields a pine log, stump, and woodcutting XP", () =>
117{
118 const harness = makeSimulation({ workerCount: 1 });
119 try
120 {
121 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
122 const playerId = harness.simulation.spawnCharacter(1, character);
123 const record = harness.simulation.entityRecord(playerId);
124 const worker = harness.simulation.workers[record.workerId];
125 bagAxe(worker, playerId, ItemId.bronzeAxe);
126 setSkillLevel(worker, playerId, SkillId.woodcutting, 1);
127 placeTree(worker, 9, 8, SeasonId.summer);
128
129 harness.simulation.enqueue(1, {
130 type: "chop",
131 characterId: character.character_id,
132 tileX: 9,
133 tileY: 8
134 });
135 const start = harness.simulation.step();
136 assert.ok(start.events.some((event) =>
137 event.type === "gather-swing"
138 && event.toolItemId === ItemId.bronzeAxe), JSON.stringify(start.events));
139 advanceMs(harness, woodcuttingDurationMs(WoodTier.pine, WoodTier.pine) + 200);
140
141 const handle = worker.world.ecs.handleOf(playerId);
142 const inventory = worker.world.ecs.get(handle, Component.inventory);
143 assert.equal(countItem(inventory.slots, ItemId.pineLog), 1);
144 const log = inventory.slots.find((slot) => slot?.itemId === ItemId.pineLog);
145 assert.equal(log?.origins?.[0]?.origin?.kind, ItemOriginKind.gathered);
146 assert.equal(log?.origins?.[0]?.origin?.verb, GatherOriginVerb.felled);
147
148 const block = worker.world.chunkData(0, 0).blocks[8 * 16 + 9];
149 assert.equal(block.typeId, BlockType.pineTree);
150 assert.ok(String(block.state).endsWith("-stump"));
151 assert.equal(isChopableTreeBlock(block), false);
152
153 const skills = worker.world.ecs.get(handle, Component.skills);
154 assert.ok((skills.xp[SkillId.woodcutting] | 0) > totalXpForLevel(1));
155 }
156 finally
157 { harness.close(); }
158});
159
160test("tree stump respawns after exhaust duration", () =>
161{
162 const harness = makeSimulation({ workerCount: 1 });
163 try
164 {
165 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
166 const playerId = harness.simulation.spawnCharacter(1, character);
167 const record = harness.simulation.entityRecord(playerId);
168 const worker = harness.simulation.workers[record.workerId];
169 bagAxe(worker, playerId, ItemId.bronzeAxe);
170 placeTree(worker, 9, 8);
171
172 harness.simulation.enqueue(1, {
173 type: "chop",
174 characterId: character.character_id,
175 tileX: 9,
176 tileY: 8
177 });
178 advanceMs(harness, woodcuttingDurationMs(WoodTier.pine, WoodTier.pine) + 200);
179 assert.ok(String(worker.world.chunkData(0, 0).blocks[8 * 16 + 9].state).endsWith("-stump"));
180
181 advanceMs(harness, treeExhaustDurationMs(WoodTier.pine) + 200);
182 const block = worker.world.chunkData(0, 0).blocks[8 * 16 + 9];
183 assert.equal(isChopableTreeBlock(block), true);
184 assert.equal(tierRank(WoodTier.pine), 1);
185 }
186 finally
187 { harness.close(); }
188});