@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.
- package/.claude/architecture.md +472 -0
- package/.claude/class-hierarchy.md +982 -0
- package/.claude/event-system-architecture.md +475 -0
- package/.claude/level-progression.md +1259 -0
- package/.claude/skill-execution-flow.md +979 -0
- package/.claude/testing-guide.md +356 -0
- package/.claude/testing-patterns.md +1096 -0
- package/CLAUDE.md +164 -29
- package/lib/class-path.js +13 -10
- package/lib/client/receiver.js +1 -3
- package/lib/levels-set.js +24 -17
- package/lib/server/sender.js +1 -1
- package/lib/skill.js +19 -16
- package/lib/types/attack.js +28 -11
- package/lib/types/effect.js +10 -4
- package/lib/types/physical-attack.js +2 -2
- package/lib/types/physical-effect.js +2 -2
- package/lib/types/physical-properties-validator.js +1 -1
- package/lib/types/physical-skill-runner.js +5 -5
- package/package.json +9 -3
- package/tests/fixtures/levels/base-levels.js +89 -0
- package/tests/fixtures/mocks/mock-client.js +44 -0
- package/tests/fixtures/mocks/mock-owner.js +60 -0
- package/tests/fixtures/mocks/mock-target.js +50 -0
- package/tests/fixtures/skills/base-skills.js +80 -0
- package/tests/run-tests.js +88 -0
- package/tests/unit/client/test-receiver.js +249 -0
- package/tests/unit/server/test-sender.js +527 -0
- package/tests/unit/test-class-path.js +1239 -0
- package/tests/unit/test-level.js +176 -0
- package/tests/unit/test-levels-set.js +1227 -0
- package/tests/unit/test-server.js +266 -0
- package/tests/unit/test-skill.js +1302 -0
- package/tests/unit/types/test-attack.js +1195 -0
- package/tests/unit/types/test-effect.js +587 -0
- package/tests/unit/types/test-physical-attack.js +564 -0
- package/tests/unit/types/test-physical-effect.js +769 -0
- package/tests/unit/types/test-physical-properties-validator.js +203 -0
- package/tests/unit/types/test-physical-skill-runner.js +348 -0
- package/tests/utils/test-helpers.js +122 -0
|
@@ -0,0 +1,1302 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - Skill Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it, beforeEach, afterEach } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const Skill = require('../../lib/skill');
|
|
10
|
+
const SkillsConst = require('../../lib/constants');
|
|
11
|
+
const SkillsEvents = require('../../lib/skills-events');
|
|
12
|
+
const { Condition, Modifier, ModifierConst } = require('@reldens/modifiers');
|
|
13
|
+
const { TestHelpers } = require('../utils/test-helpers');
|
|
14
|
+
const { MockOwner } = require('../fixtures/mocks/mock-owner');
|
|
15
|
+
const { MockTarget } = require('../fixtures/mocks/mock-target');
|
|
16
|
+
const { BaseSkillsFixtures } = require('../fixtures/skills/base-skills');
|
|
17
|
+
|
|
18
|
+
describe('Skill', () => {
|
|
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 basic properties', () => {
|
|
34
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
35
|
+
let skill = new Skill(skillData);
|
|
36
|
+
assert.strictEqual(skill.key, 'test-basic-skill');
|
|
37
|
+
assert.strictEqual(skill.owner, mockOwner);
|
|
38
|
+
assert.strictEqual(skill.type, SkillsConst.SKILL.TYPE.BASE);
|
|
39
|
+
assert.strictEqual(skill.isReady, true);
|
|
40
|
+
assert.strictEqual(skill.canActivate, true);
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
it('should set isReady to false when key is missing', () => {
|
|
44
|
+
let skill = new Skill({owner: mockOwner});
|
|
45
|
+
assert.strictEqual(skill.isReady, false);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
it('should set isReady to false when owner is missing', () => {
|
|
49
|
+
let skill = new Skill({key: 'test-skill', owner: {}});
|
|
50
|
+
assert.strictEqual(skill.isReady, false);
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
it('should set isReady to false when owner has no getPosition method', () => {
|
|
54
|
+
let invalidOwner = {id: 'test'};
|
|
55
|
+
let skill = new Skill({key: 'test-skill', owner: invalidOwner});
|
|
56
|
+
assert.strictEqual(skill.isReady, false);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
it('should initialize with default values', () => {
|
|
60
|
+
let skillData = {key: 'test', owner: mockOwner};
|
|
61
|
+
let skill = new Skill(skillData);
|
|
62
|
+
assert.strictEqual(skill.skillDelay, 0);
|
|
63
|
+
assert.strictEqual(skill.castTime, 0);
|
|
64
|
+
assert.strictEqual(skill.range, 0);
|
|
65
|
+
assert.strictEqual(skill.usesLimit, 0);
|
|
66
|
+
assert.strictEqual(skill.uses, 0);
|
|
67
|
+
assert.strictEqual(skill.allowSelfTarget, false);
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
it('should handle custom properties', () => {
|
|
71
|
+
let skillData = {
|
|
72
|
+
key: 'custom-skill',
|
|
73
|
+
owner: mockOwner,
|
|
74
|
+
skillDelay: 1000,
|
|
75
|
+
castTime: 500,
|
|
76
|
+
range: 50,
|
|
77
|
+
usesLimit: 5,
|
|
78
|
+
criticalChance: 20,
|
|
79
|
+
criticalMultiplier: 1.5
|
|
80
|
+
};
|
|
81
|
+
let skill = new Skill(skillData);
|
|
82
|
+
assert.strictEqual(skill.skillDelay, 1000);
|
|
83
|
+
assert.strictEqual(skill.castTime, 500);
|
|
84
|
+
assert.strictEqual(skill.range, 50);
|
|
85
|
+
assert.strictEqual(skill.usesLimit, 5);
|
|
86
|
+
assert.strictEqual(skill.criticalChance, 20);
|
|
87
|
+
assert.strictEqual(skill.criticalMultiplier, 1.5);
|
|
88
|
+
});
|
|
89
|
+
});
|
|
90
|
+
|
|
91
|
+
describe('validate', () => {
|
|
92
|
+
it('should return false when skill is not ready', () => {
|
|
93
|
+
let skill = new Skill({owner: mockOwner});
|
|
94
|
+
let result = skill.validate();
|
|
95
|
+
assert.strictEqual(result, false);
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
it('should return false when canActivate is false', () => {
|
|
99
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
100
|
+
let skill = new Skill(skillData);
|
|
101
|
+
skill.canActivate = false;
|
|
102
|
+
let result = skill.validate();
|
|
103
|
+
assert.strictEqual(result, false);
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
it('should return false when owner is casting', () => {
|
|
107
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
108
|
+
let skill = new Skill(skillData);
|
|
109
|
+
mockOwner.isCasting = true;
|
|
110
|
+
let result = skill.validate();
|
|
111
|
+
assert.strictEqual(result, false);
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
it('should return false when uses limit is reached', () => {
|
|
115
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner, usesLimit: 3};
|
|
116
|
+
let skill = new Skill(skillData);
|
|
117
|
+
skill.uses = 3;
|
|
118
|
+
let result = skill.validate();
|
|
119
|
+
assert.strictEqual(result, false);
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
it('should return true for valid skill', () => {
|
|
123
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
124
|
+
let skill = new Skill(skillData);
|
|
125
|
+
let result = skill.validate();
|
|
126
|
+
assert.strictEqual(result, true);
|
|
127
|
+
});
|
|
128
|
+
|
|
129
|
+
it('should set canActivate to false when skillDelay is greater than 0', () => {
|
|
130
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner, skillDelay: 1000};
|
|
131
|
+
let skill = new Skill(skillData);
|
|
132
|
+
skill.validate();
|
|
133
|
+
assert.strictEqual(skill.canActivate, false);
|
|
134
|
+
});
|
|
135
|
+
});
|
|
136
|
+
|
|
137
|
+
describe('validateConditions', () => {
|
|
138
|
+
it('should return true when no conditions are set', () => {
|
|
139
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
140
|
+
let skill = new Skill(skillData);
|
|
141
|
+
let result = skill.validateConditions();
|
|
142
|
+
assert.strictEqual(result, true);
|
|
143
|
+
});
|
|
144
|
+
|
|
145
|
+
it('should return false when condition is not valid', () => {
|
|
146
|
+
let condition = new Condition({
|
|
147
|
+
key: 'hp-check',
|
|
148
|
+
propertyKey: 'stats/hp',
|
|
149
|
+
conditional: 'gt',
|
|
150
|
+
value: 200
|
|
151
|
+
});
|
|
152
|
+
let skillData = {
|
|
153
|
+
...BaseSkillsFixtures.basicSkill,
|
|
154
|
+
owner: mockOwner,
|
|
155
|
+
ownerConditions: [condition]
|
|
156
|
+
};
|
|
157
|
+
let skill = new Skill(skillData);
|
|
158
|
+
let result = skill.validateConditions();
|
|
159
|
+
assert.strictEqual(result, false);
|
|
160
|
+
});
|
|
161
|
+
|
|
162
|
+
it('should return true when all conditions are valid', () => {
|
|
163
|
+
let condition = new Condition({
|
|
164
|
+
key: 'hp-check',
|
|
165
|
+
propertyKey: 'stats/hp',
|
|
166
|
+
conditional: 'gt',
|
|
167
|
+
value: 50
|
|
168
|
+
});
|
|
169
|
+
let skillData = {
|
|
170
|
+
...BaseSkillsFixtures.basicSkill,
|
|
171
|
+
owner: mockOwner,
|
|
172
|
+
ownerConditions: [condition]
|
|
173
|
+
};
|
|
174
|
+
let skill = new Skill(skillData);
|
|
175
|
+
let result = skill.validateConditions();
|
|
176
|
+
assert.strictEqual(result, true);
|
|
177
|
+
});
|
|
178
|
+
});
|
|
179
|
+
|
|
180
|
+
describe('isInRange', () => {
|
|
181
|
+
it('should return true for infinite range (0)', () => {
|
|
182
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner, range: 0};
|
|
183
|
+
let skill = new Skill(skillData);
|
|
184
|
+
let result = skill.isInRange(
|
|
185
|
+
{x: 0, y: 0},
|
|
186
|
+
{x: 1000, y: 1000}
|
|
187
|
+
);
|
|
188
|
+
assert.strictEqual(result, true);
|
|
189
|
+
});
|
|
190
|
+
|
|
191
|
+
it('should return true when target is in range', () => {
|
|
192
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner, range: 50};
|
|
193
|
+
let skill = new Skill(skillData);
|
|
194
|
+
let result = skill.isInRange(
|
|
195
|
+
{x: 100, y: 100},
|
|
196
|
+
{x: 110, y: 110}
|
|
197
|
+
);
|
|
198
|
+
assert.strictEqual(result, true);
|
|
199
|
+
});
|
|
200
|
+
|
|
201
|
+
it('should return false when target is out of range', () => {
|
|
202
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner, range: 10};
|
|
203
|
+
let skill = new Skill(skillData);
|
|
204
|
+
let result = skill.isInRange(
|
|
205
|
+
{x: 0, y: 0},
|
|
206
|
+
{x: 100, y: 100}
|
|
207
|
+
);
|
|
208
|
+
assert.strictEqual(result, false);
|
|
209
|
+
});
|
|
210
|
+
});
|
|
211
|
+
|
|
212
|
+
describe('execute', () => {
|
|
213
|
+
it('should return false when skill is not ready', async () => {
|
|
214
|
+
let skill = new Skill({owner: mockOwner});
|
|
215
|
+
let result = await skill.execute(mockTarget);
|
|
216
|
+
assert.strictEqual(result, false);
|
|
217
|
+
});
|
|
218
|
+
|
|
219
|
+
it('should return false when target is undefined', async () => {
|
|
220
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
221
|
+
let skill = new Skill(skillData);
|
|
222
|
+
let result = await skill.execute();
|
|
223
|
+
assert.strictEqual(result, false);
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
it('should execute skill logic successfully', async () => {
|
|
227
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
228
|
+
let skill = new Skill(skillData);
|
|
229
|
+
let result = await skill.execute(mockTarget);
|
|
230
|
+
assert.strictEqual(result, true);
|
|
231
|
+
assert.strictEqual(skill.uses, 1);
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
it('should increment uses counter', async () => {
|
|
235
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
236
|
+
let skill = new Skill(skillData);
|
|
237
|
+
await skill.execute(mockTarget);
|
|
238
|
+
assert.strictEqual(skill.uses, 1);
|
|
239
|
+
await skill.execute(mockTarget);
|
|
240
|
+
assert.strictEqual(skill.uses, 2);
|
|
241
|
+
});
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
describe('isCritical', () => {
|
|
245
|
+
it('should return false when criticalChance is 0', () => {
|
|
246
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner, criticalChance: 0};
|
|
247
|
+
let skill = new Skill(skillData);
|
|
248
|
+
let result = skill.isCritical();
|
|
249
|
+
assert.strictEqual(result, false);
|
|
250
|
+
});
|
|
251
|
+
|
|
252
|
+
it('should return boolean value when criticalChance is greater than 0', () => {
|
|
253
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner, criticalChance: 50};
|
|
254
|
+
let skill = new Skill(skillData);
|
|
255
|
+
let result = skill.isCritical();
|
|
256
|
+
assert.strictEqual(typeof result, 'boolean');
|
|
257
|
+
});
|
|
258
|
+
});
|
|
259
|
+
|
|
260
|
+
describe('applyCriticalValue', () => {
|
|
261
|
+
it('should return normal value when not critical', () => {
|
|
262
|
+
let skillData = {
|
|
263
|
+
...BaseSkillsFixtures.basicSkill,
|
|
264
|
+
owner: mockOwner,
|
|
265
|
+
criticalChance: 0
|
|
266
|
+
};
|
|
267
|
+
let skill = new Skill(skillData);
|
|
268
|
+
let result = skill.applyCriticalValue(100);
|
|
269
|
+
assert.strictEqual(result, 100);
|
|
270
|
+
});
|
|
271
|
+
|
|
272
|
+
it('should apply criticalMultiplier when critical', () => {
|
|
273
|
+
let skillData = {
|
|
274
|
+
...BaseSkillsFixtures.basicSkill,
|
|
275
|
+
owner: mockOwner,
|
|
276
|
+
criticalChance: 100,
|
|
277
|
+
criticalMultiplier: 2
|
|
278
|
+
};
|
|
279
|
+
let skill = new Skill(skillData);
|
|
280
|
+
let originalIsCritical = skill.isCritical.bind(skill);
|
|
281
|
+
skill.isCritical = () => true;
|
|
282
|
+
let result = skill.applyCriticalValue(100);
|
|
283
|
+
assert.strictEqual(result, 200);
|
|
284
|
+
skill.isCritical = originalIsCritical;
|
|
285
|
+
});
|
|
286
|
+
|
|
287
|
+
it('should apply criticalFixedValue when critical', () => {
|
|
288
|
+
let skillData = {
|
|
289
|
+
...BaseSkillsFixtures.basicSkill,
|
|
290
|
+
owner: mockOwner,
|
|
291
|
+
criticalChance: 100,
|
|
292
|
+
criticalMultiplier: 1,
|
|
293
|
+
criticalFixedValue: 50
|
|
294
|
+
};
|
|
295
|
+
let skill = new Skill(skillData);
|
|
296
|
+
skill.isCritical = () => true;
|
|
297
|
+
let result = skill.applyCriticalValue(100);
|
|
298
|
+
assert.strictEqual(result, 150);
|
|
299
|
+
});
|
|
300
|
+
});
|
|
301
|
+
|
|
302
|
+
describe('getOwnerId', () => {
|
|
303
|
+
it('should return owner id', () => {
|
|
304
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
305
|
+
let skill = new Skill(skillData);
|
|
306
|
+
assert.strictEqual(skill.getOwnerId(), 'mock-owner-1');
|
|
307
|
+
});
|
|
308
|
+
|
|
309
|
+
it('should use custom ownerIdProperty', () => {
|
|
310
|
+
let customOwner = {customId: 'custom-123', getPosition: () => ({x: 0, y: 0})};
|
|
311
|
+
let skillData = {
|
|
312
|
+
key: 'test',
|
|
313
|
+
owner: customOwner,
|
|
314
|
+
ownerIdProperty: 'customId'
|
|
315
|
+
};
|
|
316
|
+
let skill = new Skill(skillData);
|
|
317
|
+
assert.strictEqual(skill.getOwnerId(), 'custom-123');
|
|
318
|
+
});
|
|
319
|
+
});
|
|
320
|
+
|
|
321
|
+
describe('Events', () => {
|
|
322
|
+
it('should fire SKILL_BEFORE_EXECUTE event', async () => {
|
|
323
|
+
let eventFired = false;
|
|
324
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
325
|
+
let skill = new Skill(skillData);
|
|
326
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, () => {
|
|
327
|
+
eventFired = true;
|
|
328
|
+
}, 'test-listener');
|
|
329
|
+
await skill.execute(mockTarget);
|
|
330
|
+
assert.strictEqual(eventFired, true);
|
|
331
|
+
});
|
|
332
|
+
|
|
333
|
+
it('should fire SKILL_AFTER_EXECUTE event', async () => {
|
|
334
|
+
let eventFired = false;
|
|
335
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
336
|
+
let skill = new Skill(skillData);
|
|
337
|
+
skill.listenEvent(SkillsEvents.SKILL_AFTER_EXECUTE, () => {
|
|
338
|
+
eventFired = true;
|
|
339
|
+
}, 'test-listener-after');
|
|
340
|
+
await skill.execute(mockTarget);
|
|
341
|
+
assert.strictEqual(eventFired, true);
|
|
342
|
+
});
|
|
343
|
+
|
|
344
|
+
it('should fire event with masterKey parameter', async () => {
|
|
345
|
+
let eventFired = false;
|
|
346
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
347
|
+
let skill = new Skill(skillData);
|
|
348
|
+
let masterKey = skill.getOwnerEventKey();
|
|
349
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, () => {
|
|
350
|
+
eventFired = true;
|
|
351
|
+
}, 'sub-key', masterKey);
|
|
352
|
+
await skill.execute(mockTarget);
|
|
353
|
+
assert.strictEqual(eventFired, true);
|
|
354
|
+
});
|
|
355
|
+
|
|
356
|
+
it('should fire event without any keys', async () => {
|
|
357
|
+
let eventFired = false;
|
|
358
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
359
|
+
let skill = new Skill(skillData);
|
|
360
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, () => {
|
|
361
|
+
eventFired = true;
|
|
362
|
+
});
|
|
363
|
+
await skill.execute(mockTarget);
|
|
364
|
+
assert.strictEqual(eventFired, true);
|
|
365
|
+
});
|
|
366
|
+
|
|
367
|
+
it('should handle multiple listeners on same event', async () => {
|
|
368
|
+
let count = 0;
|
|
369
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
370
|
+
let skill = new Skill(skillData);
|
|
371
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, () => { count++; }, 'key1');
|
|
372
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, () => { count++; }, 'key2');
|
|
373
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, () => { count++; }, 'key3');
|
|
374
|
+
await skill.execute(mockTarget);
|
|
375
|
+
assert.strictEqual(count, 3);
|
|
376
|
+
});
|
|
377
|
+
|
|
378
|
+
it('should pass correct arguments to event listeners', async () => {
|
|
379
|
+
let receivedSkill = null;
|
|
380
|
+
let receivedTarget = null;
|
|
381
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
382
|
+
let skill = new Skill(skillData);
|
|
383
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, (s, t) => {
|
|
384
|
+
receivedSkill = s;
|
|
385
|
+
receivedTarget = t;
|
|
386
|
+
}, 'arg-test');
|
|
387
|
+
await skill.execute(mockTarget);
|
|
388
|
+
assert.strictEqual(receivedSkill, skill);
|
|
389
|
+
assert.strictEqual(receivedTarget, mockTarget);
|
|
390
|
+
});
|
|
391
|
+
|
|
392
|
+
it('should fire VALIDATE_BEFORE event', () => {
|
|
393
|
+
let eventFired = false;
|
|
394
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
395
|
+
let skill = new Skill(skillData);
|
|
396
|
+
skill.listenEvent(SkillsEvents.VALIDATE_BEFORE, () => {
|
|
397
|
+
eventFired = true;
|
|
398
|
+
}, 'validate-before-test');
|
|
399
|
+
skill.validate();
|
|
400
|
+
assert.strictEqual(eventFired, true);
|
|
401
|
+
});
|
|
402
|
+
|
|
403
|
+
it('should fire VALIDATE_SUCCESS event', () => {
|
|
404
|
+
let eventFired = false;
|
|
405
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
406
|
+
let skill = new Skill(skillData);
|
|
407
|
+
skill.listenEvent(SkillsEvents.VALIDATE_SUCCESS, () => {
|
|
408
|
+
eventFired = true;
|
|
409
|
+
}, 'validate-success-test');
|
|
410
|
+
skill.validate();
|
|
411
|
+
assert.strictEqual(eventFired, true);
|
|
412
|
+
});
|
|
413
|
+
|
|
414
|
+
it('should fire VALIDATE_FAIL event when condition fails', () => {
|
|
415
|
+
let eventFired = false;
|
|
416
|
+
let failedCondition = null;
|
|
417
|
+
let condition = new Condition({
|
|
418
|
+
key: 'impossible',
|
|
419
|
+
propertyKey: 'stats/hp',
|
|
420
|
+
conditional: 'gt',
|
|
421
|
+
value: 999
|
|
422
|
+
});
|
|
423
|
+
let skillData = {
|
|
424
|
+
...BaseSkillsFixtures.basicSkill,
|
|
425
|
+
owner: mockOwner,
|
|
426
|
+
ownerConditions: [condition]
|
|
427
|
+
};
|
|
428
|
+
let skill = new Skill(skillData);
|
|
429
|
+
skill.listenEvent(SkillsEvents.VALIDATE_FAIL, (s, c) => {
|
|
430
|
+
eventFired = true;
|
|
431
|
+
failedCondition = c;
|
|
432
|
+
}, 'validate-fail-test');
|
|
433
|
+
skill.validate();
|
|
434
|
+
assert.strictEqual(eventFired, true);
|
|
435
|
+
assert.strictEqual(failedCondition, condition);
|
|
436
|
+
});
|
|
437
|
+
|
|
438
|
+
it('should fire all execution events in correct order', async () => {
|
|
439
|
+
let eventOrder = [];
|
|
440
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
441
|
+
let skill = new Skill(skillData);
|
|
442
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_EXECUTE, () => {
|
|
443
|
+
eventOrder.push('BEFORE_EXECUTE');
|
|
444
|
+
}, 'order1');
|
|
445
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_RUN_LOGIC, () => {
|
|
446
|
+
eventOrder.push('BEFORE_RUN_LOGIC');
|
|
447
|
+
}, 'order2');
|
|
448
|
+
skill.listenEvent(SkillsEvents.SKILL_AFTER_RUN_LOGIC, () => {
|
|
449
|
+
eventOrder.push('AFTER_RUN_LOGIC');
|
|
450
|
+
}, 'order3');
|
|
451
|
+
skill.listenEvent(SkillsEvents.SKILL_AFTER_EXECUTE, () => {
|
|
452
|
+
eventOrder.push('AFTER_EXECUTE');
|
|
453
|
+
}, 'order4');
|
|
454
|
+
await skill.execute(mockTarget);
|
|
455
|
+
assert.deepStrictEqual(eventOrder, [
|
|
456
|
+
'BEFORE_EXECUTE',
|
|
457
|
+
'BEFORE_RUN_LOGIC',
|
|
458
|
+
'AFTER_RUN_LOGIC',
|
|
459
|
+
'AFTER_EXECUTE'
|
|
460
|
+
]);
|
|
461
|
+
});
|
|
462
|
+
});
|
|
463
|
+
|
|
464
|
+
describe('Error Conditions - validateConditions', () => {
|
|
465
|
+
it('should return false with invalid condition type', () => {
|
|
466
|
+
let skillData = {
|
|
467
|
+
...BaseSkillsFixtures.basicSkill,
|
|
468
|
+
owner: mockOwner,
|
|
469
|
+
ownerConditions: [{not: 'a condition'}]
|
|
470
|
+
};
|
|
471
|
+
let skill = new Skill(skillData);
|
|
472
|
+
let result = skill.validateConditions();
|
|
473
|
+
assert.strictEqual(result, false);
|
|
474
|
+
});
|
|
475
|
+
|
|
476
|
+
it('should return false with null condition', () => {
|
|
477
|
+
let skillData = {
|
|
478
|
+
...BaseSkillsFixtures.basicSkill,
|
|
479
|
+
owner: mockOwner,
|
|
480
|
+
ownerConditions: [null]
|
|
481
|
+
};
|
|
482
|
+
let skill = new Skill(skillData);
|
|
483
|
+
let result = skill.validateConditions();
|
|
484
|
+
assert.strictEqual(result, false);
|
|
485
|
+
});
|
|
486
|
+
|
|
487
|
+
it('should return false with undefined in conditions array', () => {
|
|
488
|
+
let skillData = {
|
|
489
|
+
...BaseSkillsFixtures.basicSkill,
|
|
490
|
+
owner: mockOwner,
|
|
491
|
+
ownerConditions: [undefined]
|
|
492
|
+
};
|
|
493
|
+
let skill = new Skill(skillData);
|
|
494
|
+
let result = skill.validateConditions();
|
|
495
|
+
assert.strictEqual(result, false);
|
|
496
|
+
});
|
|
497
|
+
|
|
498
|
+
it('should handle mixed valid and invalid conditions', () => {
|
|
499
|
+
let validCondition = new Condition({
|
|
500
|
+
key: 'valid',
|
|
501
|
+
propertyKey: 'stats/hp',
|
|
502
|
+
conditional: 'gt',
|
|
503
|
+
value: 0
|
|
504
|
+
});
|
|
505
|
+
let skillData = {
|
|
506
|
+
...BaseSkillsFixtures.basicSkill,
|
|
507
|
+
owner: mockOwner,
|
|
508
|
+
ownerConditions: [validCondition, {invalid: true}]
|
|
509
|
+
};
|
|
510
|
+
let skill = new Skill(skillData);
|
|
511
|
+
let result = skill.validateConditions();
|
|
512
|
+
assert.strictEqual(result, false);
|
|
513
|
+
});
|
|
514
|
+
});
|
|
515
|
+
|
|
516
|
+
describe('Edge Cases - Range Validation', () => {
|
|
517
|
+
it('should handle negative range values', () => {
|
|
518
|
+
let skillData = {
|
|
519
|
+
...BaseSkillsFixtures.basicSkill,
|
|
520
|
+
owner: mockOwner,
|
|
521
|
+
range: -50
|
|
522
|
+
};
|
|
523
|
+
let skill = new Skill(skillData);
|
|
524
|
+
let result = skill.isInRange({x: 0, y: 0}, {x: 100, y: 100});
|
|
525
|
+
assert.strictEqual(typeof result, 'boolean');
|
|
526
|
+
});
|
|
527
|
+
|
|
528
|
+
it('should handle exact range boundary', () => {
|
|
529
|
+
let skillData = {
|
|
530
|
+
...BaseSkillsFixtures.basicSkill,
|
|
531
|
+
owner: mockOwner,
|
|
532
|
+
range: 10
|
|
533
|
+
};
|
|
534
|
+
let skill = new Skill(skillData);
|
|
535
|
+
let result = skill.isInRange({x: 0, y: 0}, {x: 10, y: 0});
|
|
536
|
+
assert.strictEqual(typeof result, 'boolean');
|
|
537
|
+
});
|
|
538
|
+
|
|
539
|
+
it('should handle decimal positions', () => {
|
|
540
|
+
let skillData = {
|
|
541
|
+
...BaseSkillsFixtures.basicSkill,
|
|
542
|
+
owner: mockOwner,
|
|
543
|
+
range: 50
|
|
544
|
+
};
|
|
545
|
+
let skill = new Skill(skillData);
|
|
546
|
+
let result = skill.isInRange({x: 0.5, y: 0.5}, {x: 10.7, y: 10.3});
|
|
547
|
+
assert.strictEqual(typeof result, 'boolean');
|
|
548
|
+
});
|
|
549
|
+
|
|
550
|
+
it('should validateRange return false with missing range properties', () => {
|
|
551
|
+
let skillData = {
|
|
552
|
+
...BaseSkillsFixtures.basicSkill,
|
|
553
|
+
owner: mockOwner,
|
|
554
|
+
range: 50
|
|
555
|
+
};
|
|
556
|
+
let skill = new Skill(skillData);
|
|
557
|
+
let result = skill.validateRange(mockTarget);
|
|
558
|
+
assert.strictEqual(result, false);
|
|
559
|
+
});
|
|
560
|
+
|
|
561
|
+
it('should validateRange work with valid range properties', () => {
|
|
562
|
+
let skillData = {
|
|
563
|
+
...BaseSkillsFixtures.basicSkill,
|
|
564
|
+
owner: mockOwner,
|
|
565
|
+
range: 50,
|
|
566
|
+
rangePropertyX: 'position/x',
|
|
567
|
+
rangePropertyY: 'position/y'
|
|
568
|
+
};
|
|
569
|
+
let skill = new Skill(skillData);
|
|
570
|
+
let result = skill.validateRange(mockTarget);
|
|
571
|
+
assert.strictEqual(typeof result, 'boolean');
|
|
572
|
+
});
|
|
573
|
+
});
|
|
574
|
+
|
|
575
|
+
describe('Edge Cases - Critical Hits', () => {
|
|
576
|
+
it('should handle 100% critical chance', () => {
|
|
577
|
+
let skillData = {
|
|
578
|
+
...BaseSkillsFixtures.basicSkill,
|
|
579
|
+
owner: mockOwner,
|
|
580
|
+
criticalChance: 100
|
|
581
|
+
};
|
|
582
|
+
let skill = new Skill(skillData);
|
|
583
|
+
let criticalHits = 0;
|
|
584
|
+
for(let i = 0; i < 10; i++){
|
|
585
|
+
if(skill.isCritical()){
|
|
586
|
+
criticalHits++;
|
|
587
|
+
}
|
|
588
|
+
}
|
|
589
|
+
assert.ok(criticalHits > 0);
|
|
590
|
+
});
|
|
591
|
+
|
|
592
|
+
it('should handle negative critical chance', () => {
|
|
593
|
+
let skillData = {
|
|
594
|
+
...BaseSkillsFixtures.basicSkill,
|
|
595
|
+
owner: mockOwner,
|
|
596
|
+
criticalChance: -50
|
|
597
|
+
};
|
|
598
|
+
let skill = new Skill(skillData);
|
|
599
|
+
let result = skill.isCritical();
|
|
600
|
+
assert.strictEqual(result, false);
|
|
601
|
+
});
|
|
602
|
+
|
|
603
|
+
it('should apply negative critical multiplier', () => {
|
|
604
|
+
let skillData = {
|
|
605
|
+
...BaseSkillsFixtures.basicSkill,
|
|
606
|
+
owner: mockOwner,
|
|
607
|
+
criticalChance: 100,
|
|
608
|
+
criticalMultiplier: -2
|
|
609
|
+
};
|
|
610
|
+
let skill = new Skill(skillData);
|
|
611
|
+
skill.isCritical = () => true;
|
|
612
|
+
let result = skill.applyCriticalValue(100);
|
|
613
|
+
assert.strictEqual(result, -200);
|
|
614
|
+
});
|
|
615
|
+
|
|
616
|
+
it('should apply zero critical multiplier', () => {
|
|
617
|
+
let skillData = {
|
|
618
|
+
...BaseSkillsFixtures.basicSkill,
|
|
619
|
+
owner: mockOwner,
|
|
620
|
+
criticalChance: 100,
|
|
621
|
+
criticalMultiplier: 0
|
|
622
|
+
};
|
|
623
|
+
let skill = new Skill(skillData);
|
|
624
|
+
skill.isCritical = () => true;
|
|
625
|
+
let result = skill.applyCriticalValue(100);
|
|
626
|
+
assert.strictEqual(result, 0);
|
|
627
|
+
});
|
|
628
|
+
|
|
629
|
+
it('should handle both multiplier and fixed value', () => {
|
|
630
|
+
let skillData = {
|
|
631
|
+
...BaseSkillsFixtures.basicSkill,
|
|
632
|
+
owner: mockOwner,
|
|
633
|
+
criticalChance: 100,
|
|
634
|
+
criticalMultiplier: 2,
|
|
635
|
+
criticalFixedValue: 50
|
|
636
|
+
};
|
|
637
|
+
let skill = new Skill(skillData);
|
|
638
|
+
skill.isCritical = () => true;
|
|
639
|
+
let result = skill.applyCriticalValue(100);
|
|
640
|
+
assert.strictEqual(result, 250);
|
|
641
|
+
});
|
|
642
|
+
|
|
643
|
+
it('should getCriticalDiff return correct difference', () => {
|
|
644
|
+
let skillData = {
|
|
645
|
+
...BaseSkillsFixtures.basicSkill,
|
|
646
|
+
owner: mockOwner,
|
|
647
|
+
criticalChance: 100,
|
|
648
|
+
criticalMultiplier: 2
|
|
649
|
+
};
|
|
650
|
+
let skill = new Skill(skillData);
|
|
651
|
+
skill.isCritical = () => true;
|
|
652
|
+
let diff = skill.getCriticalDiff(100);
|
|
653
|
+
assert.strictEqual(diff, 100);
|
|
654
|
+
});
|
|
655
|
+
});
|
|
656
|
+
|
|
657
|
+
describe('Edge Cases - Uses and Limits', () => {
|
|
658
|
+
it('should handle uses at exactly limit', () => {
|
|
659
|
+
let skillData = {
|
|
660
|
+
...BaseSkillsFixtures.basicSkill,
|
|
661
|
+
owner: mockOwner,
|
|
662
|
+
usesLimit: 5
|
|
663
|
+
};
|
|
664
|
+
let skill = new Skill(skillData);
|
|
665
|
+
skill.uses = 5;
|
|
666
|
+
let result = skill.validate();
|
|
667
|
+
assert.strictEqual(result, false);
|
|
668
|
+
});
|
|
669
|
+
|
|
670
|
+
it('should handle uses beyond limit', () => {
|
|
671
|
+
let skillData = {
|
|
672
|
+
...BaseSkillsFixtures.basicSkill,
|
|
673
|
+
owner: mockOwner,
|
|
674
|
+
usesLimit: 5
|
|
675
|
+
};
|
|
676
|
+
let skill = new Skill(skillData);
|
|
677
|
+
skill.uses = 10;
|
|
678
|
+
let result = skill.validate();
|
|
679
|
+
assert.strictEqual(result, false);
|
|
680
|
+
});
|
|
681
|
+
|
|
682
|
+
it('should increment uses on each execution', async () => {
|
|
683
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
684
|
+
let skill = new Skill(skillData);
|
|
685
|
+
assert.strictEqual(skill.uses, 0);
|
|
686
|
+
await skill.execute(mockTarget);
|
|
687
|
+
assert.strictEqual(skill.uses, 1);
|
|
688
|
+
await skill.execute(mockTarget);
|
|
689
|
+
assert.strictEqual(skill.uses, 2);
|
|
690
|
+
await skill.execute(mockTarget);
|
|
691
|
+
assert.strictEqual(skill.uses, 3);
|
|
692
|
+
});
|
|
693
|
+
|
|
694
|
+
it('should handle negative usesLimit', () => {
|
|
695
|
+
let skillData = {
|
|
696
|
+
...BaseSkillsFixtures.basicSkill,
|
|
697
|
+
owner: mockOwner,
|
|
698
|
+
usesLimit: -1
|
|
699
|
+
};
|
|
700
|
+
let skill = new Skill(skillData);
|
|
701
|
+
let result = skill.validate();
|
|
702
|
+
assert.strictEqual(result, true);
|
|
703
|
+
});
|
|
704
|
+
});
|
|
705
|
+
|
|
706
|
+
describe('Edge Cases - Skill Delay and Timers', () => {
|
|
707
|
+
it('should set canActivate to false with positive delay', () => {
|
|
708
|
+
let skillData = {
|
|
709
|
+
...BaseSkillsFixtures.basicSkill,
|
|
710
|
+
owner: mockOwner,
|
|
711
|
+
skillDelay: 1000
|
|
712
|
+
};
|
|
713
|
+
let skill = new Skill(skillData);
|
|
714
|
+
skill.validate();
|
|
715
|
+
assert.strictEqual(skill.canActivate, false);
|
|
716
|
+
assert.ok(skill.skillActivationTimer);
|
|
717
|
+
});
|
|
718
|
+
|
|
719
|
+
it('should handle zero skill delay', () => {
|
|
720
|
+
let skillData = {
|
|
721
|
+
...BaseSkillsFixtures.basicSkill,
|
|
722
|
+
owner: mockOwner,
|
|
723
|
+
skillDelay: 0
|
|
724
|
+
};
|
|
725
|
+
let skill = new Skill(skillData);
|
|
726
|
+
skill.validate();
|
|
727
|
+
assert.strictEqual(skill.canActivate, true);
|
|
728
|
+
});
|
|
729
|
+
|
|
730
|
+
it('should handle negative skill delay', () => {
|
|
731
|
+
let skillData = {
|
|
732
|
+
...BaseSkillsFixtures.basicSkill,
|
|
733
|
+
owner: mockOwner,
|
|
734
|
+
skillDelay: -1000
|
|
735
|
+
};
|
|
736
|
+
let skill = new Skill(skillData);
|
|
737
|
+
skill.validate();
|
|
738
|
+
assert.strictEqual(skill.canActivate, true);
|
|
739
|
+
});
|
|
740
|
+
|
|
741
|
+
it('should restore canActivate after delay', async () => {
|
|
742
|
+
let skillData = {
|
|
743
|
+
...BaseSkillsFixtures.basicSkill,
|
|
744
|
+
owner: mockOwner,
|
|
745
|
+
skillDelay: 100
|
|
746
|
+
};
|
|
747
|
+
let skill = new Skill(skillData);
|
|
748
|
+
skill.validate();
|
|
749
|
+
assert.strictEqual(skill.canActivate, false);
|
|
750
|
+
await TestHelpers.sleep(150);
|
|
751
|
+
assert.strictEqual(skill.canActivate, true);
|
|
752
|
+
});
|
|
753
|
+
});
|
|
754
|
+
|
|
755
|
+
describe('Edge Cases - Owner Effects', () => {
|
|
756
|
+
it('should apply owner effects when provided', async () => {
|
|
757
|
+
let modifier = new Modifier({
|
|
758
|
+
key: 'hp-cost',
|
|
759
|
+
propertyKey: 'stats/hp',
|
|
760
|
+
operation: ModifierConst.OPS.DEC,
|
|
761
|
+
value: 10
|
|
762
|
+
});
|
|
763
|
+
let skillData = {
|
|
764
|
+
...BaseSkillsFixtures.basicSkill,
|
|
765
|
+
owner: mockOwner,
|
|
766
|
+
ownerEffects: [modifier]
|
|
767
|
+
};
|
|
768
|
+
let skill = new Skill(skillData);
|
|
769
|
+
let initialHp = mockOwner.stats.hp;
|
|
770
|
+
await skill.execute(mockTarget);
|
|
771
|
+
assert.ok(mockOwner.stats.hp !== initialHp);
|
|
772
|
+
});
|
|
773
|
+
|
|
774
|
+
it('should fire SKILL_APPLY_OWNER_EFFECTS event', async () => {
|
|
775
|
+
let eventFired = false;
|
|
776
|
+
let modifier = new Modifier({
|
|
777
|
+
key: 'mp-cost',
|
|
778
|
+
propertyKey: 'stats/mp',
|
|
779
|
+
operation: ModifierConst.OPS.DEC,
|
|
780
|
+
value: 5
|
|
781
|
+
});
|
|
782
|
+
let skillData = {
|
|
783
|
+
...BaseSkillsFixtures.basicSkill,
|
|
784
|
+
owner: mockOwner,
|
|
785
|
+
ownerEffects: [modifier]
|
|
786
|
+
};
|
|
787
|
+
let skill = new Skill(skillData);
|
|
788
|
+
skill.listenEvent(SkillsEvents.SKILL_APPLY_OWNER_EFFECTS, () => {
|
|
789
|
+
eventFired = true;
|
|
790
|
+
}, 'owner-effects-test');
|
|
791
|
+
await skill.execute(mockTarget);
|
|
792
|
+
assert.strictEqual(eventFired, true);
|
|
793
|
+
});
|
|
794
|
+
|
|
795
|
+
it('should handle empty ownerEffects array', async () => {
|
|
796
|
+
let skillData = {
|
|
797
|
+
...BaseSkillsFixtures.basicSkill,
|
|
798
|
+
owner: mockOwner,
|
|
799
|
+
ownerEffects: []
|
|
800
|
+
};
|
|
801
|
+
let skill = new Skill(skillData);
|
|
802
|
+
let result = await skill.execute(mockTarget);
|
|
803
|
+
assert.strictEqual(typeof result, 'boolean');
|
|
804
|
+
});
|
|
805
|
+
});
|
|
806
|
+
|
|
807
|
+
describe('Error Conditions - Missing Required Data', () => {
|
|
808
|
+
it('should handle missing target on execute', async () => {
|
|
809
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
810
|
+
let skill = new Skill(skillData);
|
|
811
|
+
let result = await skill.execute();
|
|
812
|
+
assert.strictEqual(result, false);
|
|
813
|
+
});
|
|
814
|
+
|
|
815
|
+
it('should handle null target', async () => {
|
|
816
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
817
|
+
let skill = new Skill(skillData);
|
|
818
|
+
let result = await skill.execute(null);
|
|
819
|
+
assert.strictEqual(result, false);
|
|
820
|
+
});
|
|
821
|
+
|
|
822
|
+
it('should handle undefined target', async () => {
|
|
823
|
+
let skillData = {...BaseSkillsFixtures.basicSkill, owner: mockOwner};
|
|
824
|
+
let skill = new Skill(skillData);
|
|
825
|
+
let result = await skill.execute(undefined);
|
|
826
|
+
assert.strictEqual(result, false);
|
|
827
|
+
});
|
|
828
|
+
|
|
829
|
+
it('should work with fixed target from props', async () => {
|
|
830
|
+
let skillData = {
|
|
831
|
+
...BaseSkillsFixtures.basicSkill,
|
|
832
|
+
owner: mockOwner,
|
|
833
|
+
target: mockTarget
|
|
834
|
+
};
|
|
835
|
+
let skill = new Skill(skillData);
|
|
836
|
+
let result = await skill.execute();
|
|
837
|
+
assert.strictEqual(result, true);
|
|
838
|
+
});
|
|
839
|
+
});
|
|
840
|
+
|
|
841
|
+
describe('Async Execution and Timing', () => {
|
|
842
|
+
it('should handle cast time correctly', async () => {
|
|
843
|
+
let castStarted = false;
|
|
844
|
+
let castFinished = false;
|
|
845
|
+
let skillData = {
|
|
846
|
+
...BaseSkillsFixtures.basicSkill,
|
|
847
|
+
owner: mockOwner,
|
|
848
|
+
castTime: 100
|
|
849
|
+
};
|
|
850
|
+
let skill = new Skill(skillData);
|
|
851
|
+
skill.listenEvent(SkillsEvents.SKILL_BEFORE_CAST, () => {
|
|
852
|
+
castStarted = true;
|
|
853
|
+
}, 'cast-start');
|
|
854
|
+
skill.listenEvent(SkillsEvents.SKILL_AFTER_CAST, () => {
|
|
855
|
+
castFinished = true;
|
|
856
|
+
}, 'cast-finish');
|
|
857
|
+
await skill.execute(mockTarget);
|
|
858
|
+
assert.strictEqual(castStarted, true);
|
|
859
|
+
assert.strictEqual(mockOwner.isCasting, true);
|
|
860
|
+
await TestHelpers.sleep(150);
|
|
861
|
+
assert.strictEqual(castFinished, true);
|
|
862
|
+
assert.strictEqual(mockOwner.isCasting, false);
|
|
863
|
+
});
|
|
864
|
+
|
|
865
|
+
it('should not set isCasting with zero cast time', async () => {
|
|
866
|
+
let skillData = {
|
|
867
|
+
...BaseSkillsFixtures.basicSkill,
|
|
868
|
+
owner: mockOwner,
|
|
869
|
+
castTime: 0
|
|
870
|
+
};
|
|
871
|
+
let skill = new Skill(skillData);
|
|
872
|
+
await skill.execute(mockTarget);
|
|
873
|
+
assert.strictEqual(mockOwner.isCasting, false);
|
|
874
|
+
});
|
|
875
|
+
});
|
|
876
|
+
|
|
877
|
+
describe('isValidRange', () => {
|
|
878
|
+
it('should return false when rangeAutomaticValidation is false', async () => {
|
|
879
|
+
let skillData = {
|
|
880
|
+
...BaseSkillsFixtures.basicSkill,
|
|
881
|
+
owner: mockOwner,
|
|
882
|
+
rangeAutomaticValidation: false,
|
|
883
|
+
rangePropertyX: 'x',
|
|
884
|
+
rangePropertyY: 'y'
|
|
885
|
+
};
|
|
886
|
+
let skill = new Skill(skillData);
|
|
887
|
+
let result = await skill.isValidRange(mockTarget);
|
|
888
|
+
assert.strictEqual(result, false);
|
|
889
|
+
});
|
|
890
|
+
|
|
891
|
+
it('should return false when rangePropertyX is missing', async () => {
|
|
892
|
+
let skillData = {
|
|
893
|
+
...BaseSkillsFixtures.basicSkill,
|
|
894
|
+
owner: mockOwner,
|
|
895
|
+
rangeAutomaticValidation: true,
|
|
896
|
+
rangePropertyY: 'y'
|
|
897
|
+
};
|
|
898
|
+
let skill = new Skill(skillData);
|
|
899
|
+
let result = await skill.isValidRange(mockTarget);
|
|
900
|
+
assert.strictEqual(result, false);
|
|
901
|
+
});
|
|
902
|
+
|
|
903
|
+
it('should return false when rangePropertyY is missing', async () => {
|
|
904
|
+
let skillData = {
|
|
905
|
+
...BaseSkillsFixtures.basicSkill,
|
|
906
|
+
owner: mockOwner,
|
|
907
|
+
rangeAutomaticValidation: true,
|
|
908
|
+
rangePropertyX: 'x'
|
|
909
|
+
};
|
|
910
|
+
let skill = new Skill(skillData);
|
|
911
|
+
let result = await skill.isValidRange(mockTarget);
|
|
912
|
+
assert.strictEqual(result, false);
|
|
913
|
+
});
|
|
914
|
+
|
|
915
|
+
it('should return true when all properties set and target out of range', async () => {
|
|
916
|
+
let skillData = {
|
|
917
|
+
...BaseSkillsFixtures.basicSkill,
|
|
918
|
+
owner: mockOwner,
|
|
919
|
+
rangeAutomaticValidation: true,
|
|
920
|
+
rangePropertyX: 'position/x',
|
|
921
|
+
rangePropertyY: 'position/y',
|
|
922
|
+
range: 1
|
|
923
|
+
};
|
|
924
|
+
let skill = new Skill(skillData);
|
|
925
|
+
let result = await skill.isValidRange(mockTarget);
|
|
926
|
+
assert.strictEqual(result, true);
|
|
927
|
+
});
|
|
928
|
+
|
|
929
|
+
it('should return false when target is in range', async () => {
|
|
930
|
+
mockTarget.getPosition = () => ({x: 100, y: 100});
|
|
931
|
+
let skillData = {
|
|
932
|
+
...BaseSkillsFixtures.basicSkill,
|
|
933
|
+
owner: mockOwner,
|
|
934
|
+
rangeAutomaticValidation: true,
|
|
935
|
+
rangePropertyX: 'position/x',
|
|
936
|
+
rangePropertyY: 'position/y',
|
|
937
|
+
range: 100
|
|
938
|
+
};
|
|
939
|
+
let skill = new Skill(skillData);
|
|
940
|
+
let result = await skill.isValidRange(mockTarget);
|
|
941
|
+
assert.strictEqual(result, false);
|
|
942
|
+
});
|
|
943
|
+
});
|
|
944
|
+
|
|
945
|
+
describe('onExecuteConditions', () => {
|
|
946
|
+
it('should return true by default', () => {
|
|
947
|
+
let skillData = {
|
|
948
|
+
...BaseSkillsFixtures.basicSkill,
|
|
949
|
+
owner: mockOwner
|
|
950
|
+
};
|
|
951
|
+
let skill = new Skill(skillData);
|
|
952
|
+
let result = skill.onExecuteConditions();
|
|
953
|
+
assert.strictEqual(result, true);
|
|
954
|
+
});
|
|
955
|
+
|
|
956
|
+
it('should be called during execute', async () => {
|
|
957
|
+
let conditionCalled = false;
|
|
958
|
+
let skillData = {
|
|
959
|
+
...BaseSkillsFixtures.basicSkill,
|
|
960
|
+
owner: mockOwner
|
|
961
|
+
};
|
|
962
|
+
let skill = new Skill(skillData);
|
|
963
|
+
skill.onExecuteConditions = () => {
|
|
964
|
+
conditionCalled = true;
|
|
965
|
+
return true;
|
|
966
|
+
};
|
|
967
|
+
await skill.execute(mockTarget);
|
|
968
|
+
assert.strictEqual(conditionCalled, true);
|
|
969
|
+
});
|
|
970
|
+
|
|
971
|
+
it('should prevent execution when returns false', async () => {
|
|
972
|
+
let skillData = {
|
|
973
|
+
...BaseSkillsFixtures.basicSkill,
|
|
974
|
+
owner: mockOwner
|
|
975
|
+
};
|
|
976
|
+
let skill = new Skill(skillData);
|
|
977
|
+
skill.onExecuteConditions = () => false;
|
|
978
|
+
let result = await skill.execute(mockTarget);
|
|
979
|
+
assert.strictEqual(result, false);
|
|
980
|
+
});
|
|
981
|
+
});
|
|
982
|
+
|
|
983
|
+
describe('onExecuteRewards', () => {
|
|
984
|
+
it('should be callable without errors', async () => {
|
|
985
|
+
let skillData = {
|
|
986
|
+
...BaseSkillsFixtures.basicSkill,
|
|
987
|
+
owner: mockOwner
|
|
988
|
+
};
|
|
989
|
+
let skill = new Skill(skillData);
|
|
990
|
+
await skill.onExecuteRewards();
|
|
991
|
+
assert.ok(true);
|
|
992
|
+
});
|
|
993
|
+
|
|
994
|
+
it('should be called during execute', async () => {
|
|
995
|
+
let rewardsCalled = false;
|
|
996
|
+
let skillData = {
|
|
997
|
+
...BaseSkillsFixtures.basicSkill,
|
|
998
|
+
owner: mockOwner
|
|
999
|
+
};
|
|
1000
|
+
let skill = new Skill(skillData);
|
|
1001
|
+
skill.onExecuteRewards = async () => {
|
|
1002
|
+
rewardsCalled = true;
|
|
1003
|
+
};
|
|
1004
|
+
await skill.execute(mockTarget);
|
|
1005
|
+
assert.strictEqual(rewardsCalled, true);
|
|
1006
|
+
});
|
|
1007
|
+
});
|
|
1008
|
+
|
|
1009
|
+
describe('getOwnerUniqueEventKey', () => {
|
|
1010
|
+
it('should generate unique key with timestamp', () => {
|
|
1011
|
+
let skillData = {
|
|
1012
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1013
|
+
owner: mockOwner
|
|
1014
|
+
};
|
|
1015
|
+
let skill = new Skill(skillData);
|
|
1016
|
+
let key1 = skill.getOwnerUniqueEventKey();
|
|
1017
|
+
assert.ok(key1.includes('skills.ownerId'));
|
|
1018
|
+
assert.ok(key1.includes('.uKey.'));
|
|
1019
|
+
});
|
|
1020
|
+
|
|
1021
|
+
it('should append suffix when provided', () => {
|
|
1022
|
+
let skillData = {
|
|
1023
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1024
|
+
owner: mockOwner
|
|
1025
|
+
};
|
|
1026
|
+
let skill = new Skill(skillData);
|
|
1027
|
+
let key = skill.getOwnerUniqueEventKey('testSuffix');
|
|
1028
|
+
assert.ok(key.endsWith('.testSuffix'));
|
|
1029
|
+
});
|
|
1030
|
+
|
|
1031
|
+
it('should use owner eventUniqueKey when available', () => {
|
|
1032
|
+
let customOwner = {
|
|
1033
|
+
...mockOwner,
|
|
1034
|
+
eventUniqueKey: () => 'custom-unique-key'
|
|
1035
|
+
};
|
|
1036
|
+
let skillData = {
|
|
1037
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1038
|
+
owner: customOwner
|
|
1039
|
+
};
|
|
1040
|
+
let skill = new Skill(skillData);
|
|
1041
|
+
let key = skill.getOwnerUniqueEventKey();
|
|
1042
|
+
assert.ok(key.includes('custom-unique-key'));
|
|
1043
|
+
});
|
|
1044
|
+
});
|
|
1045
|
+
|
|
1046
|
+
describe('execute with autoValidation', () => {
|
|
1047
|
+
it('should validate range when autoValidation is true', async () => {
|
|
1048
|
+
let skillData = {
|
|
1049
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1050
|
+
owner: mockOwner,
|
|
1051
|
+
rangeAutomaticValidation: true,
|
|
1052
|
+
rangePropertyX: 'position/x',
|
|
1053
|
+
rangePropertyY: 'position/y',
|
|
1054
|
+
range: 1
|
|
1055
|
+
};
|
|
1056
|
+
let skill = new Skill(skillData);
|
|
1057
|
+
let result = await skill.execute(mockTarget);
|
|
1058
|
+
assert.strictEqual(result, false);
|
|
1059
|
+
});
|
|
1060
|
+
});
|
|
1061
|
+
|
|
1062
|
+
describe('Constructor with null owner', () => {
|
|
1063
|
+
it('should handle explicitly null owner', () => {
|
|
1064
|
+
let skillData = {
|
|
1065
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1066
|
+
owner: null
|
|
1067
|
+
};
|
|
1068
|
+
assert.throws(() => new Skill(skillData), TypeError);
|
|
1069
|
+
});
|
|
1070
|
+
});
|
|
1071
|
+
|
|
1072
|
+
describe('Constructor with false values', () => {
|
|
1073
|
+
it('should handle false allowSelfTarget', () => {
|
|
1074
|
+
let skillData = {
|
|
1075
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1076
|
+
owner: mockOwner,
|
|
1077
|
+
allowSelfTarget: false
|
|
1078
|
+
};
|
|
1079
|
+
let skill = new Skill(skillData);
|
|
1080
|
+
assert.strictEqual(skill.allowSelfTarget, false);
|
|
1081
|
+
});
|
|
1082
|
+
|
|
1083
|
+
it('should handle false rangeAutomaticValidation', () => {
|
|
1084
|
+
let skillData = {
|
|
1085
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1086
|
+
owner: mockOwner,
|
|
1087
|
+
rangeAutomaticValidation: false
|
|
1088
|
+
};
|
|
1089
|
+
let skill = new Skill(skillData);
|
|
1090
|
+
assert.strictEqual(skill.rangeAutomaticValidation, false);
|
|
1091
|
+
});
|
|
1092
|
+
});
|
|
1093
|
+
|
|
1094
|
+
describe('validate with multiple conditions', () => {
|
|
1095
|
+
it('should return false when both canActivate false and owner casting', () => {
|
|
1096
|
+
let skillData = {
|
|
1097
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1098
|
+
owner: mockOwner,
|
|
1099
|
+
skillDelay: 100
|
|
1100
|
+
};
|
|
1101
|
+
let skill = new Skill(skillData);
|
|
1102
|
+
skill.validate();
|
|
1103
|
+
mockOwner.isCasting = true;
|
|
1104
|
+
let result = skill.validate();
|
|
1105
|
+
assert.strictEqual(result, false);
|
|
1106
|
+
});
|
|
1107
|
+
});
|
|
1108
|
+
|
|
1109
|
+
describe('validateRange with target properties', () => {
|
|
1110
|
+
it('should work with rangeTargetPropertyX', () => {
|
|
1111
|
+
let skillData = {
|
|
1112
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1113
|
+
owner: mockOwner,
|
|
1114
|
+
rangePropertyX: 'position/x',
|
|
1115
|
+
rangePropertyY: 'position/y',
|
|
1116
|
+
rangeTargetPropertyX: 'targetX',
|
|
1117
|
+
rangeTargetPropertyY: 'targetY',
|
|
1118
|
+
range: 10
|
|
1119
|
+
};
|
|
1120
|
+
let skill = new Skill(skillData);
|
|
1121
|
+
mockTarget.targetX = 105;
|
|
1122
|
+
mockTarget.targetY = 105;
|
|
1123
|
+
let result = skill.validateRange(mockTarget);
|
|
1124
|
+
assert.strictEqual(result, true);
|
|
1125
|
+
});
|
|
1126
|
+
|
|
1127
|
+
it('should handle target with undefined positions', () => {
|
|
1128
|
+
let skillData = {
|
|
1129
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1130
|
+
owner: mockOwner,
|
|
1131
|
+
rangePropertyX: 'position/x',
|
|
1132
|
+
rangePropertyY: 'position/y',
|
|
1133
|
+
range: 10
|
|
1134
|
+
};
|
|
1135
|
+
let skill = new Skill(skillData);
|
|
1136
|
+
let badTarget = {getPosition: () => ({x: undefined, y: 110}), position: {x: undefined, y: 110}};
|
|
1137
|
+
assert.throws(() => skill.validateRange(badTarget), Error);
|
|
1138
|
+
});
|
|
1139
|
+
|
|
1140
|
+
it('should handle target with NaN positions', () => {
|
|
1141
|
+
let skillData = {
|
|
1142
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1143
|
+
owner: mockOwner,
|
|
1144
|
+
rangePropertyX: 'position/x',
|
|
1145
|
+
rangePropertyY: 'position/y',
|
|
1146
|
+
range: 10
|
|
1147
|
+
};
|
|
1148
|
+
let skill = new Skill(skillData);
|
|
1149
|
+
let badTarget = {getPosition: () => ({x: NaN, y: 110}), position: {x: NaN, y: 110}};
|
|
1150
|
+
let result = skill.validateRange(badTarget);
|
|
1151
|
+
assert.strictEqual(result, false);
|
|
1152
|
+
});
|
|
1153
|
+
});
|
|
1154
|
+
|
|
1155
|
+
describe('isInRange same position', () => {
|
|
1156
|
+
it('should return true when distance is 0', () => {
|
|
1157
|
+
mockTarget.getPosition = () => ({x: 100, y: 100});
|
|
1158
|
+
let skillData = {
|
|
1159
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1160
|
+
owner: mockOwner,
|
|
1161
|
+
range: 10
|
|
1162
|
+
};
|
|
1163
|
+
let skill = new Skill(skillData);
|
|
1164
|
+
let result = skill.isInRange(mockOwner.getPosition(), mockTarget.getPosition());
|
|
1165
|
+
assert.strictEqual(result, true);
|
|
1166
|
+
});
|
|
1167
|
+
});
|
|
1168
|
+
|
|
1169
|
+
describe('execute with fixed target', () => {
|
|
1170
|
+
it('should not overwrite fixed target', async () => {
|
|
1171
|
+
let fixedTarget = TestHelpers.createMockTarget('fixed-target');
|
|
1172
|
+
let skillData = {
|
|
1173
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1174
|
+
owner: mockOwner,
|
|
1175
|
+
target: fixedTarget
|
|
1176
|
+
};
|
|
1177
|
+
let skill = new Skill(skillData);
|
|
1178
|
+
await skill.execute(mockTarget);
|
|
1179
|
+
assert.strictEqual(skill.target, mockTarget);
|
|
1180
|
+
});
|
|
1181
|
+
});
|
|
1182
|
+
|
|
1183
|
+
describe('execute with ownerEffects variations', () => {
|
|
1184
|
+
it('should handle ownerEffects as empty array', async () => {
|
|
1185
|
+
let skillData = {
|
|
1186
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1187
|
+
owner: mockOwner,
|
|
1188
|
+
ownerEffects: []
|
|
1189
|
+
};
|
|
1190
|
+
let skill = new Skill(skillData);
|
|
1191
|
+
await skill.execute(mockTarget);
|
|
1192
|
+
assert.ok(true);
|
|
1193
|
+
});
|
|
1194
|
+
|
|
1195
|
+
it('should handle ownerEffects as null', async () => {
|
|
1196
|
+
let skillData = {
|
|
1197
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1198
|
+
owner: mockOwner,
|
|
1199
|
+
ownerEffects: null
|
|
1200
|
+
};
|
|
1201
|
+
let skill = new Skill(skillData);
|
|
1202
|
+
await skill.execute(mockTarget);
|
|
1203
|
+
assert.ok(true);
|
|
1204
|
+
});
|
|
1205
|
+
});
|
|
1206
|
+
|
|
1207
|
+
describe('applySkillLogicOnTarget with negative castTime', () => {
|
|
1208
|
+
it('should handle negative castTime', async () => {
|
|
1209
|
+
let skillData = {
|
|
1210
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1211
|
+
owner: mockOwner,
|
|
1212
|
+
castTime: -100
|
|
1213
|
+
};
|
|
1214
|
+
let skill = new Skill(skillData);
|
|
1215
|
+
await skill.execute(mockTarget);
|
|
1216
|
+
assert.strictEqual(mockOwner.isCasting, false);
|
|
1217
|
+
});
|
|
1218
|
+
});
|
|
1219
|
+
|
|
1220
|
+
describe('applyModifiers with avoidCritical', () => {
|
|
1221
|
+
it('should not apply critical when avoidCritical is true', () => {
|
|
1222
|
+
let modifier = new Modifier({
|
|
1223
|
+
key: 'test-mod',
|
|
1224
|
+
propertyKey: 'stats/hp',
|
|
1225
|
+
operation: ModifierConst.OPS.INC,
|
|
1226
|
+
value: 10
|
|
1227
|
+
});
|
|
1228
|
+
let skillData = {
|
|
1229
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1230
|
+
owner: mockOwner,
|
|
1231
|
+
criticalChance: 100
|
|
1232
|
+
};
|
|
1233
|
+
let skill = new Skill(skillData);
|
|
1234
|
+
skill.applyModifiers({mod: modifier}, mockTarget, true);
|
|
1235
|
+
assert.ok(skill.lastAppliedModifiers);
|
|
1236
|
+
});
|
|
1237
|
+
|
|
1238
|
+
it('should populate lastAppliedModifiers correctly', () => {
|
|
1239
|
+
let modifier = new Modifier({
|
|
1240
|
+
key: 'test-mod',
|
|
1241
|
+
propertyKey: 'stats/hp',
|
|
1242
|
+
operation: ModifierConst.OPS.INC,
|
|
1243
|
+
value: 10
|
|
1244
|
+
});
|
|
1245
|
+
let skillData = {
|
|
1246
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1247
|
+
owner: mockOwner
|
|
1248
|
+
};
|
|
1249
|
+
let skill = new Skill(skillData);
|
|
1250
|
+
skill.applyModifiers({mod: modifier}, mockTarget, false);
|
|
1251
|
+
assert.ok(skill.lastAppliedModifiers['stats/hp']);
|
|
1252
|
+
});
|
|
1253
|
+
});
|
|
1254
|
+
|
|
1255
|
+
describe('getCriticalDiff edge cases', () => {
|
|
1256
|
+
it('should return 0 when not critical', () => {
|
|
1257
|
+
let skillData = {
|
|
1258
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1259
|
+
owner: mockOwner,
|
|
1260
|
+
criticalChance: 0
|
|
1261
|
+
};
|
|
1262
|
+
let skill = new Skill(skillData);
|
|
1263
|
+
let diff = skill.getCriticalDiff(100);
|
|
1264
|
+
assert.strictEqual(diff, 0);
|
|
1265
|
+
});
|
|
1266
|
+
|
|
1267
|
+
it('should handle negative normalValue', () => {
|
|
1268
|
+
let skillData = {
|
|
1269
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1270
|
+
owner: mockOwner,
|
|
1271
|
+
criticalMultiplier: 2
|
|
1272
|
+
};
|
|
1273
|
+
let skill = new Skill(skillData);
|
|
1274
|
+
let result = skill.applyCriticalValue(-10);
|
|
1275
|
+
assert.ok(typeof result === 'number');
|
|
1276
|
+
});
|
|
1277
|
+
|
|
1278
|
+
it('should handle zero normalValue', () => {
|
|
1279
|
+
let skillData = {
|
|
1280
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1281
|
+
owner: mockOwner,
|
|
1282
|
+
criticalMultiplier: 2
|
|
1283
|
+
};
|
|
1284
|
+
let skill = new Skill(skillData);
|
|
1285
|
+
let result = skill.applyCriticalValue(0);
|
|
1286
|
+
assert.strictEqual(result, 0);
|
|
1287
|
+
});
|
|
1288
|
+
});
|
|
1289
|
+
|
|
1290
|
+
describe('isCritical with floating point', () => {
|
|
1291
|
+
it('should handle floating point criticalChance', () => {
|
|
1292
|
+
let skillData = {
|
|
1293
|
+
...BaseSkillsFixtures.basicSkill,
|
|
1294
|
+
owner: mockOwner,
|
|
1295
|
+
criticalChance: 50.5
|
|
1296
|
+
};
|
|
1297
|
+
let skill = new Skill(skillData);
|
|
1298
|
+
let result = skill.isCritical();
|
|
1299
|
+
assert.ok(typeof result === 'boolean');
|
|
1300
|
+
});
|
|
1301
|
+
});
|
|
1302
|
+
});
|