@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,1227 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - LevelsSet Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it, beforeEach, afterEach } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const LevelsSet = require('../../lib/levels-set');
|
|
10
|
+
const Level = require('../../lib/level');
|
|
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 { BaseLevelsFixtures } = require('../fixtures/levels/base-levels');
|
|
16
|
+
|
|
17
|
+
describe('LevelsSet', () => {
|
|
18
|
+
let mockOwner;
|
|
19
|
+
|
|
20
|
+
beforeEach(() => {
|
|
21
|
+
mockOwner = new MockOwner();
|
|
22
|
+
TestHelpers.clearEventListeners();
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
afterEach(() => {
|
|
26
|
+
TestHelpers.clearEventListeners();
|
|
27
|
+
});
|
|
28
|
+
|
|
29
|
+
describe('Constructor', () => {
|
|
30
|
+
it('should initialize with default properties', () => {
|
|
31
|
+
let levelsSet = new LevelsSet();
|
|
32
|
+
assert.ok(levelsSet);
|
|
33
|
+
assert.strictEqual(levelsSet.owner, false);
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
it('should initialize with owner', () => {
|
|
37
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
38
|
+
assert.strictEqual(levelsSet.owner, mockOwner);
|
|
39
|
+
});
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
describe('init', () => {
|
|
43
|
+
it('should return false when owner is undefined', async () => {
|
|
44
|
+
let levelsSet = new LevelsSet();
|
|
45
|
+
let result = await levelsSet.init({levels: {}});
|
|
46
|
+
assert.strictEqual(result, false);
|
|
47
|
+
});
|
|
48
|
+
|
|
49
|
+
it('should return false when owner has no getPosition method', async () => {
|
|
50
|
+
let invalidOwner = {id: 'test'};
|
|
51
|
+
let levelsSet = new LevelsSet({owner: invalidOwner});
|
|
52
|
+
let result = await levelsSet.init({levels: {}});
|
|
53
|
+
assert.strictEqual(result, false);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
it('should return false when levels are not provided', async () => {
|
|
57
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
58
|
+
let result = await levelsSet.init({});
|
|
59
|
+
assert.strictEqual(result, false);
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
it('should initialize successfully with valid data', async () => {
|
|
63
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
64
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
65
|
+
await levelsSet.init({
|
|
66
|
+
levels: levels,
|
|
67
|
+
currentLevel: 1,
|
|
68
|
+
currentExp: 0
|
|
69
|
+
});
|
|
70
|
+
assert.strictEqual(levelsSet.currentLevel, 1);
|
|
71
|
+
assert.strictEqual(levelsSet.currentExp, 0);
|
|
72
|
+
assert.ok(levelsSet.levels);
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
it('should auto-fill levels when autoFillRanges is true', async () => {
|
|
76
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
77
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
78
|
+
await levelsSet.init({
|
|
79
|
+
levels: levels,
|
|
80
|
+
currentLevel: 1,
|
|
81
|
+
currentExp: 0,
|
|
82
|
+
autoFillRanges: true
|
|
83
|
+
});
|
|
84
|
+
assert.ok(levelsSet.levels[4]);
|
|
85
|
+
assert.strictEqual(levelsSet.levels[4].key, 4);
|
|
86
|
+
});
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
describe('levelUp', () => {
|
|
90
|
+
it('should increase level by 1', async () => {
|
|
91
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
92
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
93
|
+
await levelsSet.init({
|
|
94
|
+
levels: levels,
|
|
95
|
+
currentLevel: 1,
|
|
96
|
+
currentExp: 0
|
|
97
|
+
});
|
|
98
|
+
await levelsSet.levelUp();
|
|
99
|
+
assert.strictEqual(levelsSet.currentLevel, 2);
|
|
100
|
+
});
|
|
101
|
+
|
|
102
|
+
it('should return false at max level', async () => {
|
|
103
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
104
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
105
|
+
await levelsSet.init({
|
|
106
|
+
levels: levels,
|
|
107
|
+
currentLevel: 5,
|
|
108
|
+
currentExp: 0
|
|
109
|
+
});
|
|
110
|
+
let result = await levelsSet.levelUp();
|
|
111
|
+
assert.strictEqual(result, false);
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
it('should fire LEVEL_UP event', async () => {
|
|
115
|
+
let eventFired = false;
|
|
116
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
117
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
118
|
+
await levelsSet.init({
|
|
119
|
+
levels: levels,
|
|
120
|
+
currentLevel: 1,
|
|
121
|
+
currentExp: 0
|
|
122
|
+
});
|
|
123
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_UP, () => {
|
|
124
|
+
eventFired = true;
|
|
125
|
+
}, 'test-listener');
|
|
126
|
+
await levelsSet.levelUp();
|
|
127
|
+
assert.strictEqual(eventFired, true);
|
|
128
|
+
});
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
describe('levelDown', () => {
|
|
132
|
+
it('should decrease level by 1', async () => {
|
|
133
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
134
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
135
|
+
await levelsSet.init({
|
|
136
|
+
levels: levels,
|
|
137
|
+
currentLevel: 2,
|
|
138
|
+
currentExp: 100
|
|
139
|
+
});
|
|
140
|
+
await levelsSet.levelDown();
|
|
141
|
+
assert.strictEqual(levelsSet.currentLevel, 1);
|
|
142
|
+
});
|
|
143
|
+
|
|
144
|
+
it('should return false at level 1', async () => {
|
|
145
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
146
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
147
|
+
await levelsSet.init({
|
|
148
|
+
levels: levels,
|
|
149
|
+
currentLevel: 1,
|
|
150
|
+
currentExp: 0
|
|
151
|
+
});
|
|
152
|
+
let result = await levelsSet.levelDown();
|
|
153
|
+
assert.strictEqual(result, false);
|
|
154
|
+
});
|
|
155
|
+
});
|
|
156
|
+
|
|
157
|
+
describe('addExperience', () => {
|
|
158
|
+
it('should add experience correctly', async () => {
|
|
159
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
160
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
161
|
+
await levelsSet.init({
|
|
162
|
+
levels: levels,
|
|
163
|
+
currentLevel: 1,
|
|
164
|
+
currentExp: 0,
|
|
165
|
+
increaseLevelsWithExperience: false
|
|
166
|
+
});
|
|
167
|
+
await levelsSet.addExperience(50);
|
|
168
|
+
assert.strictEqual(levelsSet.currentExp, 50);
|
|
169
|
+
});
|
|
170
|
+
|
|
171
|
+
it('should auto level up when experience threshold is reached', async () => {
|
|
172
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
173
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
174
|
+
await levelsSet.init({
|
|
175
|
+
levels: levels,
|
|
176
|
+
currentLevel: 1,
|
|
177
|
+
currentExp: 0,
|
|
178
|
+
increaseLevelsWithExperience: true
|
|
179
|
+
});
|
|
180
|
+
await levelsSet.addExperience(100);
|
|
181
|
+
assert.strictEqual(levelsSet.currentLevel, 2);
|
|
182
|
+
assert.strictEqual(levelsSet.currentExp, 100);
|
|
183
|
+
});
|
|
184
|
+
|
|
185
|
+
it('should fire LEVEL_EXPERIENCE_ADDED event', async () => {
|
|
186
|
+
let eventFired = false;
|
|
187
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
188
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
189
|
+
await levelsSet.init({
|
|
190
|
+
levels: levels,
|
|
191
|
+
currentLevel: 1,
|
|
192
|
+
currentExp: 0
|
|
193
|
+
});
|
|
194
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_EXPERIENCE_ADDED, () => {
|
|
195
|
+
eventFired = true;
|
|
196
|
+
}, 'test-listener-exp');
|
|
197
|
+
await levelsSet.addExperience(50);
|
|
198
|
+
assert.strictEqual(eventFired, true);
|
|
199
|
+
});
|
|
200
|
+
});
|
|
201
|
+
|
|
202
|
+
describe('getNextLevelExperience', () => {
|
|
203
|
+
it('should return next level required experience', async () => {
|
|
204
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
205
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
206
|
+
await levelsSet.init({
|
|
207
|
+
levels: levels,
|
|
208
|
+
currentLevel: 1,
|
|
209
|
+
currentExp: 0
|
|
210
|
+
});
|
|
211
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
212
|
+
assert.strictEqual(nextExp, 100);
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
it('should return current level experience at max level', async () => {
|
|
216
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
217
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
218
|
+
await levelsSet.init({
|
|
219
|
+
levels: levels,
|
|
220
|
+
currentLevel: 5,
|
|
221
|
+
currentExp: 500
|
|
222
|
+
});
|
|
223
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
224
|
+
assert.strictEqual(nextExp, 500);
|
|
225
|
+
});
|
|
226
|
+
});
|
|
227
|
+
|
|
228
|
+
describe('getLevelInstance', () => {
|
|
229
|
+
it('should return level instance by key', async () => {
|
|
230
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
231
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
232
|
+
await levelsSet.init({
|
|
233
|
+
levels: levels,
|
|
234
|
+
currentLevel: 1,
|
|
235
|
+
currentExp: 0
|
|
236
|
+
});
|
|
237
|
+
let level = levelsSet.getLevelInstance(2);
|
|
238
|
+
assert.ok(level);
|
|
239
|
+
assert.strictEqual(level.key, 2);
|
|
240
|
+
});
|
|
241
|
+
|
|
242
|
+
it('should return false for non-existent level', async () => {
|
|
243
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
244
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
245
|
+
await levelsSet.init({
|
|
246
|
+
levels: levels,
|
|
247
|
+
currentLevel: 1,
|
|
248
|
+
currentExp: 0
|
|
249
|
+
});
|
|
250
|
+
let level = levelsSet.getLevelInstance(99);
|
|
251
|
+
assert.strictEqual(level, false);
|
|
252
|
+
});
|
|
253
|
+
|
|
254
|
+
it('should handle string level keys', async () => {
|
|
255
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
256
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
257
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
258
|
+
let level = levelsSet.getLevelInstance('2');
|
|
259
|
+
assert.ok(level);
|
|
260
|
+
});
|
|
261
|
+
|
|
262
|
+
it('should handle null level key', async () => {
|
|
263
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
264
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
265
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
266
|
+
let level = levelsSet.getLevelInstance(null);
|
|
267
|
+
assert.strictEqual(level, false);
|
|
268
|
+
});
|
|
269
|
+
|
|
270
|
+
it('should handle undefined level key', async () => {
|
|
271
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
272
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
273
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
274
|
+
let level = levelsSet.getLevelInstance(undefined);
|
|
275
|
+
assert.strictEqual(level, false);
|
|
276
|
+
});
|
|
277
|
+
});
|
|
278
|
+
|
|
279
|
+
describe('Event System - Parameter Variations', () => {
|
|
280
|
+
it('should fire INIT_LEVEL_SET_START with removeKey only', async () => {
|
|
281
|
+
let eventFired = false;
|
|
282
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
283
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
284
|
+
levelsSet.setOwner({owner: mockOwner});
|
|
285
|
+
levelsSet.listenEvent(SkillsEvents.INIT_LEVEL_SET_START, () => {
|
|
286
|
+
eventFired = true;
|
|
287
|
+
}, 'init-start-key');
|
|
288
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
289
|
+
assert.strictEqual(eventFired, true);
|
|
290
|
+
});
|
|
291
|
+
|
|
292
|
+
it('should fire INIT_LEVEL_SET_END with masterKey', async () => {
|
|
293
|
+
let eventFired = false;
|
|
294
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
295
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
296
|
+
let masterKey = levelsSet.getOwnerEventKey();
|
|
297
|
+
levelsSet.listenEvent(SkillsEvents.INIT_LEVEL_SET_END, () => {
|
|
298
|
+
eventFired = true;
|
|
299
|
+
}, 'init-end-sub', masterKey);
|
|
300
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
301
|
+
assert.strictEqual(eventFired, true);
|
|
302
|
+
});
|
|
303
|
+
|
|
304
|
+
it('should fire SET_LEVELS without any keys', async () => {
|
|
305
|
+
let eventFired = false;
|
|
306
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
307
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
308
|
+
levelsSet.listenEvent(SkillsEvents.SET_LEVELS, () => {
|
|
309
|
+
eventFired = true;
|
|
310
|
+
});
|
|
311
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
312
|
+
assert.strictEqual(eventFired, true);
|
|
313
|
+
});
|
|
314
|
+
|
|
315
|
+
it('should fire LEVEL_DOWN event', async () => {
|
|
316
|
+
let eventFired = false;
|
|
317
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
318
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
319
|
+
await levelsSet.init({levels: levels, currentLevel: 2, currentExp: 100});
|
|
320
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_DOWN, () => {
|
|
321
|
+
eventFired = true;
|
|
322
|
+
}, 'level-down-test');
|
|
323
|
+
await levelsSet.levelDown();
|
|
324
|
+
assert.strictEqual(eventFired, true);
|
|
325
|
+
});
|
|
326
|
+
|
|
327
|
+
it('should fire LEVEL_APPLY_MODIFIERS event', async () => {
|
|
328
|
+
let eventFired = false;
|
|
329
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
330
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
331
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
332
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_APPLY_MODIFIERS, () => {
|
|
333
|
+
eventFired = true;
|
|
334
|
+
}, 'apply-modifiers-test');
|
|
335
|
+
await levelsSet.levelUp();
|
|
336
|
+
assert.strictEqual(eventFired, true);
|
|
337
|
+
});
|
|
338
|
+
|
|
339
|
+
it('should fire GENERATED_LEVELS event when auto-filling', async () => {
|
|
340
|
+
let eventFired = false;
|
|
341
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
342
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
343
|
+
levelsSet.listenEvent(SkillsEvents.GENERATED_LEVELS, () => {
|
|
344
|
+
eventFired = true;
|
|
345
|
+
}, 'generated-levels-test');
|
|
346
|
+
await levelsSet.init({
|
|
347
|
+
levels: levels,
|
|
348
|
+
currentLevel: 1,
|
|
349
|
+
currentExp: 0,
|
|
350
|
+
autoFillRanges: true
|
|
351
|
+
});
|
|
352
|
+
assert.strictEqual(eventFired, true);
|
|
353
|
+
});
|
|
354
|
+
|
|
355
|
+
it('should handle multiple listeners on same event', async () => {
|
|
356
|
+
let count = 0;
|
|
357
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
358
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
359
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_UP, () => { count++; }, 'listener1');
|
|
360
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_UP, () => { count++; }, 'listener2');
|
|
361
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_UP, () => { count++; }, 'listener3');
|
|
362
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
363
|
+
await levelsSet.levelUp();
|
|
364
|
+
assert.strictEqual(count, 3);
|
|
365
|
+
});
|
|
366
|
+
});
|
|
367
|
+
|
|
368
|
+
describe('Error Conditions - Invalid Inputs', () => {
|
|
369
|
+
it('should return false when levels is empty object', async () => {
|
|
370
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
371
|
+
let result = await levelsSet.init({levels: {}});
|
|
372
|
+
assert.strictEqual(result, false);
|
|
373
|
+
});
|
|
374
|
+
|
|
375
|
+
it('should return false when levels is null', async () => {
|
|
376
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
377
|
+
let result = await levelsSet.init({levels: null, owner: mockOwner});
|
|
378
|
+
assert.strictEqual(result, false);
|
|
379
|
+
});
|
|
380
|
+
|
|
381
|
+
it('should return false when levels is array', async () => {
|
|
382
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
383
|
+
let result = await levelsSet.init({levels: []});
|
|
384
|
+
assert.strictEqual(result, false);
|
|
385
|
+
});
|
|
386
|
+
|
|
387
|
+
it('should handle null owner', async () => {
|
|
388
|
+
let levelsSet = new LevelsSet({owner: null});
|
|
389
|
+
let result = await levelsSet.init({levels: {}});
|
|
390
|
+
assert.strictEqual(result, false);
|
|
391
|
+
});
|
|
392
|
+
|
|
393
|
+
it('should handle undefined owner', async () => {
|
|
394
|
+
let levelsSet = new LevelsSet({owner: undefined});
|
|
395
|
+
let result = await levelsSet.init({levels: {}});
|
|
396
|
+
assert.strictEqual(result, false);
|
|
397
|
+
});
|
|
398
|
+
|
|
399
|
+
it('should return false in setOwner when owner is missing', () => {
|
|
400
|
+
let levelsSet = new LevelsSet();
|
|
401
|
+
let result = levelsSet.setOwner({});
|
|
402
|
+
assert.strictEqual(result, false);
|
|
403
|
+
});
|
|
404
|
+
|
|
405
|
+
it('should return false in setOwner when owner has no getPosition', () => {
|
|
406
|
+
let levelsSet = new LevelsSet();
|
|
407
|
+
let result = levelsSet.setOwner({owner: {id: 'test'}});
|
|
408
|
+
assert.strictEqual(result, false);
|
|
409
|
+
});
|
|
410
|
+
});
|
|
411
|
+
|
|
412
|
+
describe('Edge Cases - Auto-Fill', () => {
|
|
413
|
+
it('should auto-fill with custom multiplier', async () => {
|
|
414
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
415
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
416
|
+
await levelsSet.init({
|
|
417
|
+
levels: levels,
|
|
418
|
+
currentLevel: 1,
|
|
419
|
+
currentExp: 0,
|
|
420
|
+
autoFillRanges: true,
|
|
421
|
+
autoFillExperienceMultiplier: 2
|
|
422
|
+
});
|
|
423
|
+
assert.ok(levelsSet.levels[4]);
|
|
424
|
+
assert.strictEqual(levelsSet.autoFillExperienceMultiplier, 2);
|
|
425
|
+
});
|
|
426
|
+
|
|
427
|
+
it('should handle zero multiplier', async () => {
|
|
428
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
429
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
430
|
+
await levelsSet.init({
|
|
431
|
+
levels: levels,
|
|
432
|
+
currentLevel: 1,
|
|
433
|
+
currentExp: 0,
|
|
434
|
+
autoFillRanges: true,
|
|
435
|
+
autoFillExperienceMultiplier: 0
|
|
436
|
+
});
|
|
437
|
+
assert.strictEqual(levelsSet.autoFillExperienceMultiplier, 0);
|
|
438
|
+
});
|
|
439
|
+
|
|
440
|
+
it('should handle negative multiplier', async () => {
|
|
441
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
442
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
443
|
+
await levelsSet.init({
|
|
444
|
+
levels: levels,
|
|
445
|
+
currentLevel: 1,
|
|
446
|
+
currentExp: 0,
|
|
447
|
+
autoFillRanges: true,
|
|
448
|
+
autoFillExperienceMultiplier: -1
|
|
449
|
+
});
|
|
450
|
+
assert.strictEqual(levelsSet.autoFillExperienceMultiplier, -1);
|
|
451
|
+
});
|
|
452
|
+
|
|
453
|
+
it('should not auto-fill when disabled', async () => {
|
|
454
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
455
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
456
|
+
await levelsSet.init({
|
|
457
|
+
levels: levels,
|
|
458
|
+
currentLevel: 1,
|
|
459
|
+
currentExp: 0,
|
|
460
|
+
autoFillRanges: false
|
|
461
|
+
});
|
|
462
|
+
assert.strictEqual(levelsSet.levels[4], undefined);
|
|
463
|
+
});
|
|
464
|
+
});
|
|
465
|
+
|
|
466
|
+
describe('Edge Cases - Level Boundaries', () => {
|
|
467
|
+
it('should handle currentLevel 0', async () => {
|
|
468
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
469
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
470
|
+
await levelsSet.init({levels: levels, currentLevel: 0, currentExp: 0});
|
|
471
|
+
assert.strictEqual(levelsSet.currentLevel, 0);
|
|
472
|
+
});
|
|
473
|
+
|
|
474
|
+
it('should handle negative currentLevel', async () => {
|
|
475
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
476
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
477
|
+
await levelsSet.init({levels: levels, currentLevel: -1, currentExp: 0});
|
|
478
|
+
assert.strictEqual(levelsSet.currentLevel, -1);
|
|
479
|
+
});
|
|
480
|
+
|
|
481
|
+
it('should handle level beyond max defined level', async () => {
|
|
482
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
483
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
484
|
+
await levelsSet.init({levels: levels, currentLevel: 100, currentExp: 0});
|
|
485
|
+
assert.strictEqual(levelsSet.currentLevel, 100);
|
|
486
|
+
});
|
|
487
|
+
});
|
|
488
|
+
|
|
489
|
+
describe('Edge Cases - Experience', () => {
|
|
490
|
+
it('should add negative experience', async () => {
|
|
491
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
492
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
493
|
+
await levelsSet.init({
|
|
494
|
+
levels: levels,
|
|
495
|
+
currentLevel: 1,
|
|
496
|
+
currentExp: 100,
|
|
497
|
+
increaseLevelsWithExperience: false
|
|
498
|
+
});
|
|
499
|
+
await levelsSet.addExperience(-50);
|
|
500
|
+
assert.strictEqual(levelsSet.currentExp, 50);
|
|
501
|
+
});
|
|
502
|
+
|
|
503
|
+
it('should handle zero experience addition', async () => {
|
|
504
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
505
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
506
|
+
await levelsSet.init({
|
|
507
|
+
levels: levels,
|
|
508
|
+
currentLevel: 1,
|
|
509
|
+
currentExp: 50,
|
|
510
|
+
increaseLevelsWithExperience: false
|
|
511
|
+
});
|
|
512
|
+
await levelsSet.addExperience(0);
|
|
513
|
+
assert.strictEqual(levelsSet.currentExp, 50);
|
|
514
|
+
});
|
|
515
|
+
|
|
516
|
+
it('should handle very large experience addition', async () => {
|
|
517
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
518
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
519
|
+
await levelsSet.init({
|
|
520
|
+
levels: levels,
|
|
521
|
+
currentLevel: 1,
|
|
522
|
+
currentExp: 0,
|
|
523
|
+
increaseLevelsWithExperience: true,
|
|
524
|
+
autoFillRanges: true
|
|
525
|
+
});
|
|
526
|
+
await levelsSet.addExperience(10000);
|
|
527
|
+
assert.strictEqual(levelsSet.currentLevel, 5);
|
|
528
|
+
});
|
|
529
|
+
|
|
530
|
+
it('should handle decimal experience values', async () => {
|
|
531
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
532
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
533
|
+
await levelsSet.init({
|
|
534
|
+
levels: levels,
|
|
535
|
+
currentLevel: 1,
|
|
536
|
+
currentExp: 0,
|
|
537
|
+
increaseLevelsWithExperience: false
|
|
538
|
+
});
|
|
539
|
+
await levelsSet.addExperience(50.5);
|
|
540
|
+
assert.strictEqual(levelsSet.currentExp, 50.5);
|
|
541
|
+
});
|
|
542
|
+
|
|
543
|
+
it('should cap experience at max level when setRequiredExperienceLimit enabled', async () => {
|
|
544
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
545
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
546
|
+
await levelsSet.init({
|
|
547
|
+
levels: levels,
|
|
548
|
+
currentLevel: 5,
|
|
549
|
+
currentExp: 500,
|
|
550
|
+
increaseLevelsWithExperience: true,
|
|
551
|
+
setRequiredExperienceLimit: true
|
|
552
|
+
});
|
|
553
|
+
await levelsSet.addExperience(1000);
|
|
554
|
+
assert.strictEqual(levelsSet.currentExp, 500);
|
|
555
|
+
});
|
|
556
|
+
|
|
557
|
+
it('should not cap experience when setRequiredExperienceLimit disabled', async () => {
|
|
558
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
559
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
560
|
+
await levelsSet.init({
|
|
561
|
+
levels: levels,
|
|
562
|
+
currentLevel: 5,
|
|
563
|
+
currentExp: 500,
|
|
564
|
+
increaseLevelsWithExperience: false,
|
|
565
|
+
setRequiredExperienceLimit: false
|
|
566
|
+
});
|
|
567
|
+
await levelsSet.addExperience(1000);
|
|
568
|
+
assert.strictEqual(levelsSet.currentExp, 1500);
|
|
569
|
+
});
|
|
570
|
+
|
|
571
|
+
it('should not auto-level when disabled', async () => {
|
|
572
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
573
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
574
|
+
await levelsSet.init({
|
|
575
|
+
levels: levels,
|
|
576
|
+
currentLevel: 1,
|
|
577
|
+
currentExp: 0,
|
|
578
|
+
increaseLevelsWithExperience: false
|
|
579
|
+
});
|
|
580
|
+
await levelsSet.addExperience(100);
|
|
581
|
+
assert.strictEqual(levelsSet.currentLevel, 1);
|
|
582
|
+
assert.strictEqual(levelsSet.currentExp, 100);
|
|
583
|
+
});
|
|
584
|
+
|
|
585
|
+
it('should skip multiple levels with large experience gain', async () => {
|
|
586
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
587
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
588
|
+
await levelsSet.init({
|
|
589
|
+
levels: levels,
|
|
590
|
+
currentLevel: 1,
|
|
591
|
+
currentExp: 0,
|
|
592
|
+
increaseLevelsWithExperience: true
|
|
593
|
+
});
|
|
594
|
+
await levelsSet.addExperience(300);
|
|
595
|
+
assert.strictEqual(levelsSet.currentLevel, 3);
|
|
596
|
+
});
|
|
597
|
+
});
|
|
598
|
+
|
|
599
|
+
describe('Edge Cases - Modifiers', () => {
|
|
600
|
+
it('should apply modifiers on level up', async () => {
|
|
601
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
602
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
603
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
604
|
+
let initialMaxHp = mockOwner.stats.maxHp;
|
|
605
|
+
await levelsSet.levelUp();
|
|
606
|
+
assert.ok(mockOwner.stats.maxHp !== initialMaxHp);
|
|
607
|
+
});
|
|
608
|
+
|
|
609
|
+
it('should revert modifiers on level down', async () => {
|
|
610
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
611
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
612
|
+
await levelsSet.init({levels: levels, currentLevel: 2, currentExp: 100});
|
|
613
|
+
let levelTwoMaxHp = mockOwner.stats.maxHp;
|
|
614
|
+
await levelsSet.levelDown();
|
|
615
|
+
assert.ok(mockOwner.stats.maxHp !== levelTwoMaxHp);
|
|
616
|
+
});
|
|
617
|
+
|
|
618
|
+
it('should return false when applying modifiers for non-existent level', async () => {
|
|
619
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
620
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
621
|
+
await levelsSet.init({levels: levels, currentLevel: 100, currentExp: 0});
|
|
622
|
+
let result = await levelsSet.applyLevelModifiers();
|
|
623
|
+
assert.strictEqual(result, false);
|
|
624
|
+
});
|
|
625
|
+
|
|
626
|
+
it('should handle level with no modifiers', async () => {
|
|
627
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
628
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
629
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
630
|
+
let result = await levelsSet.applyLevelModifiers();
|
|
631
|
+
assert.strictEqual(result, false);
|
|
632
|
+
});
|
|
633
|
+
|
|
634
|
+
it('should handle level with empty modifiers array', async () => {
|
|
635
|
+
let levels = {
|
|
636
|
+
1: new Level({key: 1, modifiers: [], requiredExperience: 0})
|
|
637
|
+
};
|
|
638
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
639
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
640
|
+
let result = await levelsSet.applyLevelModifiers();
|
|
641
|
+
assert.strictEqual(result, false);
|
|
642
|
+
});
|
|
643
|
+
});
|
|
644
|
+
|
|
645
|
+
describe('Edge Cases - Owner ID', () => {
|
|
646
|
+
it('should use default ownerIdProperty', async () => {
|
|
647
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
648
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
649
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
650
|
+
assert.strictEqual(levelsSet.getOwnerId(), 'mock-owner-1');
|
|
651
|
+
});
|
|
652
|
+
|
|
653
|
+
it('should use custom ownerIdProperty', () => {
|
|
654
|
+
let customOwner = {
|
|
655
|
+
customId: 'custom-123',
|
|
656
|
+
getPosition: () => ({x: 0, y: 0})
|
|
657
|
+
};
|
|
658
|
+
let levelsSet = new LevelsSet({owner: customOwner});
|
|
659
|
+
levelsSet.setOwner({owner: customOwner, ownerIdProperty: 'customId'});
|
|
660
|
+
assert.strictEqual(levelsSet.getOwnerId(), 'custom-123');
|
|
661
|
+
});
|
|
662
|
+
|
|
663
|
+
it('should handle numeric owner IDs', () => {
|
|
664
|
+
mockOwner.id = 12345;
|
|
665
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
666
|
+
levelsSet.setOwner({owner: mockOwner});
|
|
667
|
+
assert.strictEqual(levelsSet.getOwnerId(), 12345);
|
|
668
|
+
});
|
|
669
|
+
|
|
670
|
+
it('should handle string owner IDs', () => {
|
|
671
|
+
mockOwner.id = 'player-uuid-abc-123';
|
|
672
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
673
|
+
levelsSet.setOwner({owner: mockOwner});
|
|
674
|
+
assert.strictEqual(levelsSet.getOwnerId(), 'player-uuid-abc-123');
|
|
675
|
+
});
|
|
676
|
+
});
|
|
677
|
+
|
|
678
|
+
describe('Edge Cases - Sorting and Utilities', () => {
|
|
679
|
+
it('should sort levels by key correctly', async () => {
|
|
680
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
681
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
682
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
683
|
+
let sorted = levelsSet.sortLevelsBy(levels);
|
|
684
|
+
assert.ok(Array.isArray(sorted));
|
|
685
|
+
assert.strictEqual(sorted[0], '1');
|
|
686
|
+
});
|
|
687
|
+
|
|
688
|
+
it('should sort levels by custom field', async () => {
|
|
689
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
690
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
691
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
692
|
+
let sorted = levelsSet.sortLevelsBy(levels, 'requiredExperience');
|
|
693
|
+
assert.ok(Array.isArray(sorted));
|
|
694
|
+
});
|
|
695
|
+
|
|
696
|
+
it('should handle empty levels object for sorting', () => {
|
|
697
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
698
|
+
let sorted = levelsSet.sortLevelsBy({});
|
|
699
|
+
assert.ok(Array.isArray(sorted));
|
|
700
|
+
assert.strictEqual(sorted.length, 0);
|
|
701
|
+
});
|
|
702
|
+
|
|
703
|
+
it('should generate unique event keys', async () => {
|
|
704
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
705
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
706
|
+
await levelsSet.init({levels: levels, currentLevel: 1, currentExp: 0});
|
|
707
|
+
let key1 = levelsSet.getOwnerUniqueEventKey('test');
|
|
708
|
+
await TestHelpers.sleep(1);
|
|
709
|
+
let key2 = levelsSet.getOwnerUniqueEventKey('test');
|
|
710
|
+
assert.ok(key1 !== key2);
|
|
711
|
+
});
|
|
712
|
+
|
|
713
|
+
it('should handle experience overflow', async () => {
|
|
714
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
715
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
716
|
+
await levelsSet.init({
|
|
717
|
+
levels: levels,
|
|
718
|
+
currentLevel: 1,
|
|
719
|
+
currentExp: 150,
|
|
720
|
+
increaseLevelsWithExperience: false
|
|
721
|
+
});
|
|
722
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
723
|
+
assert.ok(nextExp > 0);
|
|
724
|
+
});
|
|
725
|
+
});
|
|
726
|
+
|
|
727
|
+
describe('getNextLevelExperience - All Return Paths', () => {
|
|
728
|
+
it('should return 0 when increaseLevelsWithExperience is false', async () => {
|
|
729
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
730
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
731
|
+
await levelsSet.init({
|
|
732
|
+
levels: levels,
|
|
733
|
+
currentLevel: 1,
|
|
734
|
+
increaseLevelsWithExperience: false
|
|
735
|
+
});
|
|
736
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
737
|
+
assert.strictEqual(nextExp, 100);
|
|
738
|
+
});
|
|
739
|
+
|
|
740
|
+
it('should return 0 when no next level exists', async () => {
|
|
741
|
+
let levels = {5: new Level({key: 5, requiredExperience: 500})};
|
|
742
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
743
|
+
await levelsSet.init({
|
|
744
|
+
levels: levels,
|
|
745
|
+
currentLevel: 5
|
|
746
|
+
});
|
|
747
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
748
|
+
assert.strictEqual(nextExp, 500);
|
|
749
|
+
});
|
|
750
|
+
|
|
751
|
+
it('should return next level required experience when next level exists', async () => {
|
|
752
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
753
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
754
|
+
await levelsSet.init({
|
|
755
|
+
levels: levels,
|
|
756
|
+
currentLevel: 1
|
|
757
|
+
});
|
|
758
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
759
|
+
assert.strictEqual(nextExp, 100);
|
|
760
|
+
});
|
|
761
|
+
|
|
762
|
+
it('should return required experience limit when setRequiredExperienceLimit is true', async () => {
|
|
763
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
764
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
765
|
+
await levelsSet.init({
|
|
766
|
+
levels: levels,
|
|
767
|
+
currentLevel: 5,
|
|
768
|
+
setRequiredExperienceLimit: true
|
|
769
|
+
});
|
|
770
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
771
|
+
assert.strictEqual(nextExp, 500);
|
|
772
|
+
});
|
|
773
|
+
});
|
|
774
|
+
|
|
775
|
+
describe('getNextLevelExperience - Edge Cases', () => {
|
|
776
|
+
it('should handle currentLevel = 0', async () => {
|
|
777
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
778
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
779
|
+
await levelsSet.init({
|
|
780
|
+
levels: levels,
|
|
781
|
+
currentLevel: 0
|
|
782
|
+
});
|
|
783
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
784
|
+
assert.ok(typeof nextExp === 'number');
|
|
785
|
+
});
|
|
786
|
+
|
|
787
|
+
it('should handle currentLevel = negative', async () => {
|
|
788
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
789
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
790
|
+
await levelsSet.init({
|
|
791
|
+
levels: levels,
|
|
792
|
+
currentLevel: -5
|
|
793
|
+
});
|
|
794
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
795
|
+
assert.ok(typeof nextExp === 'number');
|
|
796
|
+
});
|
|
797
|
+
|
|
798
|
+
it('should handle currentLevel beyond max', async () => {
|
|
799
|
+
let levels = {1: new Level({key: 1, requiredExperience: 0})};
|
|
800
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
801
|
+
await levelsSet.init({
|
|
802
|
+
levels: levels,
|
|
803
|
+
currentLevel: 100
|
|
804
|
+
});
|
|
805
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
806
|
+
assert.strictEqual(nextExp, 0);
|
|
807
|
+
});
|
|
808
|
+
|
|
809
|
+
it('should handle nextLevelKey is undefined', async () => {
|
|
810
|
+
let levels = {
|
|
811
|
+
1: new Level({key: 1, requiredExperience: 0}),
|
|
812
|
+
5: new Level({key: 5, requiredExperience: 500})
|
|
813
|
+
};
|
|
814
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
815
|
+
await levelsSet.init({
|
|
816
|
+
levels: levels,
|
|
817
|
+
currentLevel: 5,
|
|
818
|
+
levelsByExperience: ['1']
|
|
819
|
+
});
|
|
820
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
821
|
+
assert.ok(typeof nextExp === 'number');
|
|
822
|
+
});
|
|
823
|
+
});
|
|
824
|
+
|
|
825
|
+
describe('init - levelsByExperience Custom Ordering', () => {
|
|
826
|
+
it('should use custom levelsByExperience when provided', async () => {
|
|
827
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
828
|
+
let customOrder = ['5', '3', '2', '1'];
|
|
829
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
830
|
+
await levelsSet.init({
|
|
831
|
+
levels: levels,
|
|
832
|
+
currentLevel: 1,
|
|
833
|
+
levelsByExperience: customOrder
|
|
834
|
+
});
|
|
835
|
+
assert.deepStrictEqual(levelsSet.levelsByExperience, customOrder);
|
|
836
|
+
});
|
|
837
|
+
});
|
|
838
|
+
|
|
839
|
+
describe('init - setRequiredExperienceLimit Edge Cases', () => {
|
|
840
|
+
it('should cap experience at max level when setRequiredExperienceLimit is true', async () => {
|
|
841
|
+
let levels = {
|
|
842
|
+
1: new Level({key: 1, requiredExperience: 0}),
|
|
843
|
+
5: new Level({key: 5, requiredExperience: 500})
|
|
844
|
+
};
|
|
845
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
846
|
+
await levelsSet.init({
|
|
847
|
+
levels: levels,
|
|
848
|
+
currentLevel: 5,
|
|
849
|
+
setRequiredExperienceLimit: true
|
|
850
|
+
});
|
|
851
|
+
let nextExp = levelsSet.getNextLevelExperience();
|
|
852
|
+
assert.strictEqual(nextExp, 500);
|
|
853
|
+
});
|
|
854
|
+
});
|
|
855
|
+
|
|
856
|
+
describe('init - Event Firing Order', () => {
|
|
857
|
+
it('should fire INIT_LEVEL_SET_START then INIT_LEVEL_SET_END', async () => {
|
|
858
|
+
let eventOrder = [];
|
|
859
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
860
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
861
|
+
levelsSet.listenEvent(SkillsEvents.INIT_LEVEL_SET_START, () => {
|
|
862
|
+
eventOrder.push('START');
|
|
863
|
+
}, 'start-listener');
|
|
864
|
+
levelsSet.listenEvent(SkillsEvents.INIT_LEVEL_SET_END, () => {
|
|
865
|
+
eventOrder.push('END');
|
|
866
|
+
}, 'end-listener');
|
|
867
|
+
await levelsSet.init({
|
|
868
|
+
levels: levels,
|
|
869
|
+
currentLevel: 1
|
|
870
|
+
});
|
|
871
|
+
assert.deepStrictEqual(eventOrder, ['START', 'END']);
|
|
872
|
+
});
|
|
873
|
+
});
|
|
874
|
+
|
|
875
|
+
describe('createLevels - Multiplier Variations', () => {
|
|
876
|
+
it('should handle very large multiplier values > 100', async () => {
|
|
877
|
+
let levels = {
|
|
878
|
+
1: new Level({key: 1, requiredExperience: 10}),
|
|
879
|
+
5: new Level({key: 5, requiredExperience: 1000})
|
|
880
|
+
};
|
|
881
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
882
|
+
await levelsSet.init({
|
|
883
|
+
levels: levels,
|
|
884
|
+
currentLevel: 1,
|
|
885
|
+
autoFillRanges: true,
|
|
886
|
+
autoFillExperienceMultiplier: 150
|
|
887
|
+
});
|
|
888
|
+
assert.ok(levelsSet.levels[2]);
|
|
889
|
+
assert.ok(levelsSet.levels[3]);
|
|
890
|
+
assert.ok(levelsSet.levels[4]);
|
|
891
|
+
});
|
|
892
|
+
|
|
893
|
+
it('should handle float multiplier values like 1.5', async () => {
|
|
894
|
+
let levels = {
|
|
895
|
+
1: new Level({key: 1, requiredExperience: 100}),
|
|
896
|
+
3: new Level({key: 3, requiredExperience: 300})
|
|
897
|
+
};
|
|
898
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
899
|
+
await levelsSet.init({
|
|
900
|
+
levels: levels,
|
|
901
|
+
currentLevel: 1,
|
|
902
|
+
autoFillRanges: true,
|
|
903
|
+
autoFillExperienceMultiplier: 1.5
|
|
904
|
+
});
|
|
905
|
+
assert.ok(levelsSet.levels[2]);
|
|
906
|
+
assert.strictEqual(levelsSet.levels[2].requiredExperience, 150);
|
|
907
|
+
});
|
|
908
|
+
|
|
909
|
+
it('should handle float multiplier values like 2.5', async () => {
|
|
910
|
+
let levels = {
|
|
911
|
+
1: new Level({key: 1, requiredExperience: 100}),
|
|
912
|
+
3: new Level({key: 3, requiredExperience: 300})
|
|
913
|
+
};
|
|
914
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
915
|
+
await levelsSet.init({
|
|
916
|
+
levels: levels,
|
|
917
|
+
currentLevel: 1,
|
|
918
|
+
autoFillRanges: true,
|
|
919
|
+
autoFillExperienceMultiplier: 2.5
|
|
920
|
+
});
|
|
921
|
+
assert.ok(levelsSet.levels[2]);
|
|
922
|
+
assert.strictEqual(levelsSet.levels[2].requiredExperience, 250);
|
|
923
|
+
});
|
|
924
|
+
});
|
|
925
|
+
|
|
926
|
+
describe('createLevels - Non-Sequential Level Keys', () => {
|
|
927
|
+
it('should auto-fill non-sequential level keys like 1, 3, 10, 20', async () => {
|
|
928
|
+
let levels = {
|
|
929
|
+
1: new Level({key: 1, requiredExperience: 10}),
|
|
930
|
+
3: new Level({key: 3, requiredExperience: 30}),
|
|
931
|
+
10: new Level({key: 10, requiredExperience: 100}),
|
|
932
|
+
20: new Level({key: 20, requiredExperience: 200})
|
|
933
|
+
};
|
|
934
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
935
|
+
await levelsSet.init({
|
|
936
|
+
levels: levels,
|
|
937
|
+
currentLevel: 1,
|
|
938
|
+
autoFillRanges: true
|
|
939
|
+
});
|
|
940
|
+
assert.ok(levelsSet.levels[2]);
|
|
941
|
+
assert.ok(levelsSet.levels[5]);
|
|
942
|
+
assert.ok(levelsSet.levels[15]);
|
|
943
|
+
});
|
|
944
|
+
});
|
|
945
|
+
|
|
946
|
+
describe('createLevels - Auto-fill with Single Level', () => {
|
|
947
|
+
it('should handle auto-fill with only one level', async () => {
|
|
948
|
+
let levels = {
|
|
949
|
+
1: new Level({key: 1, requiredExperience: 10})
|
|
950
|
+
};
|
|
951
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
952
|
+
await levelsSet.init({
|
|
953
|
+
levels: levels,
|
|
954
|
+
currentLevel: 1,
|
|
955
|
+
autoFillRanges: true
|
|
956
|
+
});
|
|
957
|
+
assert.strictEqual(Object.keys(levelsSet.levels).length, 1);
|
|
958
|
+
});
|
|
959
|
+
});
|
|
960
|
+
|
|
961
|
+
describe('levelUp - Edge Cases', () => {
|
|
962
|
+
it('should handle levelUp from level 0', async () => {
|
|
963
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
964
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
965
|
+
await levelsSet.init({
|
|
966
|
+
levels: levels,
|
|
967
|
+
currentLevel: 0
|
|
968
|
+
});
|
|
969
|
+
await levelsSet.levelUp();
|
|
970
|
+
assert.ok(levelsSet.currentLevel >= 0);
|
|
971
|
+
});
|
|
972
|
+
|
|
973
|
+
it('should handle levelUp from negative level', async () => {
|
|
974
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
975
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
976
|
+
await levelsSet.init({
|
|
977
|
+
levels: levels,
|
|
978
|
+
currentLevel: -5
|
|
979
|
+
});
|
|
980
|
+
await levelsSet.levelUp();
|
|
981
|
+
assert.ok(typeof levelsSet.currentLevel === 'number');
|
|
982
|
+
});
|
|
983
|
+
|
|
984
|
+
it('should handle multiple consecutive levelUp calls', async () => {
|
|
985
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
986
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
987
|
+
await levelsSet.init({
|
|
988
|
+
levels: levels,
|
|
989
|
+
currentLevel: 1
|
|
990
|
+
});
|
|
991
|
+
await levelsSet.levelUp();
|
|
992
|
+
await levelsSet.levelUp();
|
|
993
|
+
await levelsSet.levelUp();
|
|
994
|
+
assert.strictEqual(levelsSet.currentLevel, 4);
|
|
995
|
+
});
|
|
996
|
+
});
|
|
997
|
+
|
|
998
|
+
describe('levelDown - Edge Cases', () => {
|
|
999
|
+
it('should handle levelDown from level 0', async () => {
|
|
1000
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1001
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1002
|
+
await levelsSet.init({
|
|
1003
|
+
levels: levels,
|
|
1004
|
+
currentLevel: 0
|
|
1005
|
+
});
|
|
1006
|
+
let result = await levelsSet.levelDown();
|
|
1007
|
+
assert.strictEqual(result, false);
|
|
1008
|
+
});
|
|
1009
|
+
|
|
1010
|
+
it('should handle multiple consecutive levelDown calls', async () => {
|
|
1011
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1012
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1013
|
+
await levelsSet.init({
|
|
1014
|
+
levels: levels,
|
|
1015
|
+
currentLevel: 5
|
|
1016
|
+
});
|
|
1017
|
+
await levelsSet.levelDown();
|
|
1018
|
+
await levelsSet.levelDown();
|
|
1019
|
+
await levelsSet.levelDown();
|
|
1020
|
+
assert.strictEqual(levelsSet.currentLevel, 2);
|
|
1021
|
+
});
|
|
1022
|
+
|
|
1023
|
+
it('should maintain consistency on levelDown then levelUp round-trip', async () => {
|
|
1024
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1025
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1026
|
+
await levelsSet.init({
|
|
1027
|
+
levels: levels,
|
|
1028
|
+
currentLevel: 3
|
|
1029
|
+
});
|
|
1030
|
+
await levelsSet.levelDown();
|
|
1031
|
+
assert.strictEqual(levelsSet.currentLevel, 2);
|
|
1032
|
+
await levelsSet.levelUp();
|
|
1033
|
+
assert.strictEqual(levelsSet.currentLevel, 3);
|
|
1034
|
+
});
|
|
1035
|
+
});
|
|
1036
|
+
|
|
1037
|
+
describe('applyLevelModifiers - Error Handling', () => {
|
|
1038
|
+
it('should handle when Modifier.apply() throws error', async () => {
|
|
1039
|
+
let brokenModifier = new Modifier({
|
|
1040
|
+
key: 'broken-mod',
|
|
1041
|
+
propertyKey: 'stats/atk',
|
|
1042
|
+
operation: ModifierConst.OPS.INC,
|
|
1043
|
+
value: 10
|
|
1044
|
+
});
|
|
1045
|
+
brokenModifier.apply = () => {
|
|
1046
|
+
throw new Error('Modifier apply error');
|
|
1047
|
+
};
|
|
1048
|
+
let levels = {
|
|
1049
|
+
1: new Level({key: 1, requiredExperience: 0, modifiers: [brokenModifier]})
|
|
1050
|
+
};
|
|
1051
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1052
|
+
await levelsSet.init({
|
|
1053
|
+
levels: levels,
|
|
1054
|
+
currentLevel: 1
|
|
1055
|
+
});
|
|
1056
|
+
assert.ok(levelsSet);
|
|
1057
|
+
});
|
|
1058
|
+
|
|
1059
|
+
it('should handle when Modifier.revert() throws error', async () => {
|
|
1060
|
+
let brokenModifier = new Modifier({
|
|
1061
|
+
key: 'broken-revert',
|
|
1062
|
+
propertyKey: 'stats/atk',
|
|
1063
|
+
operation: ModifierConst.OPS.INC,
|
|
1064
|
+
value: 10
|
|
1065
|
+
});
|
|
1066
|
+
brokenModifier.revert = () => {
|
|
1067
|
+
throw new Error('Modifier revert error');
|
|
1068
|
+
};
|
|
1069
|
+
let levels = {
|
|
1070
|
+
1: new Level({key: 1, requiredExperience: 0, modifiers: [brokenModifier]}),
|
|
1071
|
+
2: new Level({key: 2, requiredExperience: 100})
|
|
1072
|
+
};
|
|
1073
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1074
|
+
await levelsSet.init({
|
|
1075
|
+
levels: levels,
|
|
1076
|
+
currentLevel: 2
|
|
1077
|
+
});
|
|
1078
|
+
await levelsSet.levelDown();
|
|
1079
|
+
assert.ok(levelsSet);
|
|
1080
|
+
});
|
|
1081
|
+
|
|
1082
|
+
it('should handle large number of modifiers (100+)', async () => {
|
|
1083
|
+
let modifiers = [];
|
|
1084
|
+
for(let i = 0; i < 150; i++){
|
|
1085
|
+
modifiers.push(new Modifier({
|
|
1086
|
+
key: `mod-${i}`,
|
|
1087
|
+
propertyKey: 'stats/atk',
|
|
1088
|
+
operation: ModifierConst.OPS.INC,
|
|
1089
|
+
value: 1
|
|
1090
|
+
}));
|
|
1091
|
+
}
|
|
1092
|
+
let levels = {
|
|
1093
|
+
0: new Level({key: 0, requiredExperience: 0}),
|
|
1094
|
+
1: new Level({key: 1, requiredExperience: 0, modifiers: modifiers})
|
|
1095
|
+
};
|
|
1096
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1097
|
+
await levelsSet.init({
|
|
1098
|
+
levels: levels,
|
|
1099
|
+
currentLevel: 0
|
|
1100
|
+
});
|
|
1101
|
+
await levelsSet.levelUp();
|
|
1102
|
+
assert.strictEqual(mockOwner.stats.atk, 160);
|
|
1103
|
+
});
|
|
1104
|
+
|
|
1105
|
+
it('should apply modifiers in order', async () => {
|
|
1106
|
+
let modifier1 = new Modifier({
|
|
1107
|
+
key: 'mod-1',
|
|
1108
|
+
propertyKey: 'stats/atk',
|
|
1109
|
+
operation: ModifierConst.OPS.SET,
|
|
1110
|
+
value: 5
|
|
1111
|
+
});
|
|
1112
|
+
let modifier2 = new Modifier({
|
|
1113
|
+
key: 'mod-2',
|
|
1114
|
+
propertyKey: 'stats/atk',
|
|
1115
|
+
operation: ModifierConst.OPS.MULT,
|
|
1116
|
+
value: 2
|
|
1117
|
+
});
|
|
1118
|
+
let levels = {
|
|
1119
|
+
1: new Level({key: 1, requiredExperience: 0, modifiers: [modifier1, modifier2]})
|
|
1120
|
+
};
|
|
1121
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1122
|
+
await levelsSet.init({
|
|
1123
|
+
levels: levels,
|
|
1124
|
+
currentLevel: 1
|
|
1125
|
+
});
|
|
1126
|
+
assert.strictEqual(mockOwner.stats.atk, 10);
|
|
1127
|
+
});
|
|
1128
|
+
});
|
|
1129
|
+
|
|
1130
|
+
describe('addExperience - Experience Thresholds', () => {
|
|
1131
|
+
it('should level up when experience exactly at threshold', async () => {
|
|
1132
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1133
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1134
|
+
await levelsSet.init({
|
|
1135
|
+
levels: levels,
|
|
1136
|
+
currentLevel: 1,
|
|
1137
|
+
currentExp: 0
|
|
1138
|
+
});
|
|
1139
|
+
await levelsSet.addExperience(100);
|
|
1140
|
+
assert.strictEqual(levelsSet.currentLevel, 2);
|
|
1141
|
+
});
|
|
1142
|
+
|
|
1143
|
+
it('should not level up when experience 1 point below threshold', async () => {
|
|
1144
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1145
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1146
|
+
await levelsSet.init({
|
|
1147
|
+
levels: levels,
|
|
1148
|
+
currentLevel: 1,
|
|
1149
|
+
currentExp: 0
|
|
1150
|
+
});
|
|
1151
|
+
await levelsSet.addExperience(99);
|
|
1152
|
+
assert.strictEqual(levelsSet.currentLevel, 1);
|
|
1153
|
+
assert.strictEqual(levelsSet.currentExp, 99);
|
|
1154
|
+
});
|
|
1155
|
+
});
|
|
1156
|
+
|
|
1157
|
+
describe('addExperience - Event Parameters Validation', () => {
|
|
1158
|
+
it('should fire LEVEL_EXPERIENCE_ADDED event with all 9 parameters', async () => {
|
|
1159
|
+
let receivedArgs = [];
|
|
1160
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1161
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1162
|
+
await levelsSet.init({
|
|
1163
|
+
levels: levels,
|
|
1164
|
+
currentLevel: 1,
|
|
1165
|
+
currentExp: 50
|
|
1166
|
+
});
|
|
1167
|
+
levelsSet.listenEvent(SkillsEvents.LEVEL_EXPERIENCE_ADDED, (...args) => {
|
|
1168
|
+
receivedArgs = args;
|
|
1169
|
+
}, 'exp-listener', levelsSet.getOwnerEventKey());
|
|
1170
|
+
await levelsSet.addExperience(25);
|
|
1171
|
+
assert.strictEqual(receivedArgs.length, 9);
|
|
1172
|
+
assert.strictEqual(receivedArgs[1], 25);
|
|
1173
|
+
assert.strictEqual(receivedArgs[2], 75);
|
|
1174
|
+
});
|
|
1175
|
+
});
|
|
1176
|
+
|
|
1177
|
+
describe('addExperience - Negative Experience', () => {
|
|
1178
|
+
it('should reduce XP below 0 when negative experience added', async () => {
|
|
1179
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
1180
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1181
|
+
await levelsSet.init({
|
|
1182
|
+
levels: levels,
|
|
1183
|
+
currentLevel: 1,
|
|
1184
|
+
currentExp: 50
|
|
1185
|
+
});
|
|
1186
|
+
await levelsSet.addExperience(-75);
|
|
1187
|
+
assert.ok(levelsSet.currentExp < 0);
|
|
1188
|
+
});
|
|
1189
|
+
});
|
|
1190
|
+
|
|
1191
|
+
describe('sortLevelsBy - Edge Cases', () => {
|
|
1192
|
+
it('should handle when sortField does not exist on objects', () => {
|
|
1193
|
+
let levels = {
|
|
1194
|
+
1: new Level({key: 1, requiredExperience: 100}),
|
|
1195
|
+
2: new Level({key: 2, requiredExperience: 200})
|
|
1196
|
+
};
|
|
1197
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1198
|
+
let result = levelsSet.sortLevelsBy(levels, 'nonExistentField');
|
|
1199
|
+
assert.ok(Array.isArray(result));
|
|
1200
|
+
});
|
|
1201
|
+
|
|
1202
|
+
it('should handle mixed type values in sort field', () => {
|
|
1203
|
+
let levels = {
|
|
1204
|
+
1: {key: 1, customSort: '100'},
|
|
1205
|
+
2: {key: 2, customSort: 50},
|
|
1206
|
+
3: {key: 3, customSort: null}
|
|
1207
|
+
};
|
|
1208
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1209
|
+
let result = levelsSet.sortLevelsBy(levels, 'customSort');
|
|
1210
|
+
assert.ok(Array.isArray(result));
|
|
1211
|
+
});
|
|
1212
|
+
|
|
1213
|
+
it('should maintain stability in sort', () => {
|
|
1214
|
+
let levels = {
|
|
1215
|
+
1: new Level({key: 1, requiredExperience: 100}),
|
|
1216
|
+
2: new Level({key: 2, requiredExperience: 100}),
|
|
1217
|
+
3: new Level({key: 3, requiredExperience: 100})
|
|
1218
|
+
};
|
|
1219
|
+
let levelsSet = new LevelsSet({owner: mockOwner});
|
|
1220
|
+
let result = levelsSet.sortLevelsBy(levels, 'requiredExperience');
|
|
1221
|
+
assert.strictEqual(result.length, 3);
|
|
1222
|
+
assert.ok(result.includes('1'));
|
|
1223
|
+
assert.ok(result.includes('2'));
|
|
1224
|
+
assert.ok(result.includes('3'));
|
|
1225
|
+
});
|
|
1226
|
+
});
|
|
1227
|
+
});
|