@reldens/skills 0.46.0 → 0.48.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/.claude/architecture.md +472 -0
  2. package/.claude/class-hierarchy.md +982 -0
  3. package/.claude/event-system-architecture.md +475 -0
  4. package/.claude/level-progression.md +1259 -0
  5. package/.claude/skill-execution-flow.md +979 -0
  6. package/.claude/testing-guide.md +356 -0
  7. package/.claude/testing-patterns.md +1096 -0
  8. package/CLAUDE.md +164 -29
  9. package/lib/class-path.js +13 -10
  10. package/lib/client/receiver.js +1 -3
  11. package/lib/levels-set.js +24 -17
  12. package/lib/server/sender.js +1 -1
  13. package/lib/skill.js +19 -16
  14. package/lib/types/attack.js +28 -11
  15. package/lib/types/effect.js +10 -4
  16. package/lib/types/physical-attack.js +2 -2
  17. package/lib/types/physical-effect.js +2 -2
  18. package/lib/types/physical-properties-validator.js +1 -1
  19. package/lib/types/physical-skill-runner.js +5 -5
  20. package/package.json +9 -3
  21. package/tests/fixtures/levels/base-levels.js +89 -0
  22. package/tests/fixtures/mocks/mock-client.js +44 -0
  23. package/tests/fixtures/mocks/mock-owner.js +60 -0
  24. package/tests/fixtures/mocks/mock-target.js +50 -0
  25. package/tests/fixtures/skills/base-skills.js +80 -0
  26. package/tests/run-tests.js +88 -0
  27. package/tests/unit/client/test-receiver.js +249 -0
  28. package/tests/unit/server/test-sender.js +527 -0
  29. package/tests/unit/test-class-path.js +1239 -0
  30. package/tests/unit/test-level.js +176 -0
  31. package/tests/unit/test-levels-set.js +1227 -0
  32. package/tests/unit/test-server.js +266 -0
  33. package/tests/unit/test-skill.js +1302 -0
  34. package/tests/unit/types/test-attack.js +1195 -0
  35. package/tests/unit/types/test-effect.js +587 -0
  36. package/tests/unit/types/test-physical-attack.js +564 -0
  37. package/tests/unit/types/test-physical-effect.js +769 -0
  38. package/tests/unit/types/test-physical-properties-validator.js +203 -0
  39. package/tests/unit/types/test-physical-skill-runner.js +348 -0
  40. package/tests/utils/test-helpers.js +122 -0
@@ -0,0 +1,1195 @@
1
+ /**
2
+ *
3
+ * Reldens - Attack Unit Tests
4
+ *
5
+ */
6
+
7
+ const { describe, it, beforeEach, afterEach } = require('node:test');
8
+ const assert = require('node:assert');
9
+ const Attack = require('../../../lib/types/attack');
10
+ const SkillsConst = require('../../../lib/constants');
11
+ const SkillsEvents = require('../../../lib/skills-events');
12
+ const { TestHelpers } = require('../../utils/test-helpers');
13
+ const { MockOwner } = require('../../fixtures/mocks/mock-owner');
14
+ const { MockTarget } = require('../../fixtures/mocks/mock-target');
15
+ const { BaseSkillsFixtures } = require('../../fixtures/skills/base-skills');
16
+ const { ModifierConst } = require('@reldens/modifiers');
17
+
18
+ describe('Attack', () => {
19
+ let mockOwner;
20
+ let mockTarget;
21
+
22
+ beforeEach(() => {
23
+ mockOwner = new MockOwner();
24
+ mockTarget = new MockTarget();
25
+ TestHelpers.clearEventListeners();
26
+ });
27
+
28
+ afterEach(() => {
29
+ TestHelpers.clearEventListeners();
30
+ });
31
+
32
+ describe('Constructor', () => {
33
+ it('should initialize with attack type', () => {
34
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
35
+ let attack = new Attack(attackData);
36
+ assert.strictEqual(attack.type, SkillsConst.SKILL.TYPE.ATTACK);
37
+ });
38
+
39
+ it('should set isReady to false when affectedProperty is missing', () => {
40
+ let attackData = {key: 'test-attack', owner: mockOwner};
41
+ let attack = new Attack(attackData);
42
+ assert.strictEqual(attack.isReady, false);
43
+ });
44
+
45
+ it('should initialize with damage properties', () => {
46
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
47
+ let attack = new Attack(attackData);
48
+ assert.strictEqual(attack.hitDamage, 10);
49
+ assert.strictEqual(attack.affectedProperty, 'stats/hp');
50
+ assert.ok(Array.isArray(attack.attackProperties));
51
+ assert.ok(Array.isArray(attack.defenseProperties));
52
+ });
53
+
54
+ it('should initialize with aim and dodge properties', () => {
55
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
56
+ let attack = new Attack(attackData);
57
+ assert.ok(Array.isArray(attack.aimProperties));
58
+ assert.ok(Array.isArray(attack.dodgeProperties));
59
+ assert.strictEqual(attack.dodgeFullEnabled, true);
60
+ });
61
+
62
+ it('should initialize with default values', () => {
63
+ let attackData = {
64
+ key: 'test',
65
+ owner: mockOwner,
66
+ affectedProperty: 'stats/hp'
67
+ };
68
+ let attack = new Attack(attackData);
69
+ assert.strictEqual(attack.hitDamage, 0);
70
+ assert.strictEqual(attack.applyDirectDamage, false);
71
+ assert.strictEqual(attack.allowEffectBelowZero, false);
72
+ });
73
+ });
74
+
75
+ describe('applyDamageTo', () => {
76
+ it('should return false when target is undefined', async () => {
77
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
78
+ let attack = new Attack(attackData);
79
+ let result = await attack.applyDamageTo(null);
80
+ assert.strictEqual(result, false);
81
+ });
82
+
83
+ it('should apply direct damage when applyDirectDamage is true', async () => {
84
+ let attackData = {
85
+ ...BaseSkillsFixtures.attackSkill,
86
+ owner: mockOwner,
87
+ applyDirectDamage: true,
88
+ hitDamage: 20,
89
+ range: 0,
90
+ criticalChance: 0,
91
+ criticalMultiplier: 1
92
+ };
93
+ let attack = new Attack(attackData);
94
+ let initialHp = mockTarget.stats.hp;
95
+ await attack.applyDamageTo(mockTarget);
96
+ assert.strictEqual(mockTarget.stats.hp, initialHp - 20);
97
+ });
98
+
99
+ it('should return false when target dodge is higher than owner aim', async () => {
100
+ let highDodgeTarget = new MockTarget();
101
+ highDodgeTarget.stats.dodge = 100;
102
+ let attackData = {
103
+ ...BaseSkillsFixtures.attackSkill,
104
+ owner: mockOwner,
105
+ range: 0,
106
+ dodgeFullEnabled: true,
107
+ dodgeOverAimSuccess: 1
108
+ };
109
+ let attack = new Attack(attackData);
110
+ let result = await attack.applyDamageTo(highDodgeTarget);
111
+ assert.strictEqual(result, false);
112
+ assert.strictEqual(attack.lastState, SkillsConst.SKILL_STATES.DODGED);
113
+ });
114
+
115
+ it('should calculate damage with attack and defense properties', async () => {
116
+ let attackData = {
117
+ ...BaseSkillsFixtures.attackSkill,
118
+ owner: mockOwner,
119
+ hitDamage: 10,
120
+ range: 0,
121
+ attackProperties: ['stats/atk'],
122
+ defenseProperties: ['stats/def'],
123
+ aimProperties: ['stats/aim'],
124
+ dodgeProperties: ['stats/dodge']
125
+ };
126
+ let attack = new Attack(attackData);
127
+ let initialHp = mockTarget.stats.hp;
128
+ await attack.applyDamageTo(mockTarget);
129
+ assert.ok(mockTarget.stats.hp < initialHp);
130
+ assert.strictEqual(attack.lastState, SkillsConst.SKILL_STATES.APPLIED_DAMAGE);
131
+ });
132
+
133
+ it('should not reduce hp below 0 when allowEffectBelowZero is false', async () => {
134
+ let attackData = {
135
+ ...BaseSkillsFixtures.attackSkill,
136
+ owner: mockOwner,
137
+ hitDamage: 1000,
138
+ range: 0,
139
+ applyDirectDamage: true,
140
+ allowEffectBelowZero: false
141
+ };
142
+ let attack = new Attack(attackData);
143
+ await attack.applyDamageTo(mockTarget);
144
+ assert.strictEqual(mockTarget.stats.hp, 0);
145
+ });
146
+
147
+ it('should fire SKILL_ATTACK_APPLY_DAMAGE event', async () => {
148
+ let eventFired = false;
149
+ let attackData = {
150
+ ...BaseSkillsFixtures.attackSkill,
151
+ owner: mockOwner,
152
+ range: 0
153
+ };
154
+ let attack = new Attack(attackData);
155
+ attack.listenEvent(SkillsEvents.SKILL_ATTACK_APPLY_DAMAGE, () => {
156
+ eventFired = true;
157
+ }, 'test-listener');
158
+ await attack.applyDamageTo(mockTarget);
159
+ assert.strictEqual(eventFired, true);
160
+ });
161
+ });
162
+
163
+ describe('getPropertiesTotal', () => {
164
+ it('should return 0 for empty properties array', () => {
165
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
166
+ let attack = new Attack(attackData);
167
+ let total = attack.getPropertiesTotal(mockOwner, []);
168
+ assert.strictEqual(total, 0);
169
+ });
170
+
171
+ it('should sum property values correctly', () => {
172
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
173
+ let attack = new Attack(attackData);
174
+ let total = attack.getPropertiesTotal(mockOwner, ['stats/atk']);
175
+ assert.strictEqual(total, 10);
176
+ });
177
+
178
+ it('should sum multiple properties', () => {
179
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
180
+ let attack = new Attack(attackData);
181
+ let total = attack.getPropertiesTotal(mockOwner, ['stats/atk', 'stats/def']);
182
+ assert.strictEqual(total, 15);
183
+ });
184
+
185
+ it('should return false for invalid object', () => {
186
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
187
+ let attack = new Attack(attackData);
188
+ let total = attack.getPropertiesTotal(null, ['stats/atk']);
189
+ assert.strictEqual(total, false);
190
+ });
191
+ });
192
+
193
+ describe('getAffectedPropertyValue', () => {
194
+ it('should get target property value', () => {
195
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
196
+ let attack = new Attack(attackData);
197
+ let value = attack.getAffectedPropertyValue(mockTarget);
198
+ assert.strictEqual(value, mockTarget.stats.hp);
199
+ });
200
+ });
201
+
202
+ describe('setAffectedPropertyValue', () => {
203
+ it('should set target property value', () => {
204
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
205
+ let attack = new Attack(attackData);
206
+ attack.setAffectedPropertyValue(mockTarget, 50);
207
+ assert.strictEqual(mockTarget.stats.hp, 50);
208
+ });
209
+ });
210
+
211
+ describe('calculateCriticalDamage', () => {
212
+ it('should return critical value when not affected by dodge/aim', () => {
213
+ let attackData = {
214
+ ...BaseSkillsFixtures.attackSkill,
215
+ owner: mockOwner,
216
+ criticalAffected: false
217
+ };
218
+ let attack = new Attack(attackData);
219
+ attack.isCritical = () => true;
220
+ attack.criticalMultiplier = 2;
221
+ let critDmg = attack.calculateCriticalDamage(100, 10, 15, 0);
222
+ assert.strictEqual(critDmg, 100);
223
+ });
224
+
225
+ it('should return full critical when dodge is higher than aim', () => {
226
+ let attackData = {
227
+ ...BaseSkillsFixtures.attackSkill,
228
+ owner: mockOwner,
229
+ criticalAffected: false
230
+ };
231
+ let attack = new Attack(attackData);
232
+ attack.isCritical = () => true;
233
+ attack.criticalMultiplier = 2;
234
+ let critDmg = attack.calculateCriticalDamage(100, 20, 10, 100);
235
+ assert.strictEqual(critDmg, 100);
236
+ });
237
+ });
238
+
239
+ describe('calculateProportionDamage', () => {
240
+ it('should increase damage when attack is higher than defense', () => {
241
+ mockOwner.stats.atk = 20;
242
+ mockTarget.stats.def = 5;
243
+ let attackData = {
244
+ ...BaseSkillsFixtures.attackSkill,
245
+ owner: mockOwner,
246
+ attackProperties: ['stats/atk'],
247
+ defenseProperties: ['stats/def']
248
+ };
249
+ let attack = new Attack(attackData);
250
+ let damage = attack.calculateProportionDamage(mockTarget, 10, 0, 1, 0);
251
+ assert.ok(damage > 10);
252
+ });
253
+
254
+ it('should decrease damage when defense is higher than attack', () => {
255
+ mockOwner.stats.atk = 5;
256
+ mockTarget.stats.def = 20;
257
+ let attackData = {
258
+ ...BaseSkillsFixtures.attackSkill,
259
+ owner: mockOwner,
260
+ attackProperties: ['stats/atk'],
261
+ defenseProperties: ['stats/def']
262
+ };
263
+ let attack = new Attack(attackData);
264
+ let damage = attack.calculateProportionDamage(mockTarget, 10, 0, 1, 0);
265
+ assert.ok(damage < 10);
266
+ });
267
+
268
+ it('should handle zero attack stats', () => {
269
+ mockOwner.stats.atk = 0;
270
+ mockTarget.stats.def = 10;
271
+ let attackData = {
272
+ ...BaseSkillsFixtures.attackSkill,
273
+ owner: mockOwner,
274
+ attackProperties: ['stats/atk'],
275
+ defenseProperties: ['stats/def']
276
+ };
277
+ let attack = new Attack(attackData);
278
+ let damage = attack.calculateProportionDamage(mockTarget, 10, 0, 1, 0);
279
+ assert.ok(typeof damage === 'number');
280
+ });
281
+
282
+ it('should handle zero defense stats', () => {
283
+ mockOwner.stats.atk = 10;
284
+ mockTarget.stats.def = 0;
285
+ let attackData = {
286
+ ...BaseSkillsFixtures.attackSkill,
287
+ owner: mockOwner,
288
+ attackProperties: ['stats/atk'],
289
+ defenseProperties: ['stats/def']
290
+ };
291
+ let attack = new Attack(attackData);
292
+ let damage = attack.calculateProportionDamage(mockTarget, 10, 0, 1, 0);
293
+ assert.ok(typeof damage === 'number');
294
+ });
295
+
296
+ it('should handle negative attack stats', () => {
297
+ mockOwner.stats.atk = -10;
298
+ mockTarget.stats.def = 5;
299
+ let attackData = {
300
+ ...BaseSkillsFixtures.attackSkill,
301
+ owner: mockOwner,
302
+ attackProperties: ['stats/atk'],
303
+ defenseProperties: ['stats/def']
304
+ };
305
+ let attack = new Attack(attackData);
306
+ let damage = attack.calculateProportionDamage(mockTarget, 10, 0, 1, 0);
307
+ assert.ok(typeof damage === 'number');
308
+ });
309
+ });
310
+
311
+ describe('Error Conditions - Missing Parameters', () => {
312
+ it('should handle null target in applyDamageTo', async () => {
313
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
314
+ let attack = new Attack(attackData);
315
+ let result = await attack.applyDamageTo(null);
316
+ assert.strictEqual(result, false);
317
+ });
318
+
319
+ it('should handle undefined target in applyDamageTo', async () => {
320
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
321
+ let attack = new Attack(attackData);
322
+ let result = await attack.applyDamageTo(undefined);
323
+ assert.strictEqual(result, false);
324
+ });
325
+
326
+ it('should handle target without affectedProperty', async () => {
327
+ let invalidTarget = {getPosition: () => ({x: 0, y: 0})};
328
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner, range: 0};
329
+ let attack = new Attack(attackData);
330
+ let result = await attack.applyDamageTo(invalidTarget);
331
+ assert.strictEqual(typeof result, 'boolean');
332
+ });
333
+ });
334
+
335
+ describe('Edge Cases - Damage Calculations', () => {
336
+ it('should handle zero hitDamage', async () => {
337
+ let attackData = {
338
+ ...BaseSkillsFixtures.attackSkill,
339
+ owner: mockOwner,
340
+ hitDamage: 0,
341
+ range: 0,
342
+ applyDirectDamage: true,
343
+ criticalChance: 0
344
+ };
345
+ let attack = new Attack(attackData);
346
+ let initialHp = mockTarget.stats.hp;
347
+ await attack.applyDamageTo(mockTarget);
348
+ assert.strictEqual(mockTarget.stats.hp, initialHp);
349
+ });
350
+
351
+ it('should handle negative hitDamage', async () => {
352
+ let attackData = {
353
+ ...BaseSkillsFixtures.attackSkill,
354
+ owner: mockOwner,
355
+ hitDamage: -20,
356
+ range: 0,
357
+ applyDirectDamage: true,
358
+ criticalChance: 0
359
+ };
360
+ let attack = new Attack(attackData);
361
+ let initialHp = mockTarget.stats.hp;
362
+ await attack.applyDamageTo(mockTarget);
363
+ assert.ok(mockTarget.stats.hp !== initialHp);
364
+ });
365
+
366
+ it('should handle decimal hitDamage', async () => {
367
+ let attackData = {
368
+ ...BaseSkillsFixtures.attackSkill,
369
+ owner: mockOwner,
370
+ hitDamage: 10.5,
371
+ range: 0,
372
+ applyDirectDamage: true,
373
+ criticalChance: 0
374
+ };
375
+ let attack = new Attack(attackData);
376
+ await attack.applyDamageTo(mockTarget);
377
+ assert.ok(typeof mockTarget.stats.hp === 'number');
378
+ });
379
+
380
+ it('should handle very large damage values', async () => {
381
+ let attackData = {
382
+ ...BaseSkillsFixtures.attackSkill,
383
+ owner: mockOwner,
384
+ hitDamage: 10000,
385
+ range: 0,
386
+ applyDirectDamage: true,
387
+ criticalChance: 0,
388
+ allowEffectBelowZero: false
389
+ };
390
+ let attack = new Attack(attackData);
391
+ await attack.applyDamageTo(mockTarget);
392
+ assert.strictEqual(mockTarget.stats.hp, 0);
393
+ });
394
+
395
+ it('should allow negative hp when allowEffectBelowZero is true', async () => {
396
+ let attackData = {
397
+ ...BaseSkillsFixtures.attackSkill,
398
+ owner: mockOwner,
399
+ hitDamage: 1000,
400
+ range: 0,
401
+ applyDirectDamage: true,
402
+ criticalChance: 0,
403
+ allowEffectBelowZero: true
404
+ };
405
+ let attack = new Attack(attackData);
406
+ await attack.applyDamageTo(mockTarget);
407
+ assert.ok(mockTarget.stats.hp < 0);
408
+ });
409
+ });
410
+
411
+ describe('Edge Cases - Aim and Dodge', () => {
412
+ it('should handle zero aim', async () => {
413
+ mockOwner.stats.aim = 0;
414
+ let attackData = {
415
+ ...BaseSkillsFixtures.attackSkill,
416
+ owner: mockOwner,
417
+ range: 0,
418
+ dodgeFullEnabled: true,
419
+ aimProperties: ['stats/aim'],
420
+ dodgeProperties: ['stats/dodge']
421
+ };
422
+ let attack = new Attack(attackData);
423
+ await attack.applyDamageTo(mockTarget);
424
+ assert.ok(typeof attack.lastState === 'string');
425
+ });
426
+
427
+ it('should handle zero dodge', async () => {
428
+ mockTarget.stats.dodge = 0;
429
+ let attackData = {
430
+ ...BaseSkillsFixtures.attackSkill,
431
+ owner: mockOwner,
432
+ range: 0,
433
+ dodgeFullEnabled: true,
434
+ aimProperties: ['stats/aim'],
435
+ dodgeProperties: ['stats/dodge']
436
+ };
437
+ let attack = new Attack(attackData);
438
+ await attack.applyDamageTo(mockTarget);
439
+ assert.ok(typeof attack.lastState === 'string');
440
+ });
441
+
442
+ it('should handle negative aim', async () => {
443
+ mockOwner.stats.aim = -10;
444
+ let attackData = {
445
+ ...BaseSkillsFixtures.attackSkill,
446
+ owner: mockOwner,
447
+ range: 0,
448
+ aimProperties: ['stats/aim'],
449
+ dodgeProperties: ['stats/dodge']
450
+ };
451
+ let attack = new Attack(attackData);
452
+ await attack.applyDamageTo(mockTarget);
453
+ assert.ok(typeof attack.lastState === 'string');
454
+ });
455
+
456
+ it('should handle negative dodge', async () => {
457
+ mockTarget.stats.dodge = -10;
458
+ let attackData = {
459
+ ...BaseSkillsFixtures.attackSkill,
460
+ owner: mockOwner,
461
+ range: 0,
462
+ aimProperties: ['stats/aim'],
463
+ dodgeProperties: ['stats/dodge']
464
+ };
465
+ let attack = new Attack(attackData);
466
+ await attack.applyDamageTo(mockTarget);
467
+ assert.ok(typeof attack.lastState === 'string');
468
+ });
469
+
470
+ it('should handle empty aim properties', async () => {
471
+ let attackData = {
472
+ ...BaseSkillsFixtures.attackSkill,
473
+ owner: mockOwner,
474
+ range: 0,
475
+ aimProperties: [],
476
+ dodgeProperties: ['stats/dodge']
477
+ };
478
+ let attack = new Attack(attackData);
479
+ await attack.applyDamageTo(mockTarget);
480
+ assert.ok(typeof attack.lastState === 'string');
481
+ });
482
+
483
+ it('should handle empty dodge properties', async () => {
484
+ let attackData = {
485
+ ...BaseSkillsFixtures.attackSkill,
486
+ owner: mockOwner,
487
+ range: 0,
488
+ aimProperties: ['stats/aim'],
489
+ dodgeProperties: []
490
+ };
491
+ let attack = new Attack(attackData);
492
+ await attack.applyDamageTo(mockTarget);
493
+ assert.ok(typeof attack.lastState === 'string');
494
+ });
495
+ });
496
+
497
+ describe('Edge Cases - Properties Total', () => {
498
+ it('should handle empty properties array', () => {
499
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
500
+ let attack = new Attack(attackData);
501
+ let total = attack.getPropertiesTotal(mockOwner, []);
502
+ assert.strictEqual(total, 0);
503
+ });
504
+
505
+ it('should handle null object', () => {
506
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
507
+ let attack = new Attack(attackData);
508
+ let total = attack.getPropertiesTotal(null, ['stats/atk']);
509
+ assert.strictEqual(total, false);
510
+ });
511
+
512
+ it('should handle undefined object', () => {
513
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
514
+ let attack = new Attack(attackData);
515
+ let total = attack.getPropertiesTotal(undefined, ['stats/atk']);
516
+ assert.strictEqual(total, false);
517
+ });
518
+
519
+ it('should handle non-existent properties', () => {
520
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
521
+ let attack = new Attack(attackData);
522
+ let total = attack.getPropertiesTotal(mockOwner, ['stats/nonExistent']);
523
+ assert.strictEqual(total, false);
524
+ });
525
+
526
+ it('should handle null in properties array', () => {
527
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
528
+ let attack = new Attack(attackData);
529
+ let total = attack.getPropertiesTotal(mockOwner, [null]);
530
+ assert.strictEqual(total, false);
531
+ });
532
+ });
533
+
534
+ describe('Edge Cases - dodgeOverAimSuccess', () => {
535
+ it('should handle zero dodgeOverAimSuccess', async () => {
536
+ let attackData = {
537
+ ...BaseSkillsFixtures.attackSkill,
538
+ owner: mockOwner,
539
+ range: 0,
540
+ dodgeFullEnabled: true,
541
+ dodgeOverAimSuccess: 0
542
+ };
543
+ let attack = new Attack(attackData);
544
+ await attack.applyDamageTo(mockTarget);
545
+ assert.ok(typeof attack.lastState === 'string');
546
+ });
547
+
548
+ it('should handle negative dodgeOverAimSuccess', async () => {
549
+ let attackData = {
550
+ ...BaseSkillsFixtures.attackSkill,
551
+ owner: mockOwner,
552
+ range: 0,
553
+ dodgeFullEnabled: true,
554
+ dodgeOverAimSuccess: -1
555
+ };
556
+ let attack = new Attack(attackData);
557
+ await attack.applyDamageTo(mockTarget);
558
+ assert.ok(typeof attack.lastState === 'string');
559
+ });
560
+
561
+ it('should handle very large dodgeOverAimSuccess', async () => {
562
+ let attackData = {
563
+ ...BaseSkillsFixtures.attackSkill,
564
+ owner: mockOwner,
565
+ range: 0,
566
+ dodgeFullEnabled: true,
567
+ dodgeOverAimSuccess: 1000
568
+ };
569
+ let attack = new Attack(attackData);
570
+ await attack.applyDamageTo(mockTarget);
571
+ assert.ok(typeof attack.lastState === 'string');
572
+ });
573
+ });
574
+
575
+ describe('Event System', () => {
576
+ it('should fire SKILL_ATTACK_APPLY_DAMAGE with all parameters', async () => {
577
+ let eventFired = false;
578
+ let receivedArgs = [];
579
+ let attackData = {
580
+ ...BaseSkillsFixtures.attackSkill,
581
+ owner: mockOwner,
582
+ range: 0
583
+ };
584
+ let attack = new Attack(attackData);
585
+ attack.listenEvent(SkillsEvents.SKILL_ATTACK_APPLY_DAMAGE, (...args) => {
586
+ eventFired = true;
587
+ receivedArgs = args;
588
+ }, 'damage-listener');
589
+ await attack.applyDamageTo(mockTarget);
590
+ assert.strictEqual(eventFired, true);
591
+ assert.ok(receivedArgs.length > 0);
592
+ });
593
+
594
+ it('should fire event with masterKey parameter', async () => {
595
+ let eventFired = false;
596
+ let attackData = {
597
+ ...BaseSkillsFixtures.attackSkill,
598
+ owner: mockOwner,
599
+ range: 0
600
+ };
601
+ let attack = new Attack(attackData);
602
+ let masterKey = attack.getOwnerEventKey();
603
+ attack.listenEvent(SkillsEvents.SKILL_ATTACK_APPLY_DAMAGE, () => {
604
+ eventFired = true;
605
+ }, 'sub-key', masterKey);
606
+ await attack.applyDamageTo(mockTarget);
607
+ assert.strictEqual(eventFired, true);
608
+ });
609
+
610
+ it('should fire event without any keys', async () => {
611
+ let eventFired = false;
612
+ let attackData = {
613
+ ...BaseSkillsFixtures.attackSkill,
614
+ owner: mockOwner,
615
+ range: 0
616
+ };
617
+ let attack = new Attack(attackData);
618
+ attack.listenEvent(SkillsEvents.SKILL_ATTACK_APPLY_DAMAGE, () => {
619
+ eventFired = true;
620
+ });
621
+ await attack.applyDamageTo(mockTarget);
622
+ assert.strictEqual(eventFired, true);
623
+ });
624
+ });
625
+
626
+ describe('getDiffProportion - Division by Zero Fix', () => {
627
+ it('should return 0 when both aim and dodge are 0', () => {
628
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
629
+ let attack = new Attack(attackData);
630
+ let result = attack.getDiffProportion(0, 0);
631
+ assert.strictEqual(result, 0);
632
+ });
633
+
634
+ it('should return 100 when aim is 0 but dodge is greater than 0', () => {
635
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
636
+ let attack = new Attack(attackData);
637
+ let result = attack.getDiffProportion(0, 10);
638
+ assert.strictEqual(result, 100);
639
+ });
640
+
641
+ it('should calculate normally when aim is not 0', () => {
642
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
643
+ let attack = new Attack(attackData);
644
+ let result = attack.getDiffProportion(10, 5);
645
+ assert.strictEqual(result, -50);
646
+ });
647
+ });
648
+
649
+ describe('applyDamageTo - Return Value Consistency', () => {
650
+ it('should return true on successful damage application', async () => {
651
+ let attackData = {
652
+ ...BaseSkillsFixtures.attackSkill,
653
+ owner: mockOwner,
654
+ range: 0,
655
+ applyDirectDamage: true,
656
+ criticalChance: 0
657
+ };
658
+ let attack = new Attack(attackData);
659
+ let result = await attack.applyDamageTo(mockTarget);
660
+ assert.strictEqual(result, true);
661
+ });
662
+
663
+ it('should return false when target is null', async () => {
664
+ let attackData = {...BaseSkillsFixtures.attackSkill, owner: mockOwner};
665
+ let attack = new Attack(attackData);
666
+ let result = await attack.applyDamageTo(null);
667
+ assert.strictEqual(result, false);
668
+ });
669
+
670
+ it('should return false when attack is dodged', async () => {
671
+ let highDodgeTarget = new MockTarget();
672
+ highDodgeTarget.stats.dodge = 100;
673
+ mockOwner.stats.aim = 10;
674
+ let attackData = {
675
+ ...BaseSkillsFixtures.attackSkill,
676
+ owner: mockOwner,
677
+ range: 0,
678
+ dodgeFullEnabled: true
679
+ };
680
+ let attack = new Attack(attackData);
681
+ let result = await attack.applyDamageTo(highDodgeTarget);
682
+ assert.strictEqual(result, false);
683
+ });
684
+
685
+ it('should return false when allowEffectBelowZero is false and hp is 0', async () => {
686
+ mockTarget.stats.hp = 0;
687
+ let attackData = {
688
+ ...BaseSkillsFixtures.attackSkill,
689
+ owner: mockOwner,
690
+ range: 0,
691
+ allowEffectBelowZero: false
692
+ };
693
+ let attack = new Attack(attackData);
694
+ let result = await attack.applyDamageTo(mockTarget);
695
+ assert.strictEqual(result, false);
696
+ });
697
+ });
698
+
699
+ describe('propertiesTotalOperators - Custom Operators', () => {
700
+ it('should apply INC operator to property total', () => {
701
+ mockOwner.stats.bonus = 5;
702
+ let attackData = {
703
+ ...BaseSkillsFixtures.attackSkill,
704
+ owner: mockOwner,
705
+ propertiesTotalOperators: {
706
+ 'stats/bonus': ModifierConst.OPS.INC
707
+ }
708
+ };
709
+ let attack = new Attack(attackData);
710
+ let total = attack.getPropertiesTotal(mockOwner, ['stats/atk', 'stats/bonus']);
711
+ assert.strictEqual(total, 15);
712
+ });
713
+
714
+ it('should apply DEC operator to property total', () => {
715
+ mockOwner.stats.penalty = 3;
716
+ let attackData = {
717
+ ...BaseSkillsFixtures.attackSkill,
718
+ owner: mockOwner,
719
+ propertiesTotalOperators: {
720
+ 'stats/penalty': ModifierConst.OPS.DEC
721
+ }
722
+ };
723
+ let attack = new Attack(attackData);
724
+ let total = attack.getPropertiesTotal(mockOwner, ['stats/atk', 'stats/penalty']);
725
+ assert.strictEqual(total, 7);
726
+ });
727
+
728
+ it('should apply MULT operator to property total', () => {
729
+ mockOwner.stats.multiplier = 2;
730
+ let attackData = {
731
+ ...BaseSkillsFixtures.attackSkill,
732
+ owner: mockOwner,
733
+ propertiesTotalOperators: {
734
+ 'stats/multiplier': ModifierConst.OPS.MUL
735
+ }
736
+ };
737
+ let attack = new Attack(attackData);
738
+ let total = attack.getPropertiesTotal(mockOwner, ['stats/atk', 'stats/multiplier']);
739
+ assert.strictEqual(total, 20);
740
+ });
741
+
742
+ it('should handle multiple custom operators in same calculation', () => {
743
+ mockOwner.stats.bonus = 5;
744
+ mockOwner.stats.multiplier = 2;
745
+ let attackData = {
746
+ ...BaseSkillsFixtures.attackSkill,
747
+ owner: mockOwner,
748
+ propertiesTotalOperators: {
749
+ 'stats/bonus': ModifierConst.OPS.INC,
750
+ 'stats/multiplier': ModifierConst.OPS.MUL
751
+ }
752
+ };
753
+ let attack = new Attack(attackData);
754
+ let total = attack.getPropertiesTotal(mockOwner, ['stats/atk', 'stats/bonus', 'stats/multiplier']);
755
+ assert.strictEqual(total, 30);
756
+ });
757
+ });
758
+
759
+ describe('damageAffected - Damage Reduction Logic', () => {
760
+ it('should reduce damage when damageAffected is true and dodge > aim', async () => {
761
+ mockOwner.stats.aim = 10;
762
+ mockTarget.stats.dodge = 20;
763
+ mockOwner.stats.atk = 0;
764
+ mockTarget.stats.def = 0;
765
+ let attackData = {
766
+ ...BaseSkillsFixtures.attackSkill,
767
+ owner: mockOwner,
768
+ range: 0,
769
+ hitDamage: 100,
770
+ damageAffected: true,
771
+ dodgeFullEnabled: false,
772
+ criticalChance: 0,
773
+ aimProperties: ['stats/aim'],
774
+ dodgeProperties: ['stats/dodge'],
775
+ attackProperties: ['stats/atk'],
776
+ defenseProperties: ['stats/def']
777
+ };
778
+ let attack = new Attack(attackData);
779
+ let initialHp = mockTarget.stats.hp;
780
+ await attack.applyDamageTo(mockTarget);
781
+ let damageApplied = initialHp - mockTarget.stats.hp;
782
+ assert.ok(damageApplied < 100);
783
+ });
784
+
785
+ it('should not reduce damage when damageAffected is false even if dodge > aim', async () => {
786
+ mockOwner.stats.aim = 10;
787
+ mockTarget.stats.dodge = 20;
788
+ mockOwner.stats.atk = 0;
789
+ mockTarget.stats.def = 0;
790
+ mockTarget.stats.hp = 150;
791
+ let attackData = {
792
+ ...BaseSkillsFixtures.attackSkill,
793
+ owner: mockOwner,
794
+ range: 0,
795
+ hitDamage: 100,
796
+ damageAffected: false,
797
+ dodgeFullEnabled: false,
798
+ criticalChance: 0,
799
+ aimProperties: ['stats/aim'],
800
+ dodgeProperties: ['stats/dodge'],
801
+ attackProperties: ['stats/atk'],
802
+ defenseProperties: ['stats/def']
803
+ };
804
+ let attack = new Attack(attackData);
805
+ let initialHp = mockTarget.stats.hp;
806
+ await attack.applyDamageTo(mockTarget);
807
+ let damageApplied = initialHp - mockTarget.stats.hp;
808
+ assert.strictEqual(damageApplied, 100);
809
+ });
810
+
811
+ it('should not reduce damage when damageAffected is true but dodge < aim', async () => {
812
+ mockOwner.stats.aim = 20;
813
+ mockTarget.stats.dodge = 10;
814
+ mockOwner.stats.atk = 0;
815
+ mockTarget.stats.def = 0;
816
+ mockTarget.stats.hp = 150;
817
+ let attackData = {
818
+ ...BaseSkillsFixtures.attackSkill,
819
+ owner: mockOwner,
820
+ range: 0,
821
+ hitDamage: 100,
822
+ damageAffected: true,
823
+ dodgeFullEnabled: false,
824
+ criticalChance: 0,
825
+ aimProperties: ['stats/aim'],
826
+ dodgeProperties: ['stats/dodge'],
827
+ attackProperties: ['stats/atk'],
828
+ defenseProperties: ['stats/def']
829
+ };
830
+ let attack = new Attack(attackData);
831
+ let initialHp = mockTarget.stats.hp;
832
+ await attack.applyDamageTo(mockTarget);
833
+ let damageApplied = initialHp - mockTarget.stats.hp;
834
+ assert.strictEqual(damageApplied, 100);
835
+ });
836
+ });
837
+
838
+ describe('criticalAffected - Dodge/Aim Formula', () => {
839
+ it('should reduce critical damage when criticalAffected is true and dodge > aim', async () => {
840
+ mockOwner.stats.aim = 10;
841
+ mockTarget.stats.dodge = 20;
842
+ mockOwner.stats.atk = 0;
843
+ mockTarget.stats.def = 0;
844
+ mockTarget.stats.hp = 250;
845
+ let attackData = {
846
+ ...BaseSkillsFixtures.attackSkill,
847
+ owner: mockOwner,
848
+ range: 0,
849
+ hitDamage: 100,
850
+ criticalChance: 100,
851
+ criticalMultiplier: 2,
852
+ criticalAffected: true,
853
+ dodgeFullEnabled: false,
854
+ aimProperties: ['stats/aim'],
855
+ dodgeProperties: ['stats/dodge'],
856
+ attackProperties: ['stats/atk'],
857
+ defenseProperties: ['stats/def']
858
+ };
859
+ let attack = new Attack(attackData);
860
+ attack.isCritical = () => true;
861
+ let initialHp = mockTarget.stats.hp;
862
+ await attack.applyDamageTo(mockTarget);
863
+ let damageApplied = initialHp - mockTarget.stats.hp;
864
+ assert.strictEqual(damageApplied, 100);
865
+ });
866
+
867
+ it('should not reduce critical when criticalAffected is false', async () => {
868
+ mockOwner.stats.aim = 10;
869
+ mockTarget.stats.dodge = 20;
870
+ mockOwner.stats.atk = 0;
871
+ mockTarget.stats.def = 0;
872
+ mockTarget.stats.hp = 250;
873
+ let attackData = {
874
+ ...BaseSkillsFixtures.attackSkill,
875
+ owner: mockOwner,
876
+ range: 0,
877
+ hitDamage: 100,
878
+ criticalChance: 100,
879
+ criticalMultiplier: 2,
880
+ criticalAffected: false,
881
+ dodgeFullEnabled: false,
882
+ aimProperties: ['stats/aim'],
883
+ dodgeProperties: ['stats/dodge'],
884
+ attackProperties: ['stats/atk'],
885
+ defenseProperties: ['stats/def']
886
+ };
887
+ let attack = new Attack(attackData);
888
+ attack.isCritical = () => true;
889
+ let initialHp = mockTarget.stats.hp;
890
+ await attack.applyDamageTo(mockTarget);
891
+ let damageApplied = initialHp - mockTarget.stats.hp;
892
+ assert.strictEqual(damageApplied, 200);
893
+ });
894
+
895
+ it('should apply full critical when dodge < aim even if criticalAffected is true', async () => {
896
+ mockOwner.stats.aim = 20;
897
+ mockTarget.stats.dodge = 10;
898
+ mockOwner.stats.atk = 0;
899
+ mockTarget.stats.def = 0;
900
+ mockTarget.stats.hp = 250;
901
+ let attackData = {
902
+ ...BaseSkillsFixtures.attackSkill,
903
+ owner: mockOwner,
904
+ range: 0,
905
+ hitDamage: 100,
906
+ criticalChance: 100,
907
+ criticalMultiplier: 2,
908
+ criticalAffected: true,
909
+ dodgeFullEnabled: false,
910
+ aimProperties: ['stats/aim'],
911
+ dodgeProperties: ['stats/dodge'],
912
+ attackProperties: ['stats/atk'],
913
+ defenseProperties: ['stats/def']
914
+ };
915
+ let attack = new Attack(attackData);
916
+ attack.isCritical = () => true;
917
+ let initialHp = mockTarget.stats.hp;
918
+ await attack.applyDamageTo(mockTarget);
919
+ let damageApplied = initialHp - mockTarget.stats.hp;
920
+ assert.strictEqual(damageApplied, 200);
921
+ });
922
+ });
923
+
924
+ describe('allowEffectBelowZero - Property at 0 or Negative', () => {
925
+ it('should return false when hp is 0 and allowEffectBelowZero is false', async () => {
926
+ mockTarget.stats.hp = 0;
927
+ let attackData = {
928
+ ...BaseSkillsFixtures.attackSkill,
929
+ owner: mockOwner,
930
+ range: 0,
931
+ allowEffectBelowZero: false
932
+ };
933
+ let attack = new Attack(attackData);
934
+ let result = await attack.applyDamageTo(mockTarget);
935
+ assert.strictEqual(result, false);
936
+ });
937
+
938
+ it('should return false when hp is negative and allowEffectBelowZero is false', async () => {
939
+ mockTarget.stats.hp = -10;
940
+ let attackData = {
941
+ ...BaseSkillsFixtures.attackSkill,
942
+ owner: mockOwner,
943
+ range: 0,
944
+ allowEffectBelowZero: false
945
+ };
946
+ let attack = new Attack(attackData);
947
+ let result = await attack.applyDamageTo(mockTarget);
948
+ assert.strictEqual(result, false);
949
+ });
950
+
951
+ it('should apply damage when hp is 0 and allowEffectBelowZero is true', async () => {
952
+ mockTarget.stats.hp = 0;
953
+ let attackData = {
954
+ ...BaseSkillsFixtures.attackSkill,
955
+ owner: mockOwner,
956
+ range: 0,
957
+ hitDamage: 50,
958
+ applyDirectDamage: true,
959
+ allowEffectBelowZero: true,
960
+ criticalChance: 0
961
+ };
962
+ let attack = new Attack(attackData);
963
+ let result = await attack.applyDamageTo(mockTarget);
964
+ assert.strictEqual(result, true);
965
+ assert.strictEqual(mockTarget.stats.hp, -50);
966
+ });
967
+
968
+ it('should apply damage when hp is negative and allowEffectBelowZero is true', async () => {
969
+ mockTarget.stats.hp = -20;
970
+ let attackData = {
971
+ ...BaseSkillsFixtures.attackSkill,
972
+ owner: mockOwner,
973
+ range: 0,
974
+ hitDamage: 30,
975
+ applyDirectDamage: true,
976
+ allowEffectBelowZero: true,
977
+ criticalChance: 0
978
+ };
979
+ let attack = new Attack(attackData);
980
+ let result = await attack.applyDamageTo(mockTarget);
981
+ assert.strictEqual(result, true);
982
+ assert.strictEqual(mockTarget.stats.hp, -50);
983
+ });
984
+ });
985
+
986
+ describe('Attack/Defense - 99% Max Modifier Cap', () => {
987
+ it('should cap damage increase at 99% when attack much higher than defense', async () => {
988
+ mockOwner.stats.atk = 1000;
989
+ mockTarget.stats.def = 10;
990
+ mockOwner.stats.aim = 10;
991
+ mockTarget.stats.dodge = 0;
992
+ let attackData = {
993
+ ...BaseSkillsFixtures.attackSkill,
994
+ owner: mockOwner,
995
+ range: 0,
996
+ hitDamage: 100,
997
+ criticalChance: 0,
998
+ dodgeFullEnabled: false,
999
+ attackProperties: ['stats/atk'],
1000
+ defenseProperties: ['stats/def'],
1001
+ aimProperties: ['stats/aim'],
1002
+ dodgeProperties: ['stats/dodge']
1003
+ };
1004
+ let attack = new Attack(attackData);
1005
+ let initialHp = mockTarget.stats.hp;
1006
+ await attack.applyDamageTo(mockTarget);
1007
+ let damageApplied = initialHp - mockTarget.stats.hp;
1008
+ assert.ok(damageApplied <= 199);
1009
+ });
1010
+
1011
+ it('should cap damage reduction at 99% when defense much higher than attack', async () => {
1012
+ mockOwner.stats.atk = 10;
1013
+ mockTarget.stats.def = 1000;
1014
+ mockOwner.stats.aim = 10;
1015
+ mockTarget.stats.dodge = 0;
1016
+ let attackData = {
1017
+ ...BaseSkillsFixtures.attackSkill,
1018
+ owner: mockOwner,
1019
+ range: 0,
1020
+ hitDamage: 100,
1021
+ criticalChance: 0,
1022
+ dodgeFullEnabled: false,
1023
+ attackProperties: ['stats/atk'],
1024
+ defenseProperties: ['stats/def'],
1025
+ aimProperties: ['stats/aim'],
1026
+ dodgeProperties: ['stats/dodge']
1027
+ };
1028
+ let attack = new Attack(attackData);
1029
+ let initialHp = mockTarget.stats.hp;
1030
+ await attack.applyDamageTo(mockTarget);
1031
+ let damageApplied = initialHp - mockTarget.stats.hp;
1032
+ assert.ok(damageApplied >= 1);
1033
+ });
1034
+ });
1035
+
1036
+ describe('Direct Damage with Critical', () => {
1037
+ it('should apply critical to direct damage', async () => {
1038
+ mockTarget.stats.hp = 250;
1039
+ let attackData = {
1040
+ ...BaseSkillsFixtures.attackSkill,
1041
+ owner: mockOwner,
1042
+ range: 0,
1043
+ hitDamage: 100,
1044
+ applyDirectDamage: true,
1045
+ criticalChance: 100,
1046
+ criticalMultiplier: 2,
1047
+ criticalAffected: false
1048
+ };
1049
+ let attack = new Attack(attackData);
1050
+ attack.isCritical = () => true;
1051
+ let initialHp = mockTarget.stats.hp;
1052
+ await attack.applyDamageTo(mockTarget);
1053
+ let damageApplied = initialHp - mockTarget.stats.hp;
1054
+ assert.strictEqual(damageApplied, 200);
1055
+ });
1056
+
1057
+ it('should apply direct damage without critical when not critical hit', async () => {
1058
+ mockTarget.stats.hp = 150;
1059
+ let attackData = {
1060
+ ...BaseSkillsFixtures.attackSkill,
1061
+ owner: mockOwner,
1062
+ range: 0,
1063
+ hitDamage: 100,
1064
+ applyDirectDamage: true,
1065
+ criticalChance: 0
1066
+ };
1067
+ let attack = new Attack(attackData);
1068
+ attack.isCritical = () => false;
1069
+ let initialHp = mockTarget.stats.hp;
1070
+ await attack.applyDamageTo(mockTarget);
1071
+ let damageApplied = initialHp - mockTarget.stats.hp;
1072
+ assert.strictEqual(damageApplied, 100);
1073
+ });
1074
+ });
1075
+
1076
+ describe('calculateCriticalDamage - Formula Verification', () => {
1077
+ it('should calculate critical reduction correctly when criticalAffected', () => {
1078
+ let attackData = {
1079
+ ...BaseSkillsFixtures.attackSkill,
1080
+ owner: mockOwner,
1081
+ criticalChance: 100,
1082
+ criticalMultiplier: 2,
1083
+ criticalAffected: true
1084
+ };
1085
+ let attack = new Attack(attackData);
1086
+ attack.isCritical = () => true;
1087
+ let damage = 100;
1088
+ let targetDodge = 20;
1089
+ let ownerAim = 10;
1090
+ let dodgeAimDiff = ((targetDodge - ownerAim) * 100) / ownerAim;
1091
+ let baseCritical = damage * (attack.criticalMultiplier - 1);
1092
+ let criticalReduction = Math.floor((baseCritical * dodgeAimDiff / 100));
1093
+ let expectedCritical = baseCritical - criticalReduction;
1094
+ let actualCritical = attack.calculateCriticalDamage(damage, targetDodge, ownerAim, dodgeAimDiff);
1095
+ assert.strictEqual(actualCritical, expectedCritical);
1096
+ });
1097
+
1098
+ it('should return full critical value when dodge > aim but criticalAffected is false', () => {
1099
+ let attackData = {
1100
+ ...BaseSkillsFixtures.attackSkill,
1101
+ owner: mockOwner,
1102
+ criticalChance: 100,
1103
+ criticalMultiplier: 2,
1104
+ criticalAffected: false
1105
+ };
1106
+ let attack = new Attack(attackData);
1107
+ attack.isCritical = () => true;
1108
+ let damage = 100;
1109
+ let baseCritical = damage * (attack.criticalMultiplier - 1);
1110
+ let actualCritical = attack.calculateCriticalDamage(damage, 20, 10, 100);
1111
+ assert.strictEqual(actualCritical, baseCritical);
1112
+ });
1113
+
1114
+ it('should return full critical when dodge < aim regardless of criticalAffected', () => {
1115
+ let attackData = {
1116
+ ...BaseSkillsFixtures.attackSkill,
1117
+ owner: mockOwner,
1118
+ criticalChance: 100,
1119
+ criticalMultiplier: 2,
1120
+ criticalAffected: true
1121
+ };
1122
+ let attack = new Attack(attackData);
1123
+ attack.isCritical = () => true;
1124
+ let damage = 100;
1125
+ let baseCritical = damage * (attack.criticalMultiplier - 1);
1126
+ let actualCritical = attack.calculateCriticalDamage(damage, 10, 20, -50);
1127
+ assert.strictEqual(actualCritical, baseCritical);
1128
+ });
1129
+ });
1130
+
1131
+ describe('calculateProportionDamage - Formula Verification', () => {
1132
+ it('should calculate damage increase formula correctly when attack > defense', () => {
1133
+ mockOwner.stats.atk = 20;
1134
+ mockTarget.stats.def = 10;
1135
+ let attackData = {
1136
+ ...BaseSkillsFixtures.attackSkill,
1137
+ owner: mockOwner,
1138
+ attackProperties: ['stats/atk'],
1139
+ defenseProperties: ['stats/def']
1140
+ };
1141
+ let attack = new Attack(attackData);
1142
+ let baseDamage = 100;
1143
+ let diff = 20 - 10;
1144
+ // The code caps percentage at 99% when diff >= targetDef
1145
+ let percentage = diff < 10 ? (diff * 100 / 10) : 99;
1146
+ percentage = percentage > 99 ? 99 : percentage;
1147
+ let additionalDamage = Math.ceil((percentage * baseDamage / 100));
1148
+ let expectedDamage = baseDamage + additionalDamage;
1149
+ let actualDamage = attack.calculateProportionDamage(mockTarget, baseDamage, 0, 10, 0);
1150
+ assert.strictEqual(actualDamage, expectedDamage);
1151
+ });
1152
+
1153
+ it('should calculate damage reduction formula correctly when defense > attack', () => {
1154
+ mockOwner.stats.atk = 10;
1155
+ mockTarget.stats.def = 20;
1156
+ let attackData = {
1157
+ ...BaseSkillsFixtures.attackSkill,
1158
+ owner: mockOwner,
1159
+ attackProperties: ['stats/atk'],
1160
+ defenseProperties: ['stats/def']
1161
+ };
1162
+ let attack = new Attack(attackData);
1163
+ let baseDamage = 100;
1164
+ let diff = 10 - 20;
1165
+ // The code caps percentage at 99% when -diff >= ownerAtk
1166
+ let percentage = -diff < 10 ? (-diff * 100 / 10) : 99;
1167
+ percentage = percentage > 99 ? 99 : percentage;
1168
+ let reducedDamage = Math.floor((percentage * baseDamage / 100));
1169
+ let expectedDamage = baseDamage - reducedDamage;
1170
+ let actualDamage = attack.calculateProportionDamage(mockTarget, baseDamage, 0, 10, 0);
1171
+ assert.strictEqual(actualDamage, expectedDamage);
1172
+ });
1173
+
1174
+ it('should apply dodge proportion reduction when damageAffected and dodge > aim', () => {
1175
+ mockOwner.stats.atk = 10;
1176
+ mockTarget.stats.def = 10;
1177
+ let attackData = {
1178
+ ...BaseSkillsFixtures.attackSkill,
1179
+ owner: mockOwner,
1180
+ damageAffected: true,
1181
+ attackProperties: ['stats/atk'],
1182
+ defenseProperties: ['stats/def']
1183
+ };
1184
+ let attack = new Attack(attackData);
1185
+ let baseDamage = 100;
1186
+ let targetDodge = 20;
1187
+ let ownerAim = 10;
1188
+ let dodgeAimDiff = ((targetDodge - ownerAim) * 100) / ownerAim;
1189
+ let damageProportion = Math.floor((baseDamage * dodgeAimDiff / 100));
1190
+ let expectedDamage = baseDamage - damageProportion;
1191
+ let actualDamage = attack.calculateProportionDamage(mockTarget, baseDamage, targetDodge, ownerAim, dodgeAimDiff);
1192
+ assert.strictEqual(actualDamage, expectedDamage);
1193
+ });
1194
+ });
1195
+ });