@reldens/skills 0.45.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 (41) 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
  41. package/migrations/production/reldens-skills-install.sql +0 -275
@@ -0,0 +1,564 @@
1
+ /**
2
+ *
3
+ * Reldens - PhysicalAttack Unit Tests
4
+ *
5
+ */
6
+
7
+ const { describe, it, beforeEach, afterEach } = require('node:test');
8
+ const assert = require('node:assert');
9
+ const PhysicalAttack = require('../../../lib/types/physical-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
+
17
+ describe('PhysicalAttack', () => {
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 attack type', () => {
34
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
35
+ let skill = new PhysicalAttack(skillData);
36
+ assert.strictEqual(skill.type, SkillsConst.SKILL.TYPE.PHYSICAL_ATTACK);
37
+ });
38
+
39
+ it('should set parent type to attack', () => {
40
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
41
+ let skill = new PhysicalAttack(skillData);
42
+ assert.strictEqual(skill.parentType, SkillsConst.SKILL.TYPE.ATTACK);
43
+ });
44
+
45
+ it('should set isReady to true when all properties valid', () => {
46
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
47
+ let skill = new PhysicalAttack(skillData);
48
+ assert.strictEqual(skill.isReady, true);
49
+ });
50
+
51
+ it('should set isReady to false when magnitude missing', () => {
52
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
53
+ delete skillData.magnitude;
54
+ let skill = new PhysicalAttack(skillData);
55
+ assert.strictEqual(skill.isReady, false);
56
+ });
57
+
58
+ it('should set isReady to false when objectWidth missing', () => {
59
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
60
+ delete skillData.objectWidth;
61
+ let skill = new PhysicalAttack(skillData);
62
+ assert.strictEqual(skill.isReady, false);
63
+ });
64
+
65
+ it('should set isReady to false when objectHeight missing', () => {
66
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
67
+ delete skillData.objectHeight;
68
+ let skill = new PhysicalAttack(skillData);
69
+ assert.strictEqual(skill.isReady, false);
70
+ });
71
+
72
+ it('should set isReady to false when executePhysicalSkill missing', () => {
73
+ let ownerWithoutMethod = new MockOwner();
74
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: ownerWithoutMethod};
75
+ let skill = new PhysicalAttack(skillData);
76
+ assert.strictEqual(skill.isReady, false);
77
+ });
78
+
79
+ it('should set magnitude property', () => {
80
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
81
+ let skill = new PhysicalAttack(skillData);
82
+ assert.strictEqual(skill.magnitude, 100);
83
+ });
84
+
85
+ it('should set objectWidth property', () => {
86
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
87
+ let skill = new PhysicalAttack(skillData);
88
+ assert.strictEqual(skill.objectWidth, 10);
89
+ });
90
+
91
+ it('should set objectHeight property', () => {
92
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
93
+ let skill = new PhysicalAttack(skillData);
94
+ assert.strictEqual(skill.objectHeight, 10);
95
+ });
96
+
97
+ it('should set validateTargetOnHit to false by default', () => {
98
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
99
+ let skill = new PhysicalAttack(skillData);
100
+ assert.strictEqual(skill.validateTargetOnHit, false);
101
+ });
102
+
103
+ it('should set validateTargetOnHit when provided', () => {
104
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner, validateTargetOnHit: true};
105
+ let skill = new PhysicalAttack(skillData);
106
+ assert.strictEqual(skill.validateTargetOnHit, true);
107
+ });
108
+
109
+ it('should inherit attack properties', () => {
110
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
111
+ let skill = new PhysicalAttack(skillData);
112
+ assert.strictEqual(skill.affectedProperty, 'stats/hp');
113
+ assert.strictEqual(skill.hitDamage, 15);
114
+ assert.ok(Array.isArray(skill.attackProperties));
115
+ assert.ok(Array.isArray(skill.defenseProperties));
116
+ });
117
+ });
118
+
119
+ describe('runSkillLogic', () => {
120
+ it('should return false when target out of range', async () => {
121
+ let skillData = {
122
+ ...BaseSkillsFixtures.physicalAttackSkill,
123
+ owner: mockOwner,
124
+ target: mockTarget,
125
+ range: 10,
126
+ rangePropertyX: 'position/x',
127
+ rangePropertyY: 'position/y'
128
+ };
129
+ let skill = new PhysicalAttack(skillData);
130
+ mockOwner.position = {x: 0, y: 0};
131
+ mockTarget.position = {x: 100, y: 100};
132
+ let result = await skill.runSkillLogic();
133
+ assert.strictEqual(result, false);
134
+ });
135
+
136
+ it('should execute physical skill when in range', async () => {
137
+ let executed = false;
138
+ mockOwner.executePhysicalSkill = async (target, skill) => {
139
+ executed = true;
140
+ };
141
+ let skillData = {
142
+ ...BaseSkillsFixtures.physicalAttackSkill,
143
+ owner: mockOwner,
144
+ target: mockTarget,
145
+ rangePropertyX: 'position/x',
146
+ rangePropertyY: 'position/y'
147
+ };
148
+ let skill = new PhysicalAttack(skillData);
149
+ await skill.runSkillLogic();
150
+ assert.strictEqual(executed, true);
151
+ });
152
+
153
+ it('should return false after executing physical skill', async () => {
154
+ let skillData = {
155
+ ...BaseSkillsFixtures.physicalAttackSkill,
156
+ owner: mockOwner,
157
+ target: mockTarget,
158
+ rangePropertyX: 'position/x',
159
+ rangePropertyY: 'position/y'
160
+ };
161
+ let skill = new PhysicalAttack(skillData);
162
+ let result = await skill.runSkillLogic();
163
+ assert.strictEqual(result, false);
164
+ });
165
+
166
+ it('should pass target and skill to executePhysicalSkill', async () => {
167
+ let receivedTarget = null;
168
+ let receivedSkill = null;
169
+ mockOwner.executePhysicalSkill = async (target, skill) => {
170
+ receivedTarget = target;
171
+ receivedSkill = skill;
172
+ };
173
+ let skillData = {
174
+ ...BaseSkillsFixtures.physicalAttackSkill,
175
+ owner: mockOwner,
176
+ target: mockTarget,
177
+ rangePropertyX: 'position/x',
178
+ rangePropertyY: 'position/y'
179
+ };
180
+ let skill = new PhysicalAttack(skillData);
181
+ await skill.runSkillLogic();
182
+ assert.strictEqual(receivedTarget, mockTarget);
183
+ assert.strictEqual(receivedSkill, skill);
184
+ });
185
+ });
186
+
187
+ describe('executeOnHit', () => {
188
+ it('should fire physical attack hit event', async () => {
189
+ let eventFired = false;
190
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner};
191
+ let skill = new PhysicalAttack(skillData);
192
+ skill.listenEvent(SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT, async () => {
193
+ eventFired = true;
194
+ }, 'testListener', skill.getOwnerEventKey());
195
+ await skill.executeOnHit(mockTarget);
196
+ assert.strictEqual(eventFired, true);
197
+ });
198
+
199
+ it('should apply damage to target', async () => {
200
+ let skillData = {
201
+ ...BaseSkillsFixtures.physicalAttackSkill,
202
+ owner: mockOwner,
203
+ target: mockTarget,
204
+ applyDirectDamage: true
205
+ };
206
+ let skill = new PhysicalAttack(skillData);
207
+ let initialHp = mockTarget.stats.hp;
208
+ await skill.executeOnHit(mockTarget);
209
+ assert.ok(mockTarget.stats.hp < initialHp);
210
+ });
211
+
212
+ it('should validate target when validateTargetOnHit is true', async () => {
213
+ let differentTarget = new MockTarget();
214
+ differentTarget.id = 'different-id';
215
+ let skillData = {
216
+ ...BaseSkillsFixtures.physicalAttackSkill,
217
+ owner: mockOwner,
218
+ target: mockTarget,
219
+ validateTargetOnHit: true
220
+ };
221
+ let skill = new PhysicalAttack(skillData);
222
+ let result = await skill.executeOnHit(differentTarget);
223
+ assert.strictEqual(result, false);
224
+ });
225
+
226
+ it('should skip validation when validateTargetOnHit is false', async () => {
227
+ let differentTarget = new MockTarget();
228
+ differentTarget.id = 'different-id';
229
+ let skillData = {
230
+ ...BaseSkillsFixtures.physicalAttackSkill,
231
+ owner: mockOwner,
232
+ target: mockTarget,
233
+ validateTargetOnHit: false,
234
+ applyDirectDamage: true
235
+ };
236
+ let skill = new PhysicalAttack(skillData);
237
+ let initialHp = mockTarget.stats.hp;
238
+ await skill.executeOnHit(differentTarget);
239
+ assert.ok(mockTarget.stats.hp < initialHp);
240
+ });
241
+
242
+ it('should call parent runSkillLogic', async () => {
243
+ let skillData = {
244
+ ...BaseSkillsFixtures.physicalAttackSkill,
245
+ owner: mockOwner,
246
+ target: mockTarget,
247
+ applyDirectDamage: true
248
+ };
249
+ let skill = new PhysicalAttack(skillData);
250
+ let initialHp = mockTarget.stats.hp;
251
+ await skill.executeOnHit(mockTarget);
252
+ assert.ok(mockTarget.stats.hp < initialHp);
253
+ });
254
+ });
255
+
256
+ describe('Integration', () => {
257
+ it('should handle complete physical attack flow', async () => {
258
+ let physicalSkillExecuted = false;
259
+ let hitExecuted = false;
260
+ mockOwner.executePhysicalSkill = async (target, skill) => {
261
+ physicalSkillExecuted = true;
262
+ await skill.executeOnHit(target);
263
+ };
264
+ let skillData = {
265
+ ...BaseSkillsFixtures.physicalAttackSkill,
266
+ owner: mockOwner,
267
+ target: mockTarget,
268
+ applyDirectDamage: true,
269
+ rangePropertyX: 'position/x',
270
+ rangePropertyY: 'position/y'
271
+ };
272
+ let skill = new PhysicalAttack(skillData);
273
+ skill.listenEvent(SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT, async () => {
274
+ hitExecuted = true;
275
+ }, 'hitListener', skill.getOwnerEventKey());
276
+ let initialHp = mockTarget.stats.hp;
277
+ await skill.runSkillLogic();
278
+ assert.strictEqual(physicalSkillExecuted, true);
279
+ assert.strictEqual(hitExecuted, true);
280
+ assert.ok(mockTarget.stats.hp < initialHp);
281
+ });
282
+
283
+ it('should calculate damage with attack and defense', async () => {
284
+ mockOwner.stats.atk = 50;
285
+ mockTarget.stats.def = 20;
286
+ mockOwner.executePhysicalSkill = async (target, skill) => {
287
+ await skill.executeOnHit(target);
288
+ };
289
+ let skillData = {
290
+ ...BaseSkillsFixtures.physicalAttackSkill,
291
+ owner: mockOwner,
292
+ target: mockTarget,
293
+ rangePropertyX: 'position/x',
294
+ rangePropertyY: 'position/y'
295
+ };
296
+ let skill = new PhysicalAttack(skillData);
297
+ let initialHp = mockTarget.stats.hp;
298
+ await skill.runSkillLogic();
299
+ let damage = initialHp - mockTarget.stats.hp;
300
+ assert.ok(damage > 0);
301
+ });
302
+
303
+ it('should handle critical damage', async () => {
304
+ mockOwner.executePhysicalSkill = async (target, skill) => {
305
+ await skill.executeOnHit(target);
306
+ };
307
+ let skillData = {
308
+ ...BaseSkillsFixtures.physicalAttackSkill,
309
+ owner: mockOwner,
310
+ target: mockTarget,
311
+ criticalChance: 100,
312
+ criticalMultiplier: 2,
313
+ applyDirectDamage: true,
314
+ rangePropertyX: 'position/x',
315
+ rangePropertyY: 'position/y'
316
+ };
317
+ let skill = new PhysicalAttack(skillData);
318
+ let initialHp = mockTarget.stats.hp;
319
+ await skill.runSkillLogic();
320
+ let damage = initialHp - mockTarget.stats.hp;
321
+ assert.strictEqual(damage, 30);
322
+ });
323
+
324
+ it('should broadcast damage event', async () => {
325
+ let eventFired = false;
326
+ mockOwner.executePhysicalSkill = async (target, skill) => {
327
+ await skill.executeOnHit(target);
328
+ };
329
+ let skillData = {
330
+ ...BaseSkillsFixtures.physicalAttackSkill,
331
+ owner: mockOwner,
332
+ target: mockTarget,
333
+ applyDirectDamage: true,
334
+ rangePropertyX: 'position/x',
335
+ rangePropertyY: 'position/y'
336
+ };
337
+ let skill = new PhysicalAttack(skillData);
338
+ skill.listenEvent(SkillsEvents.SKILL_ATTACK_APPLY_DAMAGE, async () => {
339
+ eventFired = true;
340
+ }, 'damageListener', skill.getOwnerEventKey());
341
+ await skill.runSkillLogic();
342
+ assert.strictEqual(eventFired, true);
343
+ });
344
+ });
345
+
346
+ describe('Edge Cases', () => {
347
+ it('should handle zero magnitude', () => {
348
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner, magnitude: 0};
349
+ let skill = new PhysicalAttack(skillData);
350
+ assert.strictEqual(skill.magnitude, 0);
351
+ assert.strictEqual(skill.isReady, true);
352
+ });
353
+
354
+ it('should handle zero object dimensions', () => {
355
+ let skillData = {
356
+ ...BaseSkillsFixtures.physicalAttackSkill,
357
+ owner: mockOwner,
358
+ objectWidth: 0,
359
+ objectHeight: 0
360
+ };
361
+ let skill = new PhysicalAttack(skillData);
362
+ assert.strictEqual(skill.objectWidth, 0);
363
+ assert.strictEqual(skill.objectHeight, 0);
364
+ assert.strictEqual(skill.isReady, true);
365
+ });
366
+
367
+ it('should handle large magnitude values', () => {
368
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner, magnitude: 999999};
369
+ let skill = new PhysicalAttack(skillData);
370
+ assert.strictEqual(skill.magnitude, 999999);
371
+ });
372
+
373
+ it('should handle decimal magnitude', () => {
374
+ let skillData = {...BaseSkillsFixtures.physicalAttackSkill, owner: mockOwner, magnitude: 100.5};
375
+ let skill = new PhysicalAttack(skillData);
376
+ assert.strictEqual(skill.magnitude, 100.5);
377
+ });
378
+
379
+ it('should handle null target in runSkillLogic', async () => {
380
+ let skillData = {
381
+ ...BaseSkillsFixtures.physicalAttackSkill,
382
+ owner: mockOwner,
383
+ target: null,
384
+ rangePropertyX: 'position/x',
385
+ rangePropertyY: 'position/y'
386
+ };
387
+ let skill = new PhysicalAttack(skillData);
388
+ await assert.rejects(async () => {
389
+ await skill.runSkillLogic();
390
+ });
391
+ });
392
+
393
+ it('should handle target without hp property', async () => {
394
+ mockOwner.executePhysicalSkill = async (target, skill) => {
395
+ await skill.executeOnHit(target);
396
+ };
397
+ let targetWithoutHp = {
398
+ id: 'test-target',
399
+ getPosition: () => ({x: 0, y: 0}),
400
+ position: {x: 0, y: 0},
401
+ stats: {}
402
+ };
403
+ let skillData = {
404
+ ...BaseSkillsFixtures.physicalAttackSkill,
405
+ owner: mockOwner,
406
+ target: targetWithoutHp,
407
+ applyDirectDamage: true,
408
+ rangePropertyX: 'position/x',
409
+ rangePropertyY: 'position/y'
410
+ };
411
+ let skill = new PhysicalAttack(skillData);
412
+ let result = await skill.runSkillLogic();
413
+ assert.strictEqual(result, false);
414
+ });
415
+ });
416
+
417
+ describe('Constructor - Validation Failure', () => {
418
+ it('should set isReady to false when validation fails', () => {
419
+ let invalidOwner = new MockOwner();
420
+ let skillData = {
421
+ ...BaseSkillsFixtures.physicalAttackSkill,
422
+ owner: invalidOwner,
423
+ magnitude: 100,
424
+ objectWidth: 10,
425
+ objectHeight: 10
426
+ };
427
+ let skill = new PhysicalAttack(skillData);
428
+ assert.strictEqual(skill.isReady, false);
429
+ });
430
+ });
431
+
432
+ describe('runSkillLogic - Range Validation Error', () => {
433
+ it('should handle when validateRange throws error', async () => {
434
+ mockOwner.executePhysicalSkill = async () => true;
435
+ let skillData = {
436
+ ...BaseSkillsFixtures.physicalAttackSkill,
437
+ owner: mockOwner,
438
+ target: mockTarget,
439
+ magnitude: 100,
440
+ objectWidth: 10,
441
+ objectHeight: 10,
442
+ rangePropertyX: 'position/x',
443
+ rangePropertyY: 'position/y'
444
+ };
445
+ let skill = new PhysicalAttack(skillData);
446
+ skill.validateRange = () => {
447
+ throw new Error('Range validation error');
448
+ };
449
+ await assert.rejects(
450
+ async () => await skill.runSkillLogic(),
451
+ Error
452
+ );
453
+ });
454
+ });
455
+
456
+ describe('executeOnHit - Target Validation', () => {
457
+ it('should validate target matches skill.target when validateTargetOnHit is true', async () => {
458
+ mockOwner.executePhysicalSkill = async (target, skill) => {
459
+ await skill.executeOnHit(target);
460
+ };
461
+ let differentTarget = new MockTarget();
462
+ differentTarget.id = 'different-target';
463
+ let skillData = {
464
+ ...BaseSkillsFixtures.physicalAttackSkill,
465
+ owner: mockOwner,
466
+ target: mockTarget,
467
+ magnitude: 100,
468
+ objectWidth: 10,
469
+ objectHeight: 10,
470
+ validateTargetOnHit: true,
471
+ rangePropertyX: 'position/x',
472
+ rangePropertyY: 'position/y'
473
+ };
474
+ let skill = new PhysicalAttack(skillData);
475
+ let result = await skill.runSkillLogic();
476
+ assert.ok(typeof result === 'boolean');
477
+ });
478
+ });
479
+
480
+ describe('executeOnHit - Invalid Target State', () => {
481
+ it('should handle when target state is invalid', async () => {
482
+ mockOwner.executePhysicalSkill = async (target, skill) => {
483
+ await skill.executeOnHit(null);
484
+ };
485
+ let skillData = {
486
+ ...BaseSkillsFixtures.physicalAttackSkill,
487
+ owner: mockOwner,
488
+ target: mockTarget,
489
+ magnitude: 100,
490
+ objectWidth: 10,
491
+ objectHeight: 10,
492
+ rangePropertyX: 'position/x',
493
+ rangePropertyY: 'position/y'
494
+ };
495
+ let skill = new PhysicalAttack(skillData);
496
+ await skill.runSkillLogic();
497
+ assert.ok(skill);
498
+ });
499
+ });
500
+
501
+ describe('runSkillLogic - Parent Returns False', () => {
502
+ it('should handle when parent runSkillLogic returns false', async () => {
503
+ mockOwner.executePhysicalSkill = async (target, skill) => {
504
+ await skill.executeOnHit(target);
505
+ };
506
+ let skillData = {
507
+ ...BaseSkillsFixtures.physicalAttackSkill,
508
+ owner: mockOwner,
509
+ target: mockTarget,
510
+ magnitude: 100,
511
+ objectWidth: 10,
512
+ objectHeight: 10,
513
+ range: 1000,
514
+ rangePropertyX: 'position/x',
515
+ rangePropertyY: 'position/y'
516
+ };
517
+ mockOwner.position = {x: 0, y: 0};
518
+ mockTarget.position = {x: 10000, y: 10000};
519
+ let skill = new PhysicalAttack(skillData);
520
+ let result = await skill.runSkillLogic();
521
+ assert.strictEqual(result, false);
522
+ });
523
+ });
524
+
525
+ describe('Event Parameters - Completeness', () => {
526
+ it('should fire event with all required parameters', async () => {
527
+ let eventParams = null;
528
+ mockOwner.executePhysicalSkill = async (target, skill) => {
529
+ await skill.executeOnHit(target);
530
+ };
531
+ let skillData = {
532
+ ...BaseSkillsFixtures.physicalAttackSkill,
533
+ owner: mockOwner,
534
+ target: mockTarget,
535
+ magnitude: 100,
536
+ objectWidth: 10,
537
+ objectHeight: 10,
538
+ rangePropertyX: 'position/x',
539
+ rangePropertyY: 'position/y'
540
+ };
541
+ let skill = new PhysicalAttack(skillData);
542
+ skill.listenEvent(SkillsEvents.SKILL_PHYSICAL_ATTACK_HIT, (...args) => {
543
+ eventParams = args;
544
+ }, 'test-listener', skill.getOwnerEventKey());
545
+ await skill.runSkillLogic();
546
+ assert.ok(eventParams);
547
+ });
548
+ });
549
+
550
+ describe('executeOnHit - Null Target Handling', () => {
551
+ it('should handle null target in executeOnHit', async () => {
552
+ let skillData = {
553
+ ...BaseSkillsFixtures.physicalAttackSkill,
554
+ owner: mockOwner,
555
+ magnitude: 100,
556
+ objectWidth: 10,
557
+ objectHeight: 10
558
+ };
559
+ let skill = new PhysicalAttack(skillData);
560
+ await skill.executeOnHit(null);
561
+ assert.ok(skill);
562
+ });
563
+ });
564
+ });