@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.
- 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
- package/migrations/production/reldens-skills-install.sql +0 -275
|
@@ -0,0 +1,587 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - Effect Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it, beforeEach, afterEach } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const Effect = require('../../../lib/types/effect');
|
|
10
|
+
const SkillsConst = require('../../../lib/constants');
|
|
11
|
+
const SkillsEvents = require('../../../lib/skills-events');
|
|
12
|
+
const { 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('Effect', () => {
|
|
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 effect type', () => {
|
|
34
|
+
let effectData = {...BaseSkillsFixtures.effectSkill, owner: mockOwner};
|
|
35
|
+
let effect = new Effect(effectData);
|
|
36
|
+
assert.strictEqual(effect.type, SkillsConst.SKILL.TYPE.EFFECT);
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
it('should set isReady to false when targetEffects is missing', () => {
|
|
40
|
+
let effectData = {key: 'test-effect', owner: mockOwner};
|
|
41
|
+
let effect = new Effect(effectData);
|
|
42
|
+
assert.strictEqual(effect.isReady, false);
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
it('should initialize with targetEffects', () => {
|
|
46
|
+
let modifier = new Modifier({
|
|
47
|
+
key: 'atk-buff',
|
|
48
|
+
propertyKey: 'stats/atk',
|
|
49
|
+
operation: ModifierConst.OPS.INC,
|
|
50
|
+
value: 5
|
|
51
|
+
});
|
|
52
|
+
let effectData = {
|
|
53
|
+
key: 'test-effect',
|
|
54
|
+
owner: mockOwner,
|
|
55
|
+
targetEffects: [modifier]
|
|
56
|
+
};
|
|
57
|
+
let effect = new Effect(effectData);
|
|
58
|
+
assert.ok(Array.isArray(effect.targetEffects));
|
|
59
|
+
assert.strictEqual(effect.targetEffects.length, 1);
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
it('should initialize with empty targetEffects array', () => {
|
|
63
|
+
let effectData = {
|
|
64
|
+
key: 'test-effect',
|
|
65
|
+
owner: mockOwner,
|
|
66
|
+
targetEffects: []
|
|
67
|
+
};
|
|
68
|
+
let effect = new Effect(effectData);
|
|
69
|
+
assert.ok(Array.isArray(effect.targetEffects));
|
|
70
|
+
assert.strictEqual(effect.targetEffects.length, 0);
|
|
71
|
+
});
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
describe('runSkillLogic', () => {
|
|
75
|
+
it('should return false when out of range', async () => {
|
|
76
|
+
let effectData = {
|
|
77
|
+
...BaseSkillsFixtures.effectSkill,
|
|
78
|
+
owner: mockOwner,
|
|
79
|
+
range: 10,
|
|
80
|
+
targetEffects: []
|
|
81
|
+
};
|
|
82
|
+
let effect = new Effect(effectData);
|
|
83
|
+
effect.target = mockTarget;
|
|
84
|
+
let result = await effect.runSkillLogic();
|
|
85
|
+
assert.strictEqual(result, false);
|
|
86
|
+
assert.strictEqual(effect.lastState, SkillsConst.SKILL_STATES.OUT_OF_RANGE);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
it('should apply modifiers when in range', async () => {
|
|
90
|
+
let modifier = new Modifier({
|
|
91
|
+
key: 'atk-buff',
|
|
92
|
+
propertyKey: 'stats/atk',
|
|
93
|
+
operation: ModifierConst.OPS.INC,
|
|
94
|
+
value: 10
|
|
95
|
+
});
|
|
96
|
+
let effectData = {
|
|
97
|
+
...BaseSkillsFixtures.effectSkill,
|
|
98
|
+
owner: mockOwner,
|
|
99
|
+
range: 0,
|
|
100
|
+
targetEffects: [modifier]
|
|
101
|
+
};
|
|
102
|
+
let effect = new Effect(effectData);
|
|
103
|
+
effect.target = mockTarget;
|
|
104
|
+
let initialAtk = mockTarget.stats.atk;
|
|
105
|
+
await effect.runSkillLogic();
|
|
106
|
+
assert.ok(mockTarget.stats.atk !== initialAtk);
|
|
107
|
+
assert.strictEqual(effect.lastState, SkillsConst.SKILL_STATES.APPLIED_EFFECTS);
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
it('should set lastState to APPLYING_EFFECTS', async () => {
|
|
111
|
+
let effectData = {
|
|
112
|
+
...BaseSkillsFixtures.effectSkill,
|
|
113
|
+
owner: mockOwner,
|
|
114
|
+
range: 0,
|
|
115
|
+
targetEffects: []
|
|
116
|
+
};
|
|
117
|
+
let effect = new Effect(effectData);
|
|
118
|
+
effect.target = mockTarget;
|
|
119
|
+
await effect.runSkillLogic();
|
|
120
|
+
assert.strictEqual(effect.lastState, SkillsConst.SKILL_STATES.APPLIED_EFFECTS);
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
it('should fire SKILL_EFFECT_TARGET_MODIFIERS event', async () => {
|
|
124
|
+
let eventFired = false;
|
|
125
|
+
let effectData = {
|
|
126
|
+
...BaseSkillsFixtures.effectSkill,
|
|
127
|
+
owner: mockOwner,
|
|
128
|
+
range: 0,
|
|
129
|
+
targetEffects: []
|
|
130
|
+
};
|
|
131
|
+
let effect = new Effect(effectData);
|
|
132
|
+
effect.target = mockTarget;
|
|
133
|
+
effect.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, () => {
|
|
134
|
+
eventFired = true;
|
|
135
|
+
}, 'effect-test');
|
|
136
|
+
await effect.runSkillLogic();
|
|
137
|
+
assert.strictEqual(eventFired, true);
|
|
138
|
+
});
|
|
139
|
+
});
|
|
140
|
+
|
|
141
|
+
describe('Error Conditions', () => {
|
|
142
|
+
it('should handle null target', async () => {
|
|
143
|
+
let effectData = {
|
|
144
|
+
...BaseSkillsFixtures.effectSkill,
|
|
145
|
+
owner: mockOwner,
|
|
146
|
+
range: 0,
|
|
147
|
+
targetEffects: []
|
|
148
|
+
};
|
|
149
|
+
let effect = new Effect(effectData);
|
|
150
|
+
effect.target = null;
|
|
151
|
+
let result = await effect.runSkillLogic();
|
|
152
|
+
assert.strictEqual(result, false);
|
|
153
|
+
});
|
|
154
|
+
|
|
155
|
+
it('should handle undefined target', async () => {
|
|
156
|
+
let effectData = {
|
|
157
|
+
...BaseSkillsFixtures.effectSkill,
|
|
158
|
+
owner: mockOwner,
|
|
159
|
+
range: 0,
|
|
160
|
+
targetEffects: []
|
|
161
|
+
};
|
|
162
|
+
let effect = new Effect(effectData);
|
|
163
|
+
effect.target = undefined;
|
|
164
|
+
let result = await effect.runSkillLogic();
|
|
165
|
+
assert.strictEqual(result, false);
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
it('should handle null targetEffects', () => {
|
|
169
|
+
let effectData = {
|
|
170
|
+
key: 'test-effect',
|
|
171
|
+
owner: mockOwner,
|
|
172
|
+
targetEffects: null
|
|
173
|
+
};
|
|
174
|
+
let effect = new Effect(effectData);
|
|
175
|
+
assert.strictEqual(effect.isReady, false);
|
|
176
|
+
});
|
|
177
|
+
|
|
178
|
+
it('should handle undefined targetEffects', () => {
|
|
179
|
+
let effectData = {
|
|
180
|
+
key: 'test-effect',
|
|
181
|
+
owner: mockOwner
|
|
182
|
+
};
|
|
183
|
+
let effect = new Effect(effectData);
|
|
184
|
+
assert.strictEqual(effect.isReady, false);
|
|
185
|
+
});
|
|
186
|
+
});
|
|
187
|
+
|
|
188
|
+
describe('Edge Cases - Range', () => {
|
|
189
|
+
it('should handle zero range', async () => {
|
|
190
|
+
let effectData = {
|
|
191
|
+
...BaseSkillsFixtures.effectSkill,
|
|
192
|
+
owner: mockOwner,
|
|
193
|
+
range: 0,
|
|
194
|
+
targetEffects: []
|
|
195
|
+
};
|
|
196
|
+
let effect = new Effect(effectData);
|
|
197
|
+
effect.target = mockTarget;
|
|
198
|
+
await effect.runSkillLogic();
|
|
199
|
+
assert.strictEqual(effect.lastState, SkillsConst.SKILL_STATES.APPLIED_EFFECTS);
|
|
200
|
+
});
|
|
201
|
+
|
|
202
|
+
it('should handle negative range', async () => {
|
|
203
|
+
let effectData = {
|
|
204
|
+
...BaseSkillsFixtures.effectSkill,
|
|
205
|
+
owner: mockOwner,
|
|
206
|
+
range: -10,
|
|
207
|
+
targetEffects: []
|
|
208
|
+
};
|
|
209
|
+
let effect = new Effect(effectData);
|
|
210
|
+
effect.target = mockTarget;
|
|
211
|
+
await effect.runSkillLogic();
|
|
212
|
+
assert.ok(typeof effect.lastState === 'string');
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
it('should handle very large range', async () => {
|
|
216
|
+
let effectData = {
|
|
217
|
+
...BaseSkillsFixtures.effectSkill,
|
|
218
|
+
owner: mockOwner,
|
|
219
|
+
range: 10000,
|
|
220
|
+
targetEffects: []
|
|
221
|
+
};
|
|
222
|
+
let effect = new Effect(effectData);
|
|
223
|
+
effect.target = mockTarget;
|
|
224
|
+
await effect.runSkillLogic();
|
|
225
|
+
assert.strictEqual(effect.lastState, SkillsConst.SKILL_STATES.APPLIED_EFFECTS);
|
|
226
|
+
});
|
|
227
|
+
});
|
|
228
|
+
|
|
229
|
+
describe('Edge Cases - Modifiers', () => {
|
|
230
|
+
it('should handle multiple modifiers', async () => {
|
|
231
|
+
let modifier1 = new Modifier({
|
|
232
|
+
key: 'atk-buff',
|
|
233
|
+
propertyKey: 'stats/atk',
|
|
234
|
+
operation: ModifierConst.OPS.INC,
|
|
235
|
+
value: 5
|
|
236
|
+
});
|
|
237
|
+
let modifier2 = new Modifier({
|
|
238
|
+
key: 'def-buff',
|
|
239
|
+
propertyKey: 'stats/def',
|
|
240
|
+
operation: ModifierConst.OPS.INC,
|
|
241
|
+
value: 3
|
|
242
|
+
});
|
|
243
|
+
let effectData = {
|
|
244
|
+
...BaseSkillsFixtures.effectSkill,
|
|
245
|
+
owner: mockOwner,
|
|
246
|
+
range: 0,
|
|
247
|
+
targetEffects: [modifier1, modifier2]
|
|
248
|
+
};
|
|
249
|
+
let effect = new Effect(effectData);
|
|
250
|
+
effect.target = mockTarget;
|
|
251
|
+
let initialAtk = mockTarget.stats.atk;
|
|
252
|
+
let initialDef = mockTarget.stats.def;
|
|
253
|
+
await effect.runSkillLogic();
|
|
254
|
+
assert.ok(mockTarget.stats.atk !== initialAtk);
|
|
255
|
+
assert.ok(mockTarget.stats.def !== initialDef);
|
|
256
|
+
});
|
|
257
|
+
|
|
258
|
+
it('should handle modifier with DEC operation', async () => {
|
|
259
|
+
let modifier = new Modifier({
|
|
260
|
+
key: 'atk-debuff',
|
|
261
|
+
propertyKey: 'stats/atk',
|
|
262
|
+
operation: ModifierConst.OPS.DEC,
|
|
263
|
+
value: 5
|
|
264
|
+
});
|
|
265
|
+
let effectData = {
|
|
266
|
+
...BaseSkillsFixtures.effectSkill,
|
|
267
|
+
owner: mockOwner,
|
|
268
|
+
range: 0,
|
|
269
|
+
targetEffects: [modifier]
|
|
270
|
+
};
|
|
271
|
+
let effect = new Effect(effectData);
|
|
272
|
+
effect.target = mockTarget;
|
|
273
|
+
let initialAtk = mockTarget.stats.atk;
|
|
274
|
+
await effect.runSkillLogic();
|
|
275
|
+
assert.ok(mockTarget.stats.atk < initialAtk);
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
it('should handle modifier with SET operation', async () => {
|
|
279
|
+
let modifier = new Modifier({
|
|
280
|
+
key: 'atk-set',
|
|
281
|
+
propertyKey: 'stats/atk',
|
|
282
|
+
operation: ModifierConst.OPS.SET,
|
|
283
|
+
value: 100
|
|
284
|
+
});
|
|
285
|
+
let effectData = {
|
|
286
|
+
...BaseSkillsFixtures.effectSkill,
|
|
287
|
+
owner: mockOwner,
|
|
288
|
+
range: 0,
|
|
289
|
+
targetEffects: [modifier]
|
|
290
|
+
};
|
|
291
|
+
let effect = new Effect(effectData);
|
|
292
|
+
effect.target = mockTarget;
|
|
293
|
+
await effect.runSkillLogic();
|
|
294
|
+
assert.strictEqual(mockTarget.stats.atk, 100);
|
|
295
|
+
});
|
|
296
|
+
|
|
297
|
+
it('should handle modifier with zero value', async () => {
|
|
298
|
+
let modifier = new Modifier({
|
|
299
|
+
key: 'atk-zero',
|
|
300
|
+
propertyKey: 'stats/atk',
|
|
301
|
+
operation: ModifierConst.OPS.INC,
|
|
302
|
+
value: 0
|
|
303
|
+
});
|
|
304
|
+
let effectData = {
|
|
305
|
+
...BaseSkillsFixtures.effectSkill,
|
|
306
|
+
owner: mockOwner,
|
|
307
|
+
range: 0,
|
|
308
|
+
targetEffects: [modifier]
|
|
309
|
+
};
|
|
310
|
+
let effect = new Effect(effectData);
|
|
311
|
+
effect.target = mockTarget;
|
|
312
|
+
let initialAtk = mockTarget.stats.atk;
|
|
313
|
+
await effect.runSkillLogic();
|
|
314
|
+
assert.strictEqual(mockTarget.stats.atk, initialAtk);
|
|
315
|
+
});
|
|
316
|
+
|
|
317
|
+
it('should handle modifier with negative value', async () => {
|
|
318
|
+
let modifier = new Modifier({
|
|
319
|
+
key: 'atk-negative',
|
|
320
|
+
propertyKey: 'stats/atk',
|
|
321
|
+
operation: ModifierConst.OPS.INC,
|
|
322
|
+
value: -5
|
|
323
|
+
});
|
|
324
|
+
let effectData = {
|
|
325
|
+
...BaseSkillsFixtures.effectSkill,
|
|
326
|
+
owner: mockOwner,
|
|
327
|
+
range: 0,
|
|
328
|
+
targetEffects: [modifier]
|
|
329
|
+
};
|
|
330
|
+
let effect = new Effect(effectData);
|
|
331
|
+
effect.target = mockTarget;
|
|
332
|
+
let initialAtk = mockTarget.stats.atk;
|
|
333
|
+
await effect.runSkillLogic();
|
|
334
|
+
assert.ok(mockTarget.stats.atk !== initialAtk);
|
|
335
|
+
});
|
|
336
|
+
});
|
|
337
|
+
|
|
338
|
+
describe('Event System - Parameter Variations', () => {
|
|
339
|
+
it('should fire event with removeKey only', async () => {
|
|
340
|
+
let eventFired = false;
|
|
341
|
+
let effectData = {
|
|
342
|
+
...BaseSkillsFixtures.effectSkill,
|
|
343
|
+
owner: mockOwner,
|
|
344
|
+
range: 0,
|
|
345
|
+
targetEffects: []
|
|
346
|
+
};
|
|
347
|
+
let effect = new Effect(effectData);
|
|
348
|
+
effect.target = mockTarget;
|
|
349
|
+
effect.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, () => {
|
|
350
|
+
eventFired = true;
|
|
351
|
+
}, 'remove-key');
|
|
352
|
+
await effect.runSkillLogic();
|
|
353
|
+
assert.strictEqual(eventFired, true);
|
|
354
|
+
});
|
|
355
|
+
|
|
356
|
+
it('should fire event with masterKey', async () => {
|
|
357
|
+
let eventFired = false;
|
|
358
|
+
let effectData = {
|
|
359
|
+
...BaseSkillsFixtures.effectSkill,
|
|
360
|
+
owner: mockOwner,
|
|
361
|
+
range: 0,
|
|
362
|
+
targetEffects: []
|
|
363
|
+
};
|
|
364
|
+
let effect = new Effect(effectData);
|
|
365
|
+
effect.target = mockTarget;
|
|
366
|
+
let masterKey = effect.getOwnerEventKey();
|
|
367
|
+
effect.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, () => {
|
|
368
|
+
eventFired = true;
|
|
369
|
+
}, 'sub-key', masterKey);
|
|
370
|
+
await effect.runSkillLogic();
|
|
371
|
+
assert.strictEqual(eventFired, true);
|
|
372
|
+
});
|
|
373
|
+
|
|
374
|
+
it('should fire event without any keys', async () => {
|
|
375
|
+
let eventFired = false;
|
|
376
|
+
let effectData = {
|
|
377
|
+
...BaseSkillsFixtures.effectSkill,
|
|
378
|
+
owner: mockOwner,
|
|
379
|
+
range: 0,
|
|
380
|
+
targetEffects: []
|
|
381
|
+
};
|
|
382
|
+
let effect = new Effect(effectData);
|
|
383
|
+
effect.target = mockTarget;
|
|
384
|
+
effect.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, () => {
|
|
385
|
+
eventFired = true;
|
|
386
|
+
});
|
|
387
|
+
await effect.runSkillLogic();
|
|
388
|
+
assert.strictEqual(eventFired, true);
|
|
389
|
+
});
|
|
390
|
+
|
|
391
|
+
it('should handle multiple listeners', async () => {
|
|
392
|
+
let count = 0;
|
|
393
|
+
let effectData = {
|
|
394
|
+
...BaseSkillsFixtures.effectSkill,
|
|
395
|
+
owner: mockOwner,
|
|
396
|
+
range: 0,
|
|
397
|
+
targetEffects: []
|
|
398
|
+
};
|
|
399
|
+
let effect = new Effect(effectData);
|
|
400
|
+
effect.target = mockTarget;
|
|
401
|
+
effect.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, () => { count++; }, 'key1');
|
|
402
|
+
effect.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, () => { count++; }, 'key2');
|
|
403
|
+
effect.listenEvent(SkillsEvents.SKILL_EFFECT_TARGET_MODIFIERS, () => { count++; }, 'key3');
|
|
404
|
+
await effect.runSkillLogic();
|
|
405
|
+
assert.strictEqual(count, 3);
|
|
406
|
+
});
|
|
407
|
+
});
|
|
408
|
+
|
|
409
|
+
describe('Integration with Skill Base Class', () => {
|
|
410
|
+
it('should work with execute method', async () => {
|
|
411
|
+
let modifier = new Modifier({
|
|
412
|
+
key: 'hp-buff',
|
|
413
|
+
propertyKey: 'stats/hp',
|
|
414
|
+
operation: ModifierConst.OPS.INC,
|
|
415
|
+
value: 20
|
|
416
|
+
});
|
|
417
|
+
let effectData = {
|
|
418
|
+
...BaseSkillsFixtures.effectSkill,
|
|
419
|
+
owner: mockOwner,
|
|
420
|
+
range: 0,
|
|
421
|
+
castTime: 0,
|
|
422
|
+
targetEffects: [modifier]
|
|
423
|
+
};
|
|
424
|
+
let effect = new Effect(effectData);
|
|
425
|
+
let initialHp = mockTarget.stats.hp;
|
|
426
|
+
let result = await effect.execute(mockTarget);
|
|
427
|
+
assert.strictEqual(result, true);
|
|
428
|
+
assert.ok(mockTarget.stats.hp !== initialHp);
|
|
429
|
+
});
|
|
430
|
+
|
|
431
|
+
it('should handle castTime with effects', async () => {
|
|
432
|
+
mockTarget.stats.stamina = 100;
|
|
433
|
+
let modifier = new Modifier({
|
|
434
|
+
key: 'stamina-buff',
|
|
435
|
+
propertyKey: 'stats/stamina',
|
|
436
|
+
operation: ModifierConst.OPS.INC,
|
|
437
|
+
value: 10
|
|
438
|
+
});
|
|
439
|
+
let effectData = {
|
|
440
|
+
...BaseSkillsFixtures.effectSkill,
|
|
441
|
+
owner: mockOwner,
|
|
442
|
+
range: 0,
|
|
443
|
+
castTime: 100,
|
|
444
|
+
targetEffects: [modifier]
|
|
445
|
+
};
|
|
446
|
+
let effect = new Effect(effectData);
|
|
447
|
+
await effect.execute(mockTarget);
|
|
448
|
+
await TestHelpers.sleep(150);
|
|
449
|
+
assert.ok(mockTarget.stats.stamina > 100);
|
|
450
|
+
});
|
|
451
|
+
|
|
452
|
+
it('should handle skillDelay', async () => {
|
|
453
|
+
let effectData = {
|
|
454
|
+
...BaseSkillsFixtures.effectSkill,
|
|
455
|
+
owner: mockOwner,
|
|
456
|
+
range: 0,
|
|
457
|
+
castTime: 0,
|
|
458
|
+
skillDelay: 1000,
|
|
459
|
+
targetEffects: []
|
|
460
|
+
};
|
|
461
|
+
let effect = new Effect(effectData);
|
|
462
|
+
await effect.execute(mockTarget);
|
|
463
|
+
let result = effect.validate();
|
|
464
|
+
assert.strictEqual(effect.canActivate, false);
|
|
465
|
+
});
|
|
466
|
+
});
|
|
467
|
+
|
|
468
|
+
describe('Constructor - Null/Undefined Owner', () => {
|
|
469
|
+
it('should handle null owner', () => {
|
|
470
|
+
let effectData = {...BaseSkillsFixtures.effectSkill, owner: null};
|
|
471
|
+
assert.throws(
|
|
472
|
+
() => new Effect(effectData),
|
|
473
|
+
TypeError
|
|
474
|
+
);
|
|
475
|
+
});
|
|
476
|
+
|
|
477
|
+
it('should handle undefined owner', () => {
|
|
478
|
+
let effectData = {...BaseSkillsFixtures.effectSkill};
|
|
479
|
+
delete effectData.owner;
|
|
480
|
+
assert.throws(
|
|
481
|
+
() => new Effect(effectData),
|
|
482
|
+
TypeError
|
|
483
|
+
);
|
|
484
|
+
});
|
|
485
|
+
});
|
|
486
|
+
|
|
487
|
+
describe('runSkillLogic - Critical Chance on Modifiers', () => {
|
|
488
|
+
it('should apply critical multiplier to modifiers', async () => {
|
|
489
|
+
let modifier = new Modifier({
|
|
490
|
+
key: 'atk-buff',
|
|
491
|
+
propertyKey: 'stats/atk',
|
|
492
|
+
operation: ModifierConst.OPS.INC,
|
|
493
|
+
value: 10
|
|
494
|
+
});
|
|
495
|
+
let effectData = {
|
|
496
|
+
...BaseSkillsFixtures.effectSkill,
|
|
497
|
+
owner: mockOwner,
|
|
498
|
+
targetEffects: [modifier],
|
|
499
|
+
criticalChance: 100,
|
|
500
|
+
criticalMultiplier: 2,
|
|
501
|
+
range: 0,
|
|
502
|
+
castTime: 0
|
|
503
|
+
};
|
|
504
|
+
let effect = new Effect(effectData);
|
|
505
|
+
effect.isCritical = () => true;
|
|
506
|
+
let initialAtk = mockTarget.stats.atk;
|
|
507
|
+
await effect.execute(mockTarget);
|
|
508
|
+
assert.ok(mockTarget.stats.atk > initialAtk + 10);
|
|
509
|
+
});
|
|
510
|
+
});
|
|
511
|
+
|
|
512
|
+
describe('runSkillLogic - Empty Modifiers Behavior', () => {
|
|
513
|
+
it('should handle empty modifiers array', async () => {
|
|
514
|
+
let effectData = {
|
|
515
|
+
...BaseSkillsFixtures.effectSkill,
|
|
516
|
+
owner: mockOwner,
|
|
517
|
+
targetEffects: [],
|
|
518
|
+
range: 0,
|
|
519
|
+
castTime: 0
|
|
520
|
+
};
|
|
521
|
+
let effect = new Effect(effectData);
|
|
522
|
+
let result = await effect.execute(mockTarget);
|
|
523
|
+
assert.strictEqual(result, true);
|
|
524
|
+
});
|
|
525
|
+
|
|
526
|
+
it('should handle null targetEffects', async () => {
|
|
527
|
+
let effectData = {
|
|
528
|
+
...BaseSkillsFixtures.effectSkill,
|
|
529
|
+
owner: mockOwner,
|
|
530
|
+
targetEffects: null,
|
|
531
|
+
range: 0
|
|
532
|
+
};
|
|
533
|
+
let effect = new Effect(effectData);
|
|
534
|
+
let result = await effect.execute(mockTarget);
|
|
535
|
+
assert.ok(typeof result === 'boolean');
|
|
536
|
+
});
|
|
537
|
+
});
|
|
538
|
+
|
|
539
|
+
describe('runSkillLogic - Modifier Order Dependency', () => {
|
|
540
|
+
it('should apply modifiers in order', async () => {
|
|
541
|
+
let modifier1 = new Modifier({
|
|
542
|
+
key: 'set-atk',
|
|
543
|
+
propertyKey: 'stats/atk',
|
|
544
|
+
operation: ModifierConst.OPS.SET,
|
|
545
|
+
value: 20
|
|
546
|
+
});
|
|
547
|
+
let modifier2 = new Modifier({
|
|
548
|
+
key: 'mult-atk',
|
|
549
|
+
propertyKey: 'stats/atk',
|
|
550
|
+
operation: ModifierConst.OPS.MUL,
|
|
551
|
+
value: 2
|
|
552
|
+
});
|
|
553
|
+
let effectData = {
|
|
554
|
+
...BaseSkillsFixtures.effectSkill,
|
|
555
|
+
owner: mockOwner,
|
|
556
|
+
targetEffects: [modifier1, modifier2],
|
|
557
|
+
range: 0,
|
|
558
|
+
criticalChance: 0,
|
|
559
|
+
castTime: 0
|
|
560
|
+
};
|
|
561
|
+
let effect = new Effect(effectData);
|
|
562
|
+
await effect.execute(mockTarget);
|
|
563
|
+
assert.strictEqual(mockTarget.stats.atk, 40);
|
|
564
|
+
});
|
|
565
|
+
});
|
|
566
|
+
|
|
567
|
+
describe('runSkillLogic - Return Value Consistency', () => {
|
|
568
|
+
it('should return true on successful effect application', async () => {
|
|
569
|
+
let modifier = new Modifier({
|
|
570
|
+
key: 'hp-buff',
|
|
571
|
+
propertyKey: 'stats/hp',
|
|
572
|
+
operation: ModifierConst.OPS.INC,
|
|
573
|
+
value: 10
|
|
574
|
+
});
|
|
575
|
+
let effectData = {
|
|
576
|
+
...BaseSkillsFixtures.effectSkill,
|
|
577
|
+
owner: mockOwner,
|
|
578
|
+
targetEffects: [modifier],
|
|
579
|
+
range: 0,
|
|
580
|
+
castTime: 0
|
|
581
|
+
};
|
|
582
|
+
let effect = new Effect(effectData);
|
|
583
|
+
let result = await effect.execute(mockTarget);
|
|
584
|
+
assert.strictEqual(result, true);
|
|
585
|
+
});
|
|
586
|
+
});
|
|
587
|
+
});
|