BlueGit

timfa questward

Files

questward / server / tests / combatRolls.test.js

combatRolls.test.js

combatRolls.test.js 4.4 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { resolvePhysicalAttack, rollSkill, combatDamageRollLevel, rollCombatDamage, spellDamageRollLevel, rollSpellDamage } from "../../shared/combat/rolls.js";
4
5test("rollSkill returns values within 0..skillLevel", () =>
6{
7 const seen = new Set();
8 for (let i = 0; i < 400; i++)
9 { seen.add(rollSkill(5, () => Math.random())); }
10 for (const value of seen)
11 {
12 assert.ok(value >= 0 && value <= 5);
13 }
14 assert.ok(seen.has(0));
15 assert.ok(seen.has(5));
16});
17
18test("deterministic rng produces stable rolls", () =>
19{
20 let i = 0;
21 const seq = [0, 0.99, 0.5];
22 const rng = () => seq[i++ % seq.length];
23 assert.equal(rollSkill(4, rng), 0);
24 assert.equal(rollSkill(4, rng), 4);
25 assert.equal(rollSkill(4, rng), 2);
26});
27
28test("physical attack miss when agility roll beats hit roll", () =>
29{
30 let i = 0;
31 const rng = () => [0.25, 0.45, 0][i++];
32 const result = resolvePhysicalAttack({
33 hitSkillLevel: 5,
34 agilitySkillLevel: 10,
35 damageSkillLevel: 10,
36 defenceSkillLevel: 1,
37 rng
38 });
39 assert.equal(result.outcome, "miss");
40 assert.equal(result.toHitRoll, 1);
41 assert.equal(result.agilityRoll, 4);
42 assert.equal(result.damageRoll, 0);
43 assert.equal(result.damage, 0);
44});
45
46test("equal hit and agility rolls count as a hit", () =>
47{
48 let i = 0;
49 const rng = () => [0.4, 0.4, 0, 0][i++];
50 const result = resolvePhysicalAttack({
51 hitSkillLevel: 5,
52 agilitySkillLevel: 5,
53 damageSkillLevel: 5,
54 defenceSkillLevel: 1,
55 rng
56 });
57 assert.equal(result.toHitRoll, result.agilityRoll);
58 assert.equal(result.outcome, "hit");
59});
60
61test("physical attack block prevents damage after winning the hit contest", () =>
62{
63 let i = 0;
64 const rolls = [0.4, 0, 0, 0.95];
65 const rng = () => rolls[i++];
66 const result = resolvePhysicalAttack({
67 hitSkillLevel: 10,
68 agilitySkillLevel: 3,
69 damageSkillLevel: 8,
70 defenceSkillLevel: 10,
71 rng
72 });
73 assert.equal(result.outcome, "block");
74 assert.equal(result.damage, 0);
75 assert.ok(result.defenceRoll > result.toHitRoll);
76});
77
78test("physical attack hit applies rolled damage when not blocked", () =>
79{
80 let i = 0;
81 const rolls = [0.9, 0, 0.5, 0];
82 const rng = () => rolls[i++];
83 const result = resolvePhysicalAttack({
84 hitSkillLevel: 10,
85 agilitySkillLevel: 1,
86 damageSkillLevel: 5,
87 defenceSkillLevel: 1,
88 rng
89 });
90 assert.equal(result.outcome, "hit");
91 assert.equal(result.damage, 1);
92});
93
94test("combat damage roll level is quarter effective level rounded up", () =>
95{
96 assert.equal(combatDamageRollLevel(1), 1);
97 assert.equal(combatDamageRollLevel(4), 1);
98 assert.equal(combatDamageRollLevel(5), 2);
99 assert.equal(combatDamageRollLevel(99), 25);
100 assert.equal(rollCombatDamage(5, () => 0.999999), 2);
101});
102
103test("spell damage roll cap adds spell tier minus one to mind cap", () =>
104{
105 assert.equal(spellDamageRollLevel(20, 1), 5);
106 assert.equal(spellDamageRollLevel(20, 2), 6);
107 assert.equal(spellDamageRollLevel(20, 5), 9);
108 assert.equal(rollSpellDamage(20, 5, () => 0.999999), 9);
109});
110
111test("physical attack applies weakness and resistance multipliers", () =>
112{
113 let i = 0;
114 const rolls = [0.9, 0, 0.5, 0];
115 const rng = () => rolls[i++];
116 const weak = resolvePhysicalAttack({
117 hitSkillLevel: 10,
118 agilitySkillLevel: 1,
119 damageSkillLevel: 5,
120 defenceSkillLevel: 1,
121 attackType: "slashing",
122 targetAffinities: { slashing: "weak" },
123 rng
124 });
125 assert.equal(weak.outcome, "hit");
126 assert.equal(weak.damage, 2);
127 assert.equal(weak.multiplier, 2);
128
129 i = 0;
130 const resist = resolvePhysicalAttack({
131 hitSkillLevel: 10,
132 agilitySkillLevel: 1,
133 damageSkillLevel: 5,
134 defenceSkillLevel: 1,
135 attackType: "blunt",
136 targetAffinities: { blunt: "resistant" },
137 rng
138 });
139 assert.equal(resist.outcome, "hit");
140 assert.equal(resist.damage, 0);
141 assert.equal(resist.multiplier, 0.5);
142});
143
144test("physical damage is the damage skill roll only", () =>
145{
146 let i = 0;
147 const rolls = [0.5, 0, 0.4, 0];
148 const rng = () => rolls[i++];
149 const result = resolvePhysicalAttack({
150 hitSkillLevel: 10,
151 agilitySkillLevel: 1,
152 damageSkillLevel: 5,
153 defenceSkillLevel: 1,
154 rng
155 });
156 assert.equal(result.outcome, "hit");
157 assert.equal(result.damageRoll, 1);
158 assert.equal(result.damage, 1);
159});
160
161test("skill level 1 contest can still land a hit on equal agility", () =>
162{
163 const result = resolvePhysicalAttack({
164 hitSkillLevel: 1,
165 agilitySkillLevel: 1,
166 damageSkillLevel: 1,
167 defenceSkillLevel: 1,
168 rng: () => 0
169 });
170 assert.equal(result.outcome, "hit");
171 assert.equal(result.toHitRoll, 0);
172 assert.equal(result.agilityRoll, 0);
173});