BlueGit

timfa questward

Files

questward / server / tests / equipment.test.js

equipment.test.js

equipment.test.js 13.4 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { ItemId, itemDefinition } from "../../shared/definitions/items.js";
4import { ArmourItemId } from "../../shared/definitions/armourItems.js";
5import { LeatherItemId } from "../../shared/definitions/leatherItems.js";
6import { LeatherArmourItemId } from "../../shared/definitions/leatherArmourItems.js";
7import { WizardItemId } from "../../shared/definitions/wizardItems.js";
8import { CraftingItemId } from "../../shared/definitions/craftingItems.js";
9import { MaterialTier, LeatherTier, WoodTier, ClothTier, tierStatBonus, tierMinSkillLevel } from "../../shared/definitions/materialTiers.js";
10import { EquipmentKind } from "../../shared/definitions/equipmentKinds.js";
11import { SkillId } from "../../shared/definitions/skills.js";
12import { normalizePlayerSkills } from "../../shared/skills/state.js";
13import { totalXpForLevel } from "../../shared/skills/progression.js";
14import
15{
16 canEquipItem,
17 effectiveSkillLevel,
18 equipmentBonusesFromSlots
19} from "../../shared/equipment/stats.js";
20import { emptyEquipment } from "../../shared/items/inventory.js";
21import
22{
23 assertAllBonusGearCategorized,
24 defaultEquipmentStatBonuses,
25 normalizeEquipmentStatBonuses,
26 bonusForEquippedItem,
27 diffEquipmentStatBonuses
28} from "../../shared/definitions/equipmentStatCategories.js";
29import { resolveItemDualTint } from "../../shared/render/tint.js";
30
31test("tier stat bonuses scale by material", () =>
32{
33 assert.equal(tierStatBonus(MaterialTier.bronze), 1);
34 assert.equal(tierStatBonus(MaterialTier.iron), 2);
35 assert.ok(tierStatBonus(MaterialTier.orichalcum) > tierStatBonus(MaterialTier.mithril));
36});
37
38test("every bonus-gear item is categorized exactly once", () =>
39{
40 const result = assertAllBonusGearCategorized();
41 assert.equal(result.ok, true, JSON.stringify(result));
42});
43
44test("equipped weapons and armour add effective combat stats", () =>
45{
46 const skills = normalizePlayerSkills(null);
47 const slots = {
48 ...emptyEquipment().slots,
49 weapon: { itemId: ItemId.stick, quantity: 1 },
50 chest: { itemId: ItemId.clothShirt, quantity: 1 }
51 };
52 const bonuses = equipmentBonusesFromSlots(slots);
53 assert.equal(bonuses[SkillId.strength], tierStatBonus(WoodTier.pine));
54 assert.equal(bonuses[SkillId.defence], 0);
55 assert.equal(
56 effectiveSkillLevel(skills, SkillId.strength, bonuses),
57 1 + tierStatBonus(WoodTier.pine)
58 );
59});
60
61test("metal skirt matches greaves defence bonus", () =>
62{
63 const defaults = defaultEquipmentStatBonuses();
64 assert.equal(
65 defaults.metalArmour.skirt.iron.defence,
66 defaults.metalArmour.greaves.iron.defence
67 );
68 const slots = {
69 ...emptyEquipment().slots,
70 legs: { itemId: ArmourItemId.ironSkirt, quantity: 1 }
71 };
72 const bonuses = equipmentBonusesFromSlots(slots);
73 assert.equal(bonuses[SkillId.defence], tierStatBonus(MaterialTier.iron));
74 assert.equal(itemDefinition(ArmourItemId.ironSkirt)?.equipment?.slot, "legs");
75 assert.equal(itemDefinition(ArmourItemId.ironSkirt)?.equipment?.equipSprite, "item:armour:skirt:equip");
76});
77
78test("metal shield uses leather dual-tint on equip and magenta icon", () =>
79{
80 const def = itemDefinition(ArmourItemId.ironShield);
81 assert.equal(def?.equipment?.slot, "offhand");
82 assert.equal(def?.equipment?.kind, EquipmentKind.shield);
83 assert.equal(def?.equipment?.equipSprite, "item:armour:shield:equip");
84 assert.equal(def?.iconTintFromTier, true);
85 assert.equal(def?.dualTintFromTier, true);
86 assert.equal(def?.leatherTier, "hardLeather");
87 const dual = resolveItemDualTint({ itemId: ArmourItemId.ironShield }, def);
88 assert.ok(dual?.shaft);
89 assert.ok(dual?.tip);
90 assert.equal(
91 defaultEquipmentStatBonuses().metalArmour.shield.iron.defence,
92 tierStatBonus(MaterialTier.iron)
93 );
94 const slots = {
95 ...emptyEquipment().slots,
96 offhand: { itemId: ArmourItemId.ironShield, quantity: 1 }
97 };
98 assert.equal(equipmentBonusesFromSlots(slots)[SkillId.defence], tierStatBonus(MaterialTier.iron));
99});
100
101test("leather shoes grant independent agility and defence from settings", () =>
102{
103 const settings = normalizeEquipmentStatBonuses({
104 leatherArmour: {
105 shoes: {
106 softLeather: { agility: 3, defence: 1 }
107 }
108 }
109 });
110 const slots = {
111 ...emptyEquipment().slots,
112 boots: { itemId: LeatherItemId.leatherShoes, quantity: 1 }
113 };
114 const bonuses = equipmentBonusesFromSlots(slots, { equipmentStatBonuses: settings });
115 assert.equal(bonuses[SkillId.agility], 3);
116 assert.equal(bonuses[SkillId.defence], 1);
117});
118
119test("leather armour defaults to full agility and half metal defence", () =>
120{
121 const defaults = defaultEquipmentStatBonuses().leatherArmour.shoes;
122 assert.equal(defaults.softLeather.agility, tierStatBonus(LeatherTier.softLeather));
123 assert.equal(defaults.softLeather.defence, Math.floor(tierStatBonus(LeatherTier.softLeather) / 2));
124 assert.equal(defaults.studdedLeather.agility, tierStatBonus(LeatherTier.studdedLeather));
125 assert.equal(defaults.studdedLeather.defence, Math.floor(tierStatBonus(MaterialTier.steel) / 2));
126 assert.equal(defaults.dragonhide.agility, tierStatBonus(LeatherTier.dragonhide));
127 assert.equal(defaults.dragonhide.defence, Math.floor(tierStatBonus(MaterialTier.dragon) / 2));
128});
129
130test("bronze gear equips at level 1", () =>
131{
132 const skills = normalizePlayerSkills(null);
133 assert.equal(canEquipItem(skills, itemDefinition(ItemId.stick)).ok, true);
134 assert.equal(canEquipItem(skills, itemDefinition(ItemId.clothShirt)).ok, true);
135});
136
137test("higher tiers require the relevant skill level", () =>
138{
139 const ironSword = {
140 equipment: {
141 slot: "weapon",
142 tier: MaterialTier.iron,
143 kind: EquipmentKind.metalWeapon,
144 attack: { hitSkillId: SkillId.swordfighting }
145 }
146 };
147 const skills = normalizePlayerSkills(null);
148 assert.equal(canEquipItem(skills, ironSword).ok, false);
149 skills.xp[SkillId.swordfighting] = 999999;
150 assert.equal(canEquipItem(skills, ironSword).ok, true);
151});
152
153test("full helm grants +1 defence bonus and +1 equip level", () =>
154{
155 const helmet = itemDefinition(ArmourItemId.bronzeHelmet);
156 const fullHelm = itemDefinition(ArmourItemId.bronzeFullHelm);
157 const horned = itemDefinition(ArmourItemId.bronzeHornedHelm);
158 const skills = normalizePlayerSkills(null);
159
160 assert.equal(fullHelm.equipment.bonus, undefined);
161 assert.equal(fullHelm.equipment.minSkillLevel, tierMinSkillLevel(MaterialTier.bronze) + 1);
162
163 assert.equal(canEquipItem(skills, helmet).ok, true);
164 assert.equal(canEquipItem(skills, fullHelm).ok, false);
165 skills.xp[SkillId.defence] = totalXpForLevel(tierMinSkillLevel(MaterialTier.bronze) + 1);
166 assert.equal(canEquipItem(skills, fullHelm).ok, true);
167
168 const slots = {
169 ...emptyEquipment().slots,
170 head: { itemId: ArmourItemId.bronzeFullHelm, quantity: 1 }
171 };
172 assert.equal(
173 equipmentBonusesFromSlots(slots)[SkillId.defence],
174 tierStatBonus(MaterialTier.bronze) + 1
175 );
176 const hornedSlots = {
177 ...emptyEquipment().slots,
178 head: { itemId: ArmourItemId.bronzeHornedHelm, quantity: 1 }
179 };
180 assert.equal(
181 equipmentBonusesFromSlots(hornedSlots)[SkillId.defence],
182 tierStatBonus(MaterialTier.bronze)
183 );
184});
185
186test("normalizeEquipmentStatBonuses fills defaults and clamps", () =>
187{
188 const defaults = defaultEquipmentStatBonuses();
189 const normalized = normalizeEquipmentStatBonuses({
190 metalArmour: {
191 chestplate: {
192 bronze: { defence: -3, magic: -150 },
193 iron: { defence: 999 }
194 }
195 },
196 unknownCategory: { x: 1 }
197 });
198 assert.equal(normalized.metalArmour.chestplate.bronze.defence, -3);
199 assert.equal(normalized.metalArmour.chestplate.bronze.magic, -99);
200 assert.equal(normalized.metalArmour.chestplate.iron.defence, 99);
201 assert.equal(normalized.metalArmour.greaves.bronze.defence, defaults.metalArmour.greaves.bronze.defence);
202 assert.equal(normalized.unknownCategory, undefined);
203});
204
205test("diffEquipmentStatBonuses reports skill changes", () =>
206{
207 const prev = defaultEquipmentStatBonuses();
208 const next = normalizeEquipmentStatBonuses({
209 ...prev,
210 metalArmour: {
211 ...prev.metalArmour,
212 chestplate: {
213 ...prev.metalArmour.chestplate,
214 bronze: { defence: 9 }
215 }
216 }
217 });
218 const bullets = diffEquipmentStatBonuses(prev, next, (id) => itemDefinition(id)?.displayName ?? null);
219 assert.ok(bullets.some((line) => line.includes("defence") && line.includes("9")));
220});
221
222test("bonusForEquippedItem returns null for tools", () =>
223{
224 assert.equal(bonusForEquippedItem(itemDefinition(CraftingItemId.bronzePickaxe)), null);
225});
226
227test("leather armour uses leather-cloth dual tint", () =>
228{
229 const def = itemDefinition(LeatherArmourItemId.softLeatherChestguard);
230 assert.equal(def?.equipment?.kind, EquipmentKind.leatherArmour);
231 assert.equal(def?.dualTintLeatherCloth, true);
232 assert.equal(def?.leatherTier, LeatherTier.softLeather);
233 assert.equal(def?.clothTier, "cotton");
234 const dual = resolveItemDualTint({ itemId: LeatherArmourItemId.softLeatherChestguard }, def);
235 assert.ok(dual?.shaft);
236 assert.ok(dual?.tip);
237});
238
239test("wizard robe top grants magic bonus for cloth tier", () =>
240{
241 const defaults = defaultEquipmentStatBonuses().wizardArmour.robetop;
242 assert.equal(defaults.cotton.magic, tierStatBonus(ClothTier.cotton));
243 assert.equal(defaults.cotton.defence, undefined);
244 const slots = {
245 ...emptyEquipment().slots,
246 chest: { itemId: WizardItemId.cottonRobeTop, quantity: 1 }
247 };
248 const bonuses = equipmentBonusesFromSlots(slots);
249 assert.equal(bonuses[SkillId.magic], tierStatBonus(ClothTier.cotton));
250 assert.equal(bonuses[SkillId.defence], 0);
251});
252
253test("leather chestguard grants full agility and half defence", () =>
254{
255 const defaults = defaultEquipmentStatBonuses().leatherArmour.chestguard;
256 assert.equal(defaults.softLeather.agility, tierStatBonus(LeatherTier.softLeather));
257 assert.equal(defaults.softLeather.defence, Math.floor(tierStatBonus(LeatherTier.softLeather) / 2));
258 const slots = {
259 ...emptyEquipment().slots,
260 chest: { itemId: LeatherArmourItemId.softLeatherChestguard, quantity: 1 }
261 };
262 const bonuses = equipmentBonusesFromSlots(slots);
263 assert.equal(bonuses[SkillId.agility], tierStatBonus(LeatherTier.softLeather));
264 assert.equal(bonuses[SkillId.defence], Math.floor(tierStatBonus(LeatherTier.softLeather) / 2));
265});
266
267test("metal armour grants quarter-tier strength and agility rounded up", () =>
268{
269 const defaults = defaultEquipmentStatBonuses().metalArmour.chestplate;
270 assert.equal(defaults.bronze.strength, 1);
271 assert.equal(defaults.bronze.agility, 1);
272 assert.equal(defaults.iron.strength, 1);
273 assert.equal(defaults.steel.strength, 1);
274 assert.equal(defaults.mithril.strength, 2);
275 assert.equal(defaults.dragon.strength, 3);
276 const slots = {
277 ...emptyEquipment().slots,
278 chest: { itemId: ArmourItemId.steelChestplate, quantity: 1 }
279 };
280 const bonuses = equipmentBonusesFromSlots(slots);
281 assert.equal(bonuses[SkillId.strength], 1);
282 assert.equal(bonuses[SkillId.agility], 1);
283});
284
285test("metal armour penalizes magic and archery by material rank", () =>
286{
287 const defaults = defaultEquipmentStatBonuses().metalArmour.chestplate;
288 assert.equal(defaults.bronze.defence, tierStatBonus(MaterialTier.bronze));
289 assert.equal(defaults.bronze.magic, -1);
290 assert.equal(defaults.bronze.archery, -1);
291 assert.equal(defaults.dragon.defence, tierStatBonus(MaterialTier.dragon));
292 assert.equal(defaults.dragon.magic, -7);
293 assert.equal(defaults.dragon.archery, -7);
294 const slots = {
295 ...emptyEquipment().slots,
296 chest: { itemId: ArmourItemId.ironChestplate, quantity: 1 }
297 };
298 const bonuses = equipmentBonusesFromSlots(slots);
299 assert.equal(bonuses[SkillId.magic], -2);
300 assert.equal(bonuses[SkillId.archery], -2);
301 assert.equal(bonuses[SkillId.defence], tierStatBonus(MaterialTier.iron));
302});
303
304test("full helm keeps +1 defence only, not magic or archery penalty", () =>
305{
306 const defaults = defaultEquipmentStatBonuses().metalArmour.fullHelm;
307 assert.equal(defaults.bronze.defence, tierStatBonus(MaterialTier.bronze) + 1);
308 assert.equal(defaults.bronze.magic, -1);
309 assert.equal(defaults.bronze.archery, -1);
310});
311
312test("bows bonus archery and arrows bonus dexterity", () =>
313{
314 const defaults = defaultEquipmentStatBonuses().rangedWeapons;
315 assert.ok(Object.hasOwn(defaults.bow.pine, SkillId.archery));
316 assert.equal(Object.hasOwn(defaults.bow.pine, SkillId.dexterity), false);
317 assert.ok(Object.hasOwn(defaults.arrow.bronze, SkillId.dexterity));
318 assert.equal(Object.hasOwn(defaults.arrow.bronze, SkillId.archery), false);
319 assert.equal(defaults.bow.pine.archery, tierStatBonus(WoodTier.pine));
320 assert.equal(defaults.arrow.bronze.dexterity, tierStatBonus(MaterialTier.bronze));
321});
322
323test("melee weapon sections use Clubs, Swords, and Axes skills", () =>
324{
325 const defaults = defaultEquipmentStatBonuses().meleeWeapons;
326 assert.ok(Object.hasOwn(defaults.club.pine, SkillId.clubfighting));
327 assert.equal(Object.hasOwn(defaults.club.pine, SkillId.swordfighting), false);
328 assert.ok(Object.hasOwn(defaults.sword.bronze, SkillId.swordfighting));
329 assert.ok(Object.hasOwn(defaults.warAxe.bronze, SkillId.axefighting));
330 assert.equal(Object.hasOwn(defaults.warAxe.bronze, SkillId.swordfighting), false);
331 assert.equal(Object.hasOwn(defaults.warAxe.bronze, SkillId.clubfighting), false);
332});
333
334test("legacy bow dexterity settings migrate to archery", () =>
335{
336 const migrated = normalizeEquipmentStatBonuses({
337 rangedWeapons: {
338 bow: { pine: { dexterity: 4 } }
339 }
340 });
341 assert.equal(migrated.rangedWeapons.bow.pine.archery, 4);
342 assert.equal(Object.hasOwn(migrated.rangedWeapons.bow.pine, SkillId.dexterity), false);
343});
344
345test("wizard robe bottoms use single cloth tint", () =>
346{
347 const def = itemDefinition(WizardItemId.cottonRobeBottoms);
348 assert.equal(def?.tintFromTier, true);
349 assert.equal(def?.dualTintFromTier, undefined);
350 assert.equal(resolveItemDualTint({ itemId: WizardItemId.cottonRobeBottoms }, def), null);
351});