@reldens/skills 0.46.0 → 0.47.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,769 @@
1
+ /**
2
+ *
3
+ * Reldens - PhysicalEffect Unit Tests
4
+ *
5
+ */
6
+
7
+ const { describe, it, beforeEach, afterEach } = require('node:test');
8
+ const assert = require('node:assert');
9
+ const PhysicalEffect = require('../../../lib/types/physical-effect');
10
+ const { Modifier, ModifierConst } = require('@reldens/modifiers');
11
+ const SkillsConst = require('../../../lib/constants');
12
+ const SkillsEvents = require('../../../lib/skills-events');
13
+ const { TestHelpers } = require('../../utils/test-helpers');
14
+ const { MockOwner } = require('../../fixtures/mocks/mock-owner');
15
+ const { MockTarget } = require('../../fixtures/mocks/mock-target');
16
+
17
+ describe('PhysicalEffect', () => {
18
+ let mockOwner;
19
+ let mockTarget;
20
+
21
+ beforeEach(() => {
22
+ mockOwner = new MockOwner();
23
+ mockOwner.executePhysicalSkill = async () => {};
24
+ mockTarget = new MockTarget();
25
+ TestHelpers.clearEventListeners();
26
+ });
27
+
28
+ afterEach(() => {
29
+ TestHelpers.clearEventListeners();
30
+ });
31
+
32
+ describe('Constructor', () => {
33
+ it('should initialize with physical effect type', () => {
34
+ let skillData = {
35
+ key: 'test-physical-effect',
36
+ owner: mockOwner,
37
+ magnitude: 100,
38
+ objectWidth: 10,
39
+ objectHeight: 10,
40
+ targetEffects: []
41
+ };
42
+ let skill = new PhysicalEffect(skillData);
43
+ assert.strictEqual(skill.type, SkillsConst.SKILL.TYPE.PHYSICAL_EFFECT);
44
+ });
45
+
46
+ it('should set parent type to effect', () => {
47
+ let skillData = {
48
+ key: 'test-physical-effect',
49
+ owner: mockOwner,
50
+ magnitude: 100,
51
+ objectWidth: 10,
52
+ objectHeight: 10,
53
+ targetEffects: []
54
+ };
55
+ let skill = new PhysicalEffect(skillData);
56
+ assert.strictEqual(skill.parentType, SkillsConst.SKILL.TYPE.EFFECT);
57
+ });
58
+
59
+ it('should set isReady to true when all properties valid', () => {
60
+ let skillData = {
61
+ key: 'test-physical-effect',
62
+ owner: mockOwner,
63
+ magnitude: 100,
64
+ objectWidth: 10,
65
+ objectHeight: 10,
66
+ targetEffects: []
67
+ };
68
+ let skill = new PhysicalEffect(skillData);
69
+ assert.strictEqual(skill.isReady, true);
70
+ });
71
+
72
+ it('should set isReady to false when magnitude missing', () => {
73
+ let skillData = {
74
+ key: 'test-physical-effect',
75
+ owner: mockOwner,
76
+ objectWidth: 10,
77
+ objectHeight: 10,
78
+ targetEffects: []
79
+ };
80
+ let skill = new PhysicalEffect(skillData);
81
+ assert.strictEqual(skill.isReady, false);
82
+ });
83
+
84
+ it('should set isReady to false when objectWidth missing', () => {
85
+ let skillData = {
86
+ key: 'test-physical-effect',
87
+ owner: mockOwner,
88
+ magnitude: 100,
89
+ objectHeight: 10,
90
+ targetEffects: []
91
+ };
92
+ let skill = new PhysicalEffect(skillData);
93
+ assert.strictEqual(skill.isReady, false);
94
+ });
95
+
96
+ it('should set isReady to false when objectHeight missing', () => {
97
+ let skillData = {
98
+ key: 'test-physical-effect',
99
+ owner: mockOwner,
100
+ magnitude: 100,
101
+ objectWidth: 10,
102
+ targetEffects: []
103
+ };
104
+ let skill = new PhysicalEffect(skillData);
105
+ assert.strictEqual(skill.isReady, false);
106
+ });
107
+
108
+ it('should set isReady to false when executePhysicalSkill missing', () => {
109
+ let ownerWithoutMethod = new MockOwner();
110
+ let skillData = {
111
+ key: 'test-physical-effect',
112
+ owner: ownerWithoutMethod,
113
+ magnitude: 100,
114
+ objectWidth: 10,
115
+ objectHeight: 10,
116
+ targetEffects: []
117
+ };
118
+ let skill = new PhysicalEffect(skillData);
119
+ assert.strictEqual(skill.isReady, false);
120
+ });
121
+
122
+ it('should set magnitude property', () => {
123
+ let skillData = {
124
+ key: 'test-physical-effect',
125
+ owner: mockOwner,
126
+ magnitude: 150,
127
+ objectWidth: 10,
128
+ objectHeight: 10,
129
+ targetEffects: []
130
+ };
131
+ let skill = new PhysicalEffect(skillData);
132
+ assert.strictEqual(skill.magnitude, 150);
133
+ });
134
+
135
+ it('should set objectWidth property', () => {
136
+ let skillData = {
137
+ key: 'test-physical-effect',
138
+ owner: mockOwner,
139
+ magnitude: 100,
140
+ objectWidth: 20,
141
+ objectHeight: 10,
142
+ targetEffects: []
143
+ };
144
+ let skill = new PhysicalEffect(skillData);
145
+ assert.strictEqual(skill.objectWidth, 20);
146
+ });
147
+
148
+ it('should set objectHeight property', () => {
149
+ let skillData = {
150
+ key: 'test-physical-effect',
151
+ owner: mockOwner,
152
+ magnitude: 100,
153
+ objectWidth: 10,
154
+ objectHeight: 25,
155
+ targetEffects: []
156
+ };
157
+ let skill = new PhysicalEffect(skillData);
158
+ assert.strictEqual(skill.objectHeight, 25);
159
+ });
160
+
161
+ it('should set validateTargetOnHit to false by default', () => {
162
+ let skillData = {
163
+ key: 'test-physical-effect',
164
+ owner: mockOwner,
165
+ magnitude: 100,
166
+ objectWidth: 10,
167
+ objectHeight: 10,
168
+ targetEffects: []
169
+ };
170
+ let skill = new PhysicalEffect(skillData);
171
+ assert.strictEqual(skill.validateTargetOnHit, false);
172
+ });
173
+
174
+ it('should set validateTargetOnHit when provided', () => {
175
+ let skillData = {
176
+ key: 'test-physical-effect',
177
+ owner: mockOwner,
178
+ magnitude: 100,
179
+ objectWidth: 10,
180
+ objectHeight: 10,
181
+ targetEffects: [],
182
+ validateTargetOnHit: true
183
+ };
184
+ let skill = new PhysicalEffect(skillData);
185
+ assert.strictEqual(skill.validateTargetOnHit, true);
186
+ });
187
+
188
+ it('should inherit effect properties', () => {
189
+ let modifier = new Modifier({
190
+ key: 'speed-buff',
191
+ propertyKey: 'stats/speed',
192
+ operation: ModifierConst.OPS.INC,
193
+ value: 10
194
+ });
195
+ let skillData = {
196
+ key: 'test-physical-effect',
197
+ owner: mockOwner,
198
+ magnitude: 100,
199
+ objectWidth: 10,
200
+ objectHeight: 10,
201
+ targetEffects: [modifier]
202
+ };
203
+ let skill = new PhysicalEffect(skillData);
204
+ assert.ok(Array.isArray(skill.targetEffects));
205
+ assert.strictEqual(skill.targetEffects.length, 1);
206
+ });
207
+ });
208
+
209
+ describe('runSkillLogic', () => {
210
+ it('should return false when target out of range', async () => {
211
+ let skillData = {
212
+ key: 'test-physical-effect',
213
+ owner: mockOwner,
214
+ target: mockTarget,
215
+ range: 10,
216
+ rangePropertyX: 'position/x',
217
+ rangePropertyY: 'position/y',
218
+ magnitude: 100,
219
+ objectWidth: 10,
220
+ objectHeight: 10,
221
+ targetEffects: []
222
+ };
223
+ let skill = new PhysicalEffect(skillData);
224
+ mockOwner.position = {x: 0, y: 0};
225
+ mockTarget.position = {x: 100, y: 100};
226
+ let result = await skill.runSkillLogic();
227
+ assert.strictEqual(result, false);
228
+ });
229
+
230
+ it('should execute physical skill when in range', async () => {
231
+ let executed = false;
232
+ mockOwner.executePhysicalSkill = async (target, skill) => {
233
+ executed = true;
234
+ };
235
+ let skillData = {
236
+ key: 'test-physical-effect',
237
+ owner: mockOwner,
238
+ target: mockTarget,
239
+ magnitude: 100,
240
+ objectWidth: 10,
241
+ objectHeight: 10,
242
+ rangePropertyX: 'position/x',
243
+ rangePropertyY: 'position/y',
244
+ targetEffects: []
245
+ };
246
+ let skill = new PhysicalEffect(skillData);
247
+ await skill.runSkillLogic();
248
+ assert.strictEqual(executed, true);
249
+ });
250
+
251
+ it('should return false after executing physical skill', async () => {
252
+ let skillData = {
253
+ key: 'test-physical-effect',
254
+ owner: mockOwner,
255
+ target: mockTarget,
256
+ magnitude: 100,
257
+ objectWidth: 10,
258
+ objectHeight: 10,
259
+ targetEffects: []
260
+ };
261
+ let skill = new PhysicalEffect(skillData);
262
+ let result = await skill.runSkillLogic();
263
+ assert.strictEqual(result, false);
264
+ });
265
+
266
+ it('should pass target and skill to executePhysicalSkill', async () => {
267
+ let receivedTarget = null;
268
+ let receivedSkill = null;
269
+ mockOwner.executePhysicalSkill = async (target, skill) => {
270
+ receivedTarget = target;
271
+ receivedSkill = skill;
272
+ };
273
+ let skillData = {
274
+ key: 'test-physical-effect',
275
+ owner: mockOwner,
276
+ target: mockTarget,
277
+ magnitude: 100,
278
+ objectWidth: 10,
279
+ objectHeight: 10,
280
+ rangePropertyX: 'position/x',
281
+ rangePropertyY: 'position/y',
282
+ targetEffects: []
283
+ };
284
+ let skill = new PhysicalEffect(skillData);
285
+ await skill.runSkillLogic();
286
+ assert.strictEqual(receivedTarget, mockTarget);
287
+ assert.strictEqual(receivedSkill, skill);
288
+ });
289
+ });
290
+
291
+ describe('executeOnHit', () => {
292
+ it('should fire physical effect hit event', async () => {
293
+ let eventFired = false;
294
+ let skillData = {
295
+ key: 'test-physical-effect',
296
+ owner: mockOwner,
297
+ magnitude: 100,
298
+ objectWidth: 10,
299
+ objectHeight: 10,
300
+ targetEffects: []
301
+ };
302
+ let skill = new PhysicalEffect(skillData);
303
+ skill.listenEvent(SkillsEvents.SKILL_PHYSICAL_EFFECT_HIT, async () => {
304
+ eventFired = true;
305
+ }, 'testListener', skill.getOwnerEventKey());
306
+ await skill.executeOnHit(mockTarget);
307
+ assert.strictEqual(eventFired, true);
308
+ });
309
+
310
+ it('should apply modifiers to target', async () => {
311
+ let modifier = new Modifier({
312
+ key: 'atk-buff',
313
+ propertyKey: 'stats/atk',
314
+ operation: ModifierConst.OPS.INC,
315
+ value: 20
316
+ });
317
+ let skillData = {
318
+ key: 'test-physical-effect',
319
+ owner: mockOwner,
320
+ target: mockTarget,
321
+ magnitude: 100,
322
+ objectWidth: 10,
323
+ objectHeight: 10,
324
+ targetEffects: [modifier]
325
+ };
326
+ let skill = new PhysicalEffect(skillData);
327
+ let initialAtk = mockTarget.stats.atk;
328
+ await skill.executeOnHit(mockTarget);
329
+ assert.strictEqual(mockTarget.stats.atk, initialAtk + 20);
330
+ });
331
+
332
+ it('should validate target when validateTargetOnHit is true', async () => {
333
+ let differentTarget = new MockTarget();
334
+ differentTarget.id = 'different-id';
335
+ let skillData = {
336
+ key: 'test-physical-effect',
337
+ owner: mockOwner,
338
+ target: mockTarget,
339
+ magnitude: 100,
340
+ objectWidth: 10,
341
+ objectHeight: 10,
342
+ targetEffects: [],
343
+ validateTargetOnHit: true
344
+ };
345
+ let skill = new PhysicalEffect(skillData);
346
+ let result = await skill.executeOnHit(differentTarget);
347
+ assert.strictEqual(result, false);
348
+ });
349
+
350
+ it('should skip validation when validateTargetOnHit is false', async () => {
351
+ let differentTarget = new MockTarget();
352
+ differentTarget.id = 'different-id';
353
+ let modifier = new Modifier({
354
+ key: 'def-buff',
355
+ propertyKey: 'stats/def',
356
+ operation: ModifierConst.OPS.INC,
357
+ value: 15
358
+ });
359
+ let skillData = {
360
+ key: 'test-physical-effect',
361
+ owner: mockOwner,
362
+ target: mockTarget,
363
+ magnitude: 100,
364
+ objectWidth: 10,
365
+ objectHeight: 10,
366
+ targetEffects: [modifier],
367
+ validateTargetOnHit: false
368
+ };
369
+ let skill = new PhysicalEffect(skillData);
370
+ let initialDef = mockTarget.stats.def;
371
+ await skill.executeOnHit(differentTarget);
372
+ assert.strictEqual(mockTarget.stats.def, initialDef + 15);
373
+ });
374
+
375
+ it('should call parent runSkillLogic', async () => {
376
+ let modifier = new Modifier({
377
+ key: 'mp-buff',
378
+ propertyKey: 'stats/mp',
379
+ operation: ModifierConst.OPS.INC,
380
+ value: 25
381
+ });
382
+ let skillData = {
383
+ key: 'test-physical-effect',
384
+ owner: mockOwner,
385
+ target: mockTarget,
386
+ range: 0,
387
+ magnitude: 100,
388
+ objectWidth: 10,
389
+ objectHeight: 10,
390
+ rangePropertyX: 'position/x',
391
+ rangePropertyY: 'position/y',
392
+ targetEffects: [modifier]
393
+ };
394
+ let skill = new PhysicalEffect(skillData);
395
+ let initialMp = mockTarget.stats.mp;
396
+ await skill.executeOnHit(mockTarget);
397
+ assert.strictEqual(mockTarget.stats.mp, initialMp + 25);
398
+ });
399
+
400
+ it('should handle empty targetEffects array', async () => {
401
+ let skillData = {
402
+ key: 'test-physical-effect',
403
+ owner: mockOwner,
404
+ magnitude: 100,
405
+ objectWidth: 10,
406
+ objectHeight: 10,
407
+ targetEffects: []
408
+ };
409
+ let skill = new PhysicalEffect(skillData);
410
+ await skill.executeOnHit(mockTarget);
411
+ });
412
+ });
413
+
414
+ describe('Integration', () => {
415
+ it('should handle complete physical effect flow', async () => {
416
+ let physicalSkillExecuted = false;
417
+ let hitExecuted = false;
418
+ mockOwner.executePhysicalSkill = async (target, skill) => {
419
+ physicalSkillExecuted = true;
420
+ await skill.executeOnHit(target);
421
+ };
422
+ let modifier = new Modifier({
423
+ key: 'hp-buff',
424
+ propertyKey: 'stats/hp',
425
+ operation: ModifierConst.OPS.INC,
426
+ value: 25
427
+ });
428
+ let skillData = {
429
+ key: 'test-physical-effect',
430
+ owner: mockOwner,
431
+ target: mockTarget,
432
+ magnitude: 100,
433
+ objectWidth: 10,
434
+ objectHeight: 10,
435
+ rangePropertyX: 'position/x',
436
+ rangePropertyY: 'position/y',
437
+ targetEffects: [modifier]
438
+ };
439
+ let skill = new PhysicalEffect(skillData);
440
+ skill.listenEvent(SkillsEvents.SKILL_PHYSICAL_EFFECT_HIT, async () => {
441
+ hitExecuted = true;
442
+ }, 'hitListener', skill.getOwnerEventKey());
443
+ let initialHp = mockTarget.stats.hp;
444
+ await skill.runSkillLogic();
445
+ assert.strictEqual(physicalSkillExecuted, true);
446
+ assert.strictEqual(hitExecuted, true);
447
+ assert.strictEqual(mockTarget.stats.hp, initialHp + 25);
448
+ });
449
+
450
+ it('should apply multiple modifiers', async () => {
451
+ mockOwner.executePhysicalSkill = async (target, skill) => {
452
+ await skill.executeOnHit(target);
453
+ };
454
+ let modifiers = [
455
+ new Modifier({
456
+ key: 'atk-buff',
457
+ propertyKey: 'stats/atk',
458
+ operation: ModifierConst.OPS.INC,
459
+ value: 10
460
+ }),
461
+ new Modifier({
462
+ key: 'def-buff',
463
+ propertyKey: 'stats/def',
464
+ operation: ModifierConst.OPS.INC,
465
+ value: 8
466
+ })
467
+ ];
468
+ let skillData = {
469
+ key: 'test-physical-effect',
470
+ owner: mockOwner,
471
+ target: mockTarget,
472
+ magnitude: 100,
473
+ objectWidth: 10,
474
+ objectHeight: 10,
475
+ rangePropertyX: 'position/x',
476
+ rangePropertyY: 'position/y',
477
+ targetEffects: modifiers
478
+ };
479
+ let skill = new PhysicalEffect(skillData);
480
+ let initialAtk = mockTarget.stats.atk;
481
+ let initialDef = mockTarget.stats.def;
482
+ await skill.runSkillLogic();
483
+ assert.strictEqual(mockTarget.stats.atk, initialAtk + 10);
484
+ assert.strictEqual(mockTarget.stats.def, initialDef + 8);
485
+ });
486
+
487
+ it('should handle critical modifiers', async () => {
488
+ mockOwner.executePhysicalSkill = async (target, skill) => {
489
+ await skill.executeOnHit(target);
490
+ };
491
+ let modifier = new Modifier({
492
+ key: 'mp-buff',
493
+ propertyKey: 'stats/mp',
494
+ operation: ModifierConst.OPS.INC,
495
+ value: 20
496
+ });
497
+ let skillData = {
498
+ key: 'test-physical-effect',
499
+ owner: mockOwner,
500
+ target: mockTarget,
501
+ magnitude: 100,
502
+ objectWidth: 10,
503
+ objectHeight: 10,
504
+ rangePropertyX: 'position/x',
505
+ rangePropertyY: 'position/y',
506
+ targetEffects: [modifier],
507
+ criticalChance: 100,
508
+ criticalMultiplier: 2
509
+ };
510
+ let skill = new PhysicalEffect(skillData);
511
+ let initialMp = mockTarget.stats.mp;
512
+ await skill.runSkillLogic();
513
+ assert.strictEqual(mockTarget.stats.mp, initialMp + (20 * 2));
514
+ });
515
+
516
+ it('should broadcast effect event', async () => {
517
+ let eventFired = false;
518
+ mockOwner.executePhysicalSkill = async (target, skill) => {
519
+ await skill.executeOnHit(target);
520
+ };
521
+ let skillData = {
522
+ key: 'test-physical-effect',
523
+ owner: mockOwner,
524
+ target: mockTarget,
525
+ magnitude: 100,
526
+ objectWidth: 10,
527
+ objectHeight: 10,
528
+ rangePropertyX: 'position/x',
529
+ rangePropertyY: 'position/y',
530
+ targetEffects: []
531
+ };
532
+ let skill = new PhysicalEffect(skillData);
533
+ skill.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, async () => {
534
+ eventFired = true;
535
+ }, 'effectListener', skill.getOwnerEventKey());
536
+ await skill.runSkillLogic();
537
+ assert.strictEqual(eventFired, true);
538
+ });
539
+ });
540
+
541
+ describe('Edge Cases', () => {
542
+ it('should handle zero magnitude', () => {
543
+ let skillData = {
544
+ key: 'test-physical-effect',
545
+ owner: mockOwner,
546
+ magnitude: 0,
547
+ objectWidth: 10,
548
+ objectHeight: 10,
549
+ targetEffects: []
550
+ };
551
+ let skill = new PhysicalEffect(skillData);
552
+ assert.strictEqual(skill.magnitude, 0);
553
+ assert.strictEqual(skill.isReady, true);
554
+ });
555
+
556
+ it('should handle zero object dimensions', () => {
557
+ let skillData = {
558
+ key: 'test-physical-effect',
559
+ owner: mockOwner,
560
+ magnitude: 100,
561
+ objectWidth: 0,
562
+ objectHeight: 0,
563
+ targetEffects: []
564
+ };
565
+ let skill = new PhysicalEffect(skillData);
566
+ assert.strictEqual(skill.objectWidth, 0);
567
+ assert.strictEqual(skill.objectHeight, 0);
568
+ assert.strictEqual(skill.isReady, true);
569
+ });
570
+
571
+ it('should handle large magnitude values', () => {
572
+ let skillData = {
573
+ key: 'test-physical-effect',
574
+ owner: mockOwner,
575
+ magnitude: 999999,
576
+ objectWidth: 10,
577
+ objectHeight: 10,
578
+ targetEffects: []
579
+ };
580
+ let skill = new PhysicalEffect(skillData);
581
+ assert.strictEqual(skill.magnitude, 999999);
582
+ });
583
+
584
+ it('should handle decimal magnitude', () => {
585
+ let skillData = {
586
+ key: 'test-physical-effect',
587
+ owner: mockOwner,
588
+ magnitude: 150.75,
589
+ objectWidth: 10,
590
+ objectHeight: 10,
591
+ targetEffects: []
592
+ };
593
+ let skill = new PhysicalEffect(skillData);
594
+ assert.strictEqual(skill.magnitude, 150.75);
595
+ });
596
+
597
+ it('should handle null target in runSkillLogic', async () => {
598
+ let skillData = {
599
+ key: 'test-physical-effect',
600
+ owner: mockOwner,
601
+ target: null,
602
+ magnitude: 100,
603
+ objectWidth: 10,
604
+ objectHeight: 10,
605
+ rangePropertyX: 'position/x',
606
+ rangePropertyY: 'position/y',
607
+ targetEffects: []
608
+ };
609
+ let skill = new PhysicalEffect(skillData);
610
+ await assert.rejects(async () => {
611
+ await skill.runSkillLogic();
612
+ });
613
+ });
614
+
615
+ it('should handle target without stats property', async () => {
616
+ mockOwner.executePhysicalSkill = async (target, skill) => {
617
+ await skill.executeOnHit(target);
618
+ };
619
+ let targetWithoutStats = {
620
+ id: 'test-target',
621
+ getPosition: () => ({x: 0, y: 0}),
622
+ position: {x: 0, y: 0}
623
+ };
624
+ let modifier = new Modifier({
625
+ key: 'new-stat',
626
+ propertyKey: 'stats/newStat',
627
+ operation: ModifierConst.OPS.SET_VALUE,
628
+ value: 100
629
+ });
630
+ let skillData = {
631
+ key: 'test-physical-effect',
632
+ owner: mockOwner,
633
+ target: targetWithoutStats,
634
+ magnitude: 100,
635
+ objectWidth: 10,
636
+ objectHeight: 10,
637
+ rangePropertyX: 'position/x',
638
+ rangePropertyY: 'position/y',
639
+ targetEffects: [modifier]
640
+ };
641
+ let skill = new PhysicalEffect(skillData);
642
+ await assert.rejects(async () => {
643
+ await skill.runSkillLogic();
644
+ });
645
+ });
646
+
647
+ it('should handle modifier operations on undefined properties', async () => {
648
+ let modifier = new Modifier({
649
+ key: 'undefined-buff',
650
+ propertyKey: 'stats/undefinedProp',
651
+ operation: ModifierConst.OPS.INC,
652
+ value: 50
653
+ });
654
+ let skillData = {
655
+ key: 'test-physical-effect',
656
+ owner: mockOwner,
657
+ target: mockTarget,
658
+ magnitude: 100,
659
+ objectWidth: 10,
660
+ objectHeight: 10,
661
+ targetEffects: [modifier]
662
+ };
663
+ let skill = new PhysicalEffect(skillData);
664
+ await skill.executeOnHit(mockTarget);
665
+ assert.strictEqual(mockTarget.stats.undefinedProp, 50);
666
+ });
667
+ });
668
+
669
+ describe('executeOnHit - lastState on Validation Failure', () => {
670
+ it('should set lastState when validateTargetOnHit fails', async () => {
671
+ let differentTarget = new MockTarget();
672
+ differentTarget.id = 'different-id';
673
+ let skillData = {
674
+ key: 'test-physical-effect',
675
+ owner: mockOwner,
676
+ target: mockTarget,
677
+ magnitude: 100,
678
+ objectWidth: 10,
679
+ objectHeight: 10,
680
+ targetEffects: [],
681
+ validateTargetOnHit: true
682
+ };
683
+ let skill = new PhysicalEffect(skillData);
684
+ await skill.executeOnHit(differentTarget);
685
+ assert.ok(skill.lastState);
686
+ });
687
+ });
688
+
689
+ describe('executeOnHit - Parent Throws During Execution', () => {
690
+ it('should handle when parent runSkillLogic throws error', async () => {
691
+ let skillData = {
692
+ key: 'test-physical-effect',
693
+ owner: mockOwner,
694
+ target: mockTarget,
695
+ magnitude: 100,
696
+ objectWidth: 10,
697
+ objectHeight: 10,
698
+ range: 100,
699
+ targetEffects: []
700
+ };
701
+ let skill = new PhysicalEffect(skillData);
702
+ mockTarget.getPosition = () => {
703
+ throw new Error('Parent error');
704
+ };
705
+ await assert.rejects(async () => {
706
+ await skill.executeOnHit(mockTarget);
707
+ });
708
+ });
709
+ });
710
+
711
+ describe('executeOnHit - Critical Multiplier from executeOnHit Path', () => {
712
+ it('should apply critical multiplier when called from executeOnHit', async () => {
713
+ mockOwner.executePhysicalSkill = async (target, skill) => {
714
+ await skill.executeOnHit(target);
715
+ };
716
+ let modifier = new Modifier({
717
+ key: 'stamina-buff',
718
+ propertyKey: 'stats/stamina',
719
+ operation: ModifierConst.OPS.INC,
720
+ value: 10
721
+ });
722
+ let skillData = {
723
+ key: 'test-physical-effect',
724
+ owner: mockOwner,
725
+ target: mockTarget,
726
+ magnitude: 100,
727
+ objectWidth: 10,
728
+ objectHeight: 10,
729
+ rangePropertyX: 'position/x',
730
+ rangePropertyY: 'position/y',
731
+ targetEffects: [modifier],
732
+ criticalChance: 100,
733
+ criticalMultiplier: 3
734
+ };
735
+ let skill = new PhysicalEffect(skillData);
736
+ skill.isCritical = () => true;
737
+ let initialStamina = mockTarget.stats.stamina;
738
+ await skill.runSkillLogic();
739
+ assert.strictEqual(mockTarget.stats.stamina, initialStamina + 30);
740
+ });
741
+ });
742
+
743
+ describe('executeOnHit - Multiple Hits on Same Target', () => {
744
+ it('should handle multiple executeOnHit calls on same target', async () => {
745
+ let modifier = new Modifier({
746
+ key: 'mp-buff',
747
+ propertyKey: 'stats/mp',
748
+ operation: ModifierConst.OPS.INC,
749
+ value: 5
750
+ });
751
+ let skillData = {
752
+ key: 'test-physical-effect',
753
+ owner: mockOwner,
754
+ target: mockTarget,
755
+ magnitude: 100,
756
+ objectWidth: 10,
757
+ objectHeight: 10,
758
+ targetEffects: [modifier],
759
+ criticalChance: 0
760
+ };
761
+ let skill = new PhysicalEffect(skillData);
762
+ let initialMp = mockTarget.stats.mp;
763
+ await skill.executeOnHit(mockTarget);
764
+ await skill.executeOnHit(mockTarget);
765
+ await skill.executeOnHit(mockTarget);
766
+ assert.strictEqual(mockTarget.stats.mp, initialMp + 15);
767
+ });
768
+ });
769
+ });