@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,527 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
* Reldens - Sender Unit Tests
|
|
4
|
+
*
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
const { describe, it, beforeEach, afterEach } = require('node:test');
|
|
8
|
+
const assert = require('node:assert');
|
|
9
|
+
const Sender = require('../../../lib/server/sender');
|
|
10
|
+
const ClassPath = require('../../../lib/class-path');
|
|
11
|
+
const Skill = require('../../../lib/skill');
|
|
12
|
+
const Level = require('../../../lib/level');
|
|
13
|
+
const SkillsConst = require('../../../lib/constants');
|
|
14
|
+
const SkillsEvents = require('../../../lib/skills-events');
|
|
15
|
+
const { TestHelpers } = require('../../utils/test-helpers');
|
|
16
|
+
const { MockOwner } = require('../../fixtures/mocks/mock-owner');
|
|
17
|
+
const { MockTarget } = require('../../fixtures/mocks/mock-target');
|
|
18
|
+
const { BaseLevelsFixtures } = require('../../fixtures/levels/base-levels');
|
|
19
|
+
const { BaseSkillsFixtures } = require('../../fixtures/skills/base-skills');
|
|
20
|
+
|
|
21
|
+
describe('Sender', () => {
|
|
22
|
+
let mockOwner;
|
|
23
|
+
let mockClient;
|
|
24
|
+
let classPath;
|
|
25
|
+
|
|
26
|
+
beforeEach(() => {
|
|
27
|
+
mockOwner = new MockOwner();
|
|
28
|
+
mockClient = TestHelpers.createMockClient();
|
|
29
|
+
TestHelpers.clearEventListeners();
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
afterEach(() => {
|
|
33
|
+
TestHelpers.clearEventListeners();
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
describe('Constructor', () => {
|
|
37
|
+
it('should initialize with classPath and client', async () => {
|
|
38
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
39
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
40
|
+
await classPath.init({key: 'test', levels: levels});
|
|
41
|
+
let sender = new Sender(classPath, mockClient);
|
|
42
|
+
assert.ok(sender);
|
|
43
|
+
assert.strictEqual(sender.classPath, classPath);
|
|
44
|
+
assert.strictEqual(sender.client, mockClient);
|
|
45
|
+
});
|
|
46
|
+
|
|
47
|
+
it('should initialize without client', async () => {
|
|
48
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
49
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
50
|
+
await classPath.init({key: 'test', levels: levels});
|
|
51
|
+
let sender = new Sender(classPath);
|
|
52
|
+
assert.ok(sender);
|
|
53
|
+
assert.strictEqual(sender.client, false);
|
|
54
|
+
});
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
describe('validateClient', () => {
|
|
58
|
+
it('should return false when client is undefined', async () => {
|
|
59
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
60
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
61
|
+
await classPath.init({key: 'test', levels: levels});
|
|
62
|
+
let sender = new Sender(classPath);
|
|
63
|
+
assert.strictEqual(sender.validateClient(), false);
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
it('should return true when client is defined', async () => {
|
|
67
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
68
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
69
|
+
await classPath.init({key: 'test', levels: levels});
|
|
70
|
+
let sender = new Sender(classPath, mockClient);
|
|
71
|
+
assert.strictEqual(sender.validateClient(), true);
|
|
72
|
+
});
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
describe('registerListeners', () => {
|
|
76
|
+
it('should return early when client is invalid', async () => {
|
|
77
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
78
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
79
|
+
await classPath.init({key: 'test', levels: levels});
|
|
80
|
+
let sender = new Sender(classPath);
|
|
81
|
+
sender.registerListeners();
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
it('should register INIT_CLASS_PATH_END listener', async () => {
|
|
85
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
86
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
87
|
+
await classPath.init({key: 'test', levels: levels});
|
|
88
|
+
let sender = new Sender(classPath, mockClient);
|
|
89
|
+
sender.registerListeners();
|
|
90
|
+
await sender.sendInitClassPathData(classPath);
|
|
91
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
it('should register LEVEL_UP listener', async () => {
|
|
95
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
96
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
97
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 1});
|
|
98
|
+
let sender = new Sender(classPath, mockClient);
|
|
99
|
+
sender.registerListeners();
|
|
100
|
+
await sender.sendLevelUpData(classPath);
|
|
101
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
102
|
+
});
|
|
103
|
+
|
|
104
|
+
it('should register LEVEL_EXPERIENCE_ADDED listener', async () => {
|
|
105
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
106
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
107
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 1});
|
|
108
|
+
classPath.currentExp = 50;
|
|
109
|
+
let sender = new Sender(classPath, mockClient);
|
|
110
|
+
sender.registerListeners();
|
|
111
|
+
await sender.sendLevelExperienceAdded(classPath);
|
|
112
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
it('should register SKILL_BEFORE_CAST listener', async () => {
|
|
116
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
117
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
118
|
+
await classPath.init({key: 'test', levels: levels});
|
|
119
|
+
let sender = new Sender(classPath, mockClient);
|
|
120
|
+
sender.registerListeners();
|
|
121
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
122
|
+
let mockTarget = new MockTarget();
|
|
123
|
+
await sender.sendSkillBeforeCastData(skill, mockTarget);
|
|
124
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
it('should register SKILL_ATTACK_APPLY_DAMAGE listener', async () => {
|
|
128
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
129
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
130
|
+
await classPath.init({key: 'test', levels: levels});
|
|
131
|
+
let sender = new Sender(classPath, mockClient);
|
|
132
|
+
sender.registerListeners();
|
|
133
|
+
let skill = new Skill({...BaseSkillsFixtures.attackSkill, owner: mockOwner});
|
|
134
|
+
let mockTarget = new MockTarget();
|
|
135
|
+
await sender.sendSkillAttackApplyDamage(skill, mockTarget, 10, 90);
|
|
136
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
137
|
+
});
|
|
138
|
+
|
|
139
|
+
it('should register all 5 event listeners', async () => {
|
|
140
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
141
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
142
|
+
await classPath.init({key: 'test', levels: levels});
|
|
143
|
+
let sender = new Sender(classPath, mockClient);
|
|
144
|
+
sender.registerListeners();
|
|
145
|
+
});
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
describe('sendInitClassPathData', () => {
|
|
149
|
+
it('should send correct message structure', async () => {
|
|
150
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
151
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
152
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 1, currentExp: 0});
|
|
153
|
+
let sender = new Sender(classPath, mockClient);
|
|
154
|
+
await sender.sendInitClassPathData(classPath);
|
|
155
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
156
|
+
let message = mockClient.sentMessages[0];
|
|
157
|
+
assert.strictEqual(message.act, SkillsConst.ACTION_INIT_CLASS_PATH_END);
|
|
158
|
+
assert.strictEqual(message.data.lvl, 1);
|
|
159
|
+
assert.strictEqual(message.data.exp, 0);
|
|
160
|
+
});
|
|
161
|
+
|
|
162
|
+
it('should include next level experience when available', async () => {
|
|
163
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
164
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
165
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 1});
|
|
166
|
+
let sender = new Sender(classPath, mockClient);
|
|
167
|
+
await sender.sendInitClassPathData(classPath);
|
|
168
|
+
let message = mockClient.sentMessages[0];
|
|
169
|
+
assert.ok(message.data.ne);
|
|
170
|
+
assert.strictEqual(message.data.ne, 100);
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
it('should not send ne when next level experience is 0', async () => {
|
|
174
|
+
let levels = {
|
|
175
|
+
1: new Level({key: 1, requiredExperience: 0}),
|
|
176
|
+
2: new Level({key: 2, requiredExperience: 0})
|
|
177
|
+
};
|
|
178
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
179
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 1});
|
|
180
|
+
let sender = new Sender(classPath, mockClient);
|
|
181
|
+
await sender.sendInitClassPathData(classPath);
|
|
182
|
+
let message = mockClient.sentMessages[0];
|
|
183
|
+
assert.strictEqual(message.data.ne, undefined);
|
|
184
|
+
});
|
|
185
|
+
|
|
186
|
+
it('should not send ne when next level experience is negative', async () => {
|
|
187
|
+
let levels = {
|
|
188
|
+
5: new Level({key: 5, requiredExperience: 500})
|
|
189
|
+
};
|
|
190
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
191
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 5});
|
|
192
|
+
classPath.getNextLevelExperience = () => -1;
|
|
193
|
+
let sender = new Sender(classPath, mockClient);
|
|
194
|
+
await sender.sendInitClassPathData(classPath);
|
|
195
|
+
let message = mockClient.sentMessages[0];
|
|
196
|
+
assert.strictEqual(message.data.ne, undefined);
|
|
197
|
+
});
|
|
198
|
+
|
|
199
|
+
it('should include nl when labelsByLevel exists for current level', async () => {
|
|
200
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
201
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
202
|
+
await classPath.init({
|
|
203
|
+
key: 'test',
|
|
204
|
+
levels: levels,
|
|
205
|
+
currentLevel: 2,
|
|
206
|
+
label: 'Base Warrior',
|
|
207
|
+
labelsByLevel: {2: 'Advanced Warrior'}
|
|
208
|
+
});
|
|
209
|
+
let sender = new Sender(classPath, mockClient);
|
|
210
|
+
await sender.sendInitClassPathData(classPath);
|
|
211
|
+
let message = mockClient.sentMessages[0];
|
|
212
|
+
assert.strictEqual(message.data.nl, 'Advanced Warrior');
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
it('should not include nl when labelsByLevel does not exist for current level', async () => {
|
|
216
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
217
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
218
|
+
await classPath.init({
|
|
219
|
+
key: 'test',
|
|
220
|
+
levels: levels,
|
|
221
|
+
currentLevel: 1,
|
|
222
|
+
label: 'Warrior',
|
|
223
|
+
labelsByLevel: {3: 'Master Warrior'}
|
|
224
|
+
});
|
|
225
|
+
let sender = new Sender(classPath, mockClient);
|
|
226
|
+
await sender.sendInitClassPathData(classPath);
|
|
227
|
+
let message = mockClient.sentMessages[0];
|
|
228
|
+
assert.strictEqual(message.data.nl, undefined);
|
|
229
|
+
});
|
|
230
|
+
|
|
231
|
+
it('should include label', async () => {
|
|
232
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
233
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
234
|
+
await classPath.init({key: 'test', levels: levels, label: 'Warrior'});
|
|
235
|
+
let sender = new Sender(classPath, mockClient);
|
|
236
|
+
await sender.sendInitClassPathData(classPath);
|
|
237
|
+
let message = mockClient.sentMessages[0];
|
|
238
|
+
assert.strictEqual(message.data.lab, 'Warrior');
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
it('should include skill keys', async () => {
|
|
242
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
243
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
244
|
+
await classPath.init({key: 'test', levels: levels});
|
|
245
|
+
classPath.currentSkills = {skill1: {key: 'skill1'}, skill2: {key: 'skill2'}};
|
|
246
|
+
let sender = new Sender(classPath, mockClient);
|
|
247
|
+
await sender.sendInitClassPathData(classPath);
|
|
248
|
+
let message = mockClient.sentMessages[0];
|
|
249
|
+
assert.ok(Array.isArray(message.data.skl));
|
|
250
|
+
assert.strictEqual(message.data.skl.length, 2);
|
|
251
|
+
});
|
|
252
|
+
});
|
|
253
|
+
|
|
254
|
+
describe('sendLevelUpData', () => {
|
|
255
|
+
it('should send correct message structure', async () => {
|
|
256
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
257
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
258
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 2});
|
|
259
|
+
let sender = new Sender(classPath, mockClient);
|
|
260
|
+
await sender.sendLevelUpData(classPath);
|
|
261
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
262
|
+
let message = mockClient.sentMessages[0];
|
|
263
|
+
assert.strictEqual(message.act, SkillsConst.ACTION_LEVEL_UP);
|
|
264
|
+
assert.strictEqual(message.data.lvl, 2);
|
|
265
|
+
});
|
|
266
|
+
|
|
267
|
+
it('should include new skills when available', async () => {
|
|
268
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
269
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
270
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 2});
|
|
271
|
+
classPath.skillsByLevelKeys = {2: ['newSkill']};
|
|
272
|
+
let sender = new Sender(classPath, mockClient);
|
|
273
|
+
await sender.sendLevelUpData(classPath);
|
|
274
|
+
let message = mockClient.sentMessages[0];
|
|
275
|
+
assert.ok(message.data.skl);
|
|
276
|
+
assert.deepStrictEqual(message.data.skl, ['newSkill']);
|
|
277
|
+
});
|
|
278
|
+
|
|
279
|
+
it('should not include skl when no skills at current level', async () => {
|
|
280
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
281
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
282
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 2});
|
|
283
|
+
classPath.skillsByLevelKeys = {1: ['oldSkill']};
|
|
284
|
+
let sender = new Sender(classPath, mockClient);
|
|
285
|
+
await sender.sendLevelUpData(classPath);
|
|
286
|
+
let message = mockClient.sentMessages[0];
|
|
287
|
+
assert.strictEqual(message.data.skl, undefined);
|
|
288
|
+
});
|
|
289
|
+
|
|
290
|
+
it('should include next level experience', async () => {
|
|
291
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
292
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
293
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 2});
|
|
294
|
+
let sender = new Sender(classPath, mockClient);
|
|
295
|
+
await sender.sendLevelUpData(classPath);
|
|
296
|
+
let message = mockClient.sentMessages[0];
|
|
297
|
+
assert.ok(message.data.ne);
|
|
298
|
+
});
|
|
299
|
+
|
|
300
|
+
it('should not send ne when next level experience is 0', async () => {
|
|
301
|
+
let levels = {
|
|
302
|
+
1: new Level({key: 1, requiredExperience: 0}),
|
|
303
|
+
2: new Level({key: 2, requiredExperience: 0})
|
|
304
|
+
};
|
|
305
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
306
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 2});
|
|
307
|
+
let sender = new Sender(classPath, mockClient);
|
|
308
|
+
await sender.sendLevelUpData(classPath);
|
|
309
|
+
let message = mockClient.sentMessages[0];
|
|
310
|
+
assert.strictEqual(message.data.ne, undefined);
|
|
311
|
+
});
|
|
312
|
+
});
|
|
313
|
+
|
|
314
|
+
describe('sendLevelExperienceAdded', () => {
|
|
315
|
+
it('should send correct message structure', async () => {
|
|
316
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
317
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
318
|
+
await classPath.init({key: 'test', levels: levels});
|
|
319
|
+
classPath.currentExp = 50;
|
|
320
|
+
let sender = new Sender(classPath, mockClient);
|
|
321
|
+
await sender.sendLevelExperienceAdded(classPath);
|
|
322
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
323
|
+
let message = mockClient.sentMessages[0];
|
|
324
|
+
assert.strictEqual(message.act, SkillsConst.ACTION_LEVEL_EXPERIENCE_ADDED);
|
|
325
|
+
assert.strictEqual(message.data.exp, 50);
|
|
326
|
+
});
|
|
327
|
+
});
|
|
328
|
+
|
|
329
|
+
describe('sendSkillBeforeCastData', () => {
|
|
330
|
+
it('should send correct message structure with skill key and owner position', async () => {
|
|
331
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
332
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
333
|
+
await classPath.init({key: 'test', levels: levels});
|
|
334
|
+
let sender = new Sender(classPath, mockClient);
|
|
335
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
336
|
+
let mockTarget = new MockTarget();
|
|
337
|
+
await sender.sendSkillBeforeCastData(skill, mockTarget);
|
|
338
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
339
|
+
let message = mockClient.broadcastMessages[0];
|
|
340
|
+
assert.strictEqual(message.act, SkillsConst.ACTION_SKILL_BEFORE_CAST);
|
|
341
|
+
assert.strictEqual(message.data.skillKey, BaseSkillsFixtures.basicSkill.key);
|
|
342
|
+
assert.strictEqual(message.data.x, mockOwner.getPosition().x);
|
|
343
|
+
assert.strictEqual(message.data.y, mockOwner.getPosition().y);
|
|
344
|
+
});
|
|
345
|
+
|
|
346
|
+
it('should include extraData when owner.getSkillExtraData exists', async () => {
|
|
347
|
+
let ownerWithExtraData = new MockOwner();
|
|
348
|
+
ownerWithExtraData.getSkillExtraData = ({skill, target}) => {
|
|
349
|
+
return {customData: 'test-data', targetId: target.id};
|
|
350
|
+
};
|
|
351
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
352
|
+
classPath = new ClassPath({owner: ownerWithExtraData});
|
|
353
|
+
await classPath.init({key: 'test', levels: levels});
|
|
354
|
+
let sender = new Sender(classPath, mockClient);
|
|
355
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: ownerWithExtraData});
|
|
356
|
+
let mockTarget = new MockTarget();
|
|
357
|
+
await sender.sendSkillBeforeCastData(skill, mockTarget);
|
|
358
|
+
let message = mockClient.broadcastMessages[0];
|
|
359
|
+
assert.ok(message.data.extraData);
|
|
360
|
+
assert.strictEqual(message.data.extraData.customData, 'test-data');
|
|
361
|
+
assert.strictEqual(message.data.extraData.targetId, mockTarget.id);
|
|
362
|
+
});
|
|
363
|
+
|
|
364
|
+
it('should use BEHAVIOR_BROADCAST', async () => {
|
|
365
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
366
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
367
|
+
await classPath.init({key: 'test', levels: levels});
|
|
368
|
+
let sender = new Sender(classPath, mockClient);
|
|
369
|
+
let skill = new Skill({...BaseSkillsFixtures.basicSkill, owner: mockOwner});
|
|
370
|
+
let mockTarget = new MockTarget();
|
|
371
|
+
await sender.sendSkillBeforeCastData(skill, mockTarget);
|
|
372
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
373
|
+
assert.strictEqual(mockClient.sentMessages.length, 0);
|
|
374
|
+
});
|
|
375
|
+
});
|
|
376
|
+
|
|
377
|
+
describe('sendSkillAttackApplyDamage', () => {
|
|
378
|
+
it('should send correct message structure with damage', async () => {
|
|
379
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
380
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
381
|
+
await classPath.init({key: 'test', levels: levels});
|
|
382
|
+
let sender = new Sender(classPath, mockClient);
|
|
383
|
+
let skill = new Skill({...BaseSkillsFixtures.attackSkill, owner: mockOwner});
|
|
384
|
+
let mockTarget = new MockTarget();
|
|
385
|
+
let damage = 15;
|
|
386
|
+
let newValue = 85;
|
|
387
|
+
await sender.sendSkillAttackApplyDamage(skill, mockTarget, damage, newValue);
|
|
388
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
389
|
+
let message = mockClient.broadcastMessages[0];
|
|
390
|
+
assert.strictEqual(message.act, SkillsConst.ACTION_SKILL_ATTACK_APPLY_DAMAGE);
|
|
391
|
+
assert.strictEqual(message.data.d, damage);
|
|
392
|
+
});
|
|
393
|
+
|
|
394
|
+
it('should include extraData when owner.getSkillExtraData exists', async () => {
|
|
395
|
+
let ownerWithExtraData = new MockOwner();
|
|
396
|
+
ownerWithExtraData.getSkillExtraData = ({skill, target}) => {
|
|
397
|
+
return {isCritical: true, targetHealth: 85};
|
|
398
|
+
};
|
|
399
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
400
|
+
classPath = new ClassPath({owner: ownerWithExtraData});
|
|
401
|
+
await classPath.init({key: 'test', levels: levels});
|
|
402
|
+
let sender = new Sender(classPath, mockClient);
|
|
403
|
+
let skill = new Skill({...BaseSkillsFixtures.attackSkill, owner: ownerWithExtraData});
|
|
404
|
+
let mockTarget = new MockTarget();
|
|
405
|
+
await sender.sendSkillAttackApplyDamage(skill, mockTarget, 15, 85);
|
|
406
|
+
let message = mockClient.broadcastMessages[0];
|
|
407
|
+
assert.ok(message.data.extraData);
|
|
408
|
+
assert.strictEqual(message.data.extraData.isCritical, true);
|
|
409
|
+
assert.strictEqual(message.data.extraData.targetHealth, 85);
|
|
410
|
+
});
|
|
411
|
+
|
|
412
|
+
it('should use BEHAVIOR_BROADCAST', async () => {
|
|
413
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
414
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
415
|
+
await classPath.init({key: 'test', levels: levels});
|
|
416
|
+
let sender = new Sender(classPath, mockClient);
|
|
417
|
+
let skill = new Skill({...BaseSkillsFixtures.attackSkill, owner: mockOwner});
|
|
418
|
+
let mockTarget = new MockTarget();
|
|
419
|
+
await sender.sendSkillAttackApplyDamage(skill, mockTarget, 10, 90);
|
|
420
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
421
|
+
assert.strictEqual(mockClient.sentMessages.length, 0);
|
|
422
|
+
});
|
|
423
|
+
});
|
|
424
|
+
|
|
425
|
+
describe('runBehaviors', () => {
|
|
426
|
+
it('should broadcast when behavior is BROADCAST', async () => {
|
|
427
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
428
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
429
|
+
await classPath.init({key: 'test', levels: levels});
|
|
430
|
+
let sender = new Sender(classPath, mockClient);
|
|
431
|
+
await sender.runBehaviors(
|
|
432
|
+
{test: 'data'},
|
|
433
|
+
SkillsConst.ACTION_LEVEL_UP,
|
|
434
|
+
SkillsConst.BEHAVIOR_BROADCAST,
|
|
435
|
+
classPath.getOwnerId()
|
|
436
|
+
);
|
|
437
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
438
|
+
assert.strictEqual(mockClient.sentMessages.length, 0);
|
|
439
|
+
});
|
|
440
|
+
|
|
441
|
+
it('should send when behavior is SEND', async () => {
|
|
442
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
443
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
444
|
+
await classPath.init({key: 'test', levels: levels});
|
|
445
|
+
let sender = new Sender(classPath, mockClient);
|
|
446
|
+
await sender.runBehaviors(
|
|
447
|
+
{test: 'data'},
|
|
448
|
+
SkillsConst.ACTION_LEVEL_UP,
|
|
449
|
+
SkillsConst.BEHAVIOR_SEND,
|
|
450
|
+
classPath.getOwnerId()
|
|
451
|
+
);
|
|
452
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
453
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 0);
|
|
454
|
+
});
|
|
455
|
+
|
|
456
|
+
it('should both send and broadcast when behavior is BOTH', async () => {
|
|
457
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
458
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
459
|
+
await classPath.init({key: 'test', levels: levels});
|
|
460
|
+
let sender = new Sender(classPath, mockClient);
|
|
461
|
+
await sender.runBehaviors(
|
|
462
|
+
{test: 'data'},
|
|
463
|
+
SkillsConst.ACTION_LEVEL_UP,
|
|
464
|
+
SkillsConst.BEHAVIOR_BOTH,
|
|
465
|
+
classPath.getOwnerId()
|
|
466
|
+
);
|
|
467
|
+
assert.strictEqual(mockClient.sentMessages.length, 1);
|
|
468
|
+
assert.strictEqual(mockClient.broadcastMessages.length, 1);
|
|
469
|
+
});
|
|
470
|
+
|
|
471
|
+
it('should return false when owner id mismatch', async () => {
|
|
472
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
473
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
474
|
+
await classPath.init({key: 'test', levels: levels});
|
|
475
|
+
let sender = new Sender(classPath, mockClient);
|
|
476
|
+
let result = await sender.runBehaviors(
|
|
477
|
+
{test: 'data'},
|
|
478
|
+
SkillsConst.ACTION_LEVEL_UP,
|
|
479
|
+
SkillsConst.BEHAVIOR_SEND,
|
|
480
|
+
'different-owner-id'
|
|
481
|
+
);
|
|
482
|
+
assert.strictEqual(result, false);
|
|
483
|
+
assert.strictEqual(mockClient.sentMessages.length, 0);
|
|
484
|
+
});
|
|
485
|
+
|
|
486
|
+
it('should include correct message structure', async () => {
|
|
487
|
+
let levels = BaseLevelsFixtures.createLevelSet();
|
|
488
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
489
|
+
await classPath.init({key: 'test', levels: levels});
|
|
490
|
+
let sender = new Sender(classPath, mockClient);
|
|
491
|
+
let testData = {level: 5, exp: 500};
|
|
492
|
+
await sender.runBehaviors(
|
|
493
|
+
testData,
|
|
494
|
+
SkillsConst.ACTION_LEVEL_UP,
|
|
495
|
+
SkillsConst.BEHAVIOR_SEND,
|
|
496
|
+
classPath.getOwnerId()
|
|
497
|
+
);
|
|
498
|
+
let message = mockClient.sentMessages[0];
|
|
499
|
+
assert.strictEqual(message.act, SkillsConst.ACTION_LEVEL_UP);
|
|
500
|
+
assert.strictEqual(message.owner, classPath.getOwnerId());
|
|
501
|
+
assert.deepStrictEqual(message.data, testData);
|
|
502
|
+
});
|
|
503
|
+
});
|
|
504
|
+
|
|
505
|
+
describe('Edge Cases', () => {
|
|
506
|
+
it('should handle classPath without skills', async () => {
|
|
507
|
+
let levels = {1: new Level({key: 1, requiredExperience: 0})};
|
|
508
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
509
|
+
await classPath.init({key: 'test', levels: levels});
|
|
510
|
+
let sender = new Sender(classPath, mockClient);
|
|
511
|
+
await sender.sendInitClassPathData(classPath);
|
|
512
|
+
let message = mockClient.sentMessages[0];
|
|
513
|
+
assert.ok(Array.isArray(message.data.skl));
|
|
514
|
+
assert.strictEqual(message.data.skl.length, 0);
|
|
515
|
+
});
|
|
516
|
+
|
|
517
|
+
it('should handle max level without next experience', async () => {
|
|
518
|
+
let levels = {5: new Level({key: 5, requiredExperience: 500})};
|
|
519
|
+
classPath = new ClassPath({owner: mockOwner});
|
|
520
|
+
await classPath.init({key: 'test', levels: levels, currentLevel: 5});
|
|
521
|
+
let sender = new Sender(classPath, mockClient);
|
|
522
|
+
await sender.sendLevelUpData(classPath);
|
|
523
|
+
let message = mockClient.sentMessages[0];
|
|
524
|
+
assert.strictEqual(message.data.ne, 500);
|
|
525
|
+
});
|
|
526
|
+
});
|
|
527
|
+
});
|