GC: BasicDataStats - com.robrua.orianna.type.staticdata.BasicDataStats (.java)

Maven-Central
/
com.robrua / orianna
/
1.4.1

1.4.3
1.4.2
1.4.1
1.4.0
/
com.robrua.orianna.type.staticdata.BasicDataStats
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
   package com.robrua.orianna.type.staticdata;
2
   
3
   import java.io.Serializable;
4
   import java.util.HashMap;
5
   import java.util.Map;
6
   
7
   public class BasicDataStats implements Serializable {
8
       private static final long serialVersionUID = -3892233449766313123L;
9
       public final Double flatArmorMod, flatArmorPenetrationMod, flatAttackSpeedMod, flatBlockMod, flatCritChanceMod, flatCritDamageMod, flatEXPBonus,
10
              flatEnergyPoolMod, flatEnergyRegenMod, flatGoldPer10Mod, flatHPPoolMod, flatHPRegenMod, flatMPPoolMod, flatMPRegenMod, flatMagicDamageMod,
11
              flatMagicPenetrationMod, flatMovementSpeedMod, flatPhysicalDamageMod, flatSpellBlockMod, percentArmorMod, percentArmorPenetrationMod,
12
              percentAttackSpeedMod, percentBlockMod, percentCooldownMod, percentCritChanceMod, percentCritDamageMod, percentDodgeMod, percentEXPBonus,
13
              percentHPPoolMod, percentHPRegenMod, percentLifeStealMod, percentMPPoolMod, percentMPRegenMod, percentMagicDamageMod, percentMagicPenetrationMod,
14
              percentMovementSpeedMod, percentPhysicalDamageMod, percentSpellBlockMod, percentSpellVampMod, rFlatArmorModPerLevel, rFlatArmorPenetrationMod,
15
              rFlatArmorPenetrationModPerLevel, rFlatCritChanceModPerLevel, rFlatCritDamageModPerLevel, rFlatDodgeMod, rFlatDodgeModPerLevel,
16
              rFlatEnergyModPerLevel, rFlatEnergyRegenModPerLevel, rFlatGoldPer10Mod, rFlatHPModPerLevel, rFlatHPRegenModPerLevel, rFlatMPModPerLevel,
17
              rFlatMPRegenModPerLevel, rFlatMagicDamageModPerLevel, rFlatMagicPenetrationMod, rFlatMagicPenetrationModPerLevel, rFlatMovementSpeedModPerLevel,
18
              rFlatPhysicalDamageModPerLevel, rFlatSpellBlockModPerLevel, rFlatTimeDeadMod, rFlatTimeDeadModPerLevel, rPercentArmorPenetrationMod,
19
              rPercentArmorPenetrationModPerLevel, rPercentAttackSpeedModPerLevel, rPercentCooldownMod, rPercentCooldownModPerLevel, rPercentMagicPenetrationMod,
20
              rPercentMagicPenetrationModPerLevel, rPercentMovementSpeedModPerLevel, rPercentTimeDeadMod, rPercentTimeDeadModPerLevel;
21
  
22
      public BasicDataStats(final Double flatArmorMod, final Double flatArmorPenetrationMod, final Double flatAttackSpeedMod, final Double flatBlockMod,
23
              final Double flatCritChanceMod, final Double flatCritDamageMod, final Double flatEXPBonus, final Double flatEnergyPoolMod,
24
              final Double flatEnergyRegenMod, final Double flatGoldPer10Mod, final Double flatHPPoolMod, final Double flatHPRegenMod,
25
              final Double flatMPPoolMod, final Double flatMPRegenMod, final Double flatMagicDamageMod, final Double flatMagicPenetrationMod,
26
              final Double flatMovementSpeedMod, final Double flatPhysicalDamageMod, final Double flatSpellBlockMod, final Double percentArmorMod,
27
              final Double percentArmorPenetrationMod, final Double percentAttackSpeedMod, final Double percentBlockMod, final Double percentCooldownMod,
28
              final Double percentCritChanceMod, final Double percentCritDamageMod, final Double percentDodgeMod, final Double percentEXPBonus,
29
              final Double percentHPPoolMod, final Double percentHPRegenMod, final Double percentLifeStealMod, final Double percentMPPoolMod,
30
              final Double percentMPRegenMod, final Double percentMagicDamageMod, final Double percentMagicPenetrationMod, final Double percentMovementSpeedMod,
31
              final Double percentPhysicalDamageMod, final Double percentSpellBlockMod, final Double percentSpellVampMod, final Double rFlatArmorModPerLevel,
32
              final Double rFlatArmorPenetrationMod, final Double rFlatArmorPenetrationModPerLevel, final Double rFlatCritChanceModPerLevel,
33
              final Double rFlatCritDamageModPerLevel, final Double rFlatDodgeMod, final Double rFlatDodgeModPerLevel, final Double rFlatEnergyModPerLevel,
34
              final Double rFlatEnergyRegenModPerLevel, final Double rFlatGoldPer10Mod, final Double rFlatHPModPerLevel, final Double rFlatHPRegenModPerLevel,
35
              final Double rFlatMPModPerLevel, final Double rFlatMPRegenModPerLevel, final Double rFlatMagicDamageModPerLevel,
36
              final Double rFlatMagicPenetrationMod, final Double rFlatMagicPenetrationModPerLevel, final Double rFlatMovementSpeedModPerLevel,
37
              final Double rFlatPhysicalDamageModPerLevel, final Double rFlatSpellBlockModPerLevel, final Double rFlatTimeDeadMod,
38
              final Double rFlatTimeDeadModPerLevel, final Double rPercentArmorPenetrationMod, final Double rPercentArmorPenetrationModPerLevel,
39
              final Double rPercentAttackSpeedModPerLevel, final Double rPercentCooldownMod, final Double rPercentCooldownModPerLevel,
40
              final Double rPercentMagicPenetrationMod, final Double rPercentMagicPenetrationModPerLevel, final Double rPercentMovementSpeedModPerLevel,
41
              final Double rPercentTimeDeadMod, final Double rPercentTimeDeadModPerLevel) {
42
          this.flatArmorMod = flatArmorMod;
43
          this.flatArmorPenetrationMod = flatArmorPenetrationMod;
44
          this.flatAttackSpeedMod = flatAttackSpeedMod;
45
          this.flatBlockMod = flatBlockMod;
46
          this.flatCritChanceMod = flatCritChanceMod;
47
          this.flatCritDamageMod = flatCritDamageMod;
48
          this.flatEXPBonus = flatEXPBonus;
49
          this.flatEnergyPoolMod = flatEnergyPoolMod;
50
          this.flatEnergyRegenMod = flatEnergyRegenMod;
51
          this.flatGoldPer10Mod = flatGoldPer10Mod;
52
          this.flatHPPoolMod = flatHPPoolMod;
53
          this.flatHPRegenMod = flatHPRegenMod;
54
          this.flatMPPoolMod = flatMPPoolMod;
55
          this.flatMPRegenMod = flatMPRegenMod;
56
          this.flatMagicDamageMod = flatMagicDamageMod;
57
          this.flatMagicPenetrationMod = flatMagicPenetrationMod;
58
          this.flatMovementSpeedMod = flatMovementSpeedMod;
59
          this.flatPhysicalDamageMod = flatPhysicalDamageMod;
60
          this.flatSpellBlockMod = flatSpellBlockMod;
61
          this.percentArmorMod = percentArmorMod;
62
          this.percentArmorPenetrationMod = percentArmorPenetrationMod;
63
          this.percentAttackSpeedMod = percentAttackSpeedMod;
64
          this.percentBlockMod = percentBlockMod;
65
          this.percentCooldownMod = percentCooldownMod;
66
          this.percentCritChanceMod = percentCritChanceMod;
67
          this.percentCritDamageMod = percentCritDamageMod;
68
          this.percentDodgeMod = percentDodgeMod;
69
          this.percentEXPBonus = percentEXPBonus;
70
          this.percentHPPoolMod = percentHPPoolMod;
71
          this.percentHPRegenMod = percentHPRegenMod;
72
          this.percentLifeStealMod = percentLifeStealMod;
73
          this.percentMPPoolMod = percentMPPoolMod;
74
          this.percentMPRegenMod = percentMPRegenMod;
75
          this.percentMagicDamageMod = percentMagicDamageMod;
76
          this.percentMagicPenetrationMod = percentMagicPenetrationMod;
77
          this.percentMovementSpeedMod = percentMovementSpeedMod;
78
          this.percentPhysicalDamageMod = percentPhysicalDamageMod;
79
          this.percentSpellBlockMod = percentSpellBlockMod;
80
          this.percentSpellVampMod = percentSpellVampMod;
81
          this.rFlatArmorModPerLevel = rFlatArmorModPerLevel;
82
          this.rFlatArmorPenetrationMod = rFlatArmorPenetrationMod;
83
          this.rFlatArmorPenetrationModPerLevel = rFlatArmorPenetrationModPerLevel;
84
          this.rFlatCritChanceModPerLevel = rFlatCritChanceModPerLevel;
85
          this.rFlatCritDamageModPerLevel = rFlatCritDamageModPerLevel;
86
          this.rFlatDodgeMod = rFlatDodgeMod;
87
          this.rFlatDodgeModPerLevel = rFlatDodgeModPerLevel;
88
          this.rFlatEnergyModPerLevel = rFlatEnergyModPerLevel;
89
          this.rFlatEnergyRegenModPerLevel = rFlatEnergyRegenModPerLevel;
90
          this.rFlatGoldPer10Mod = rFlatGoldPer10Mod;
91
          this.rFlatHPModPerLevel = rFlatHPModPerLevel;
92
          this.rFlatHPRegenModPerLevel = rFlatHPRegenModPerLevel;
93
          this.rFlatMPModPerLevel = rFlatMPModPerLevel;
94
          this.rFlatMPRegenModPerLevel = rFlatMPRegenModPerLevel;
95
          this.rFlatMagicDamageModPerLevel = rFlatMagicDamageModPerLevel;
96
          this.rFlatMagicPenetrationMod = rFlatMagicPenetrationMod;
97
          this.rFlatMagicPenetrationModPerLevel = rFlatMagicPenetrationModPerLevel;
98
          this.rFlatMovementSpeedModPerLevel = rFlatMovementSpeedModPerLevel;
99
          this.rFlatPhysicalDamageModPerLevel = rFlatPhysicalDamageModPerLevel;
100
         this.rFlatSpellBlockModPerLevel = rFlatSpellBlockModPerLevel;
101
         this.rFlatTimeDeadMod = rFlatTimeDeadMod;
102
         this.rFlatTimeDeadModPerLevel = rFlatTimeDeadModPerLevel;
103
         this.rPercentArmorPenetrationMod = rPercentArmorPenetrationMod;
104
         this.rPercentArmorPenetrationModPerLevel = rPercentArmorPenetrationModPerLevel;
105
         this.rPercentAttackSpeedModPerLevel = rPercentAttackSpeedModPerLevel;
106
         this.rPercentCooldownMod = rPercentCooldownMod;
107
         this.rPercentCooldownModPerLevel = rPercentCooldownModPerLevel;
108
         this.rPercentMagicPenetrationMod = rPercentMagicPenetrationMod;
109
         this.rPercentMagicPenetrationModPerLevel = rPercentMagicPenetrationModPerLevel;
110
         this.rPercentMovementSpeedModPerLevel = rPercentMovementSpeedModPerLevel;
111
         this.rPercentTimeDeadMod = rPercentTimeDeadMod;
112
         this.rPercentTimeDeadModPerLevel = rPercentTimeDeadModPerLevel;
113
     }
114
 
115
     @Override
116
     public boolean equals(final Object obj) {
117
         if(this == obj) {
118
             return true;
119
         }
120
         if(obj == null) {
121
             return false;
122
         }
123
         if(!(obj instanceof BasicDataStats)) {
124
             return false;
125
         }
126
         final BasicDataStats other = (BasicDataStats)obj;
127
         if(flatArmorMod == null) {
128
             if(other.flatArmorMod != null) {
129
                 return false;
130
             }
131
         }
132
         else if(!flatArmorMod.equals(other.flatArmorMod)) {
133
             return false;
134
         }
135
         if(flatArmorPenetrationMod == null) {
136
             if(other.flatArmorPenetrationMod != null) {
137
                 return false;
138
             }
139
         }
140
         else if(!flatArmorPenetrationMod.equals(other.flatArmorPenetrationMod)) {
141
             return false;
142
         }
143
         if(flatAttackSpeedMod == null) {
144
             if(other.flatAttackSpeedMod != null) {
145
                 return false;
146
             }
147
         }
148
         else if(!flatAttackSpeedMod.equals(other.flatAttackSpeedMod)) {
149
             return false;
150
         }
151
         if(flatBlockMod == null) {
152
             if(other.flatBlockMod != null) {
153
                 return false;
154
             }
155
         }
156
         else if(!flatBlockMod.equals(other.flatBlockMod)) {
157
             return false;
158
         }
159
         if(flatCritChanceMod == null) {
160
             if(other.flatCritChanceMod != null) {
161
                 return false;
162
             }
163
         }
164
         else if(!flatCritChanceMod.equals(other.flatCritChanceMod)) {
165
             return false;
166
         }
167
         if(flatCritDamageMod == null) {
168
             if(other.flatCritDamageMod != null) {
169
                 return false;
170
             }
171
         }
172
         else if(!flatCritDamageMod.equals(other.flatCritDamageMod)) {
173
             return false;
174
         }
175
         if(flatEXPBonus == null) {
176
             if(other.flatEXPBonus != null) {
177
                 return false;
178
             }
179
         }
180
         else if(!flatEXPBonus.equals(other.flatEXPBonus)) {
181
             return false;
182
         }
183
         if(flatEnergyPoolMod == null) {
184
             if(other.flatEnergyPoolMod != null) {
185
                 return false;
186
             }
187
         }
188
         else if(!flatEnergyPoolMod.equals(other.flatEnergyPoolMod)) {
189
             return false;
190
         }
191
         if(flatEnergyRegenMod == null) {
192
             if(other.flatEnergyRegenMod != null) {
193
                 return false;
194
             }
195
         }
196
         else if(!flatEnergyRegenMod.equals(other.flatEnergyRegenMod)) {
197
             return false;
198
         }
199
         if(flatGoldPer10Mod == null) {
200
             if(other.flatGoldPer10Mod != null) {
201
                 return false;
202
             }
203
         }
204
         else if(!flatGoldPer10Mod.equals(other.flatGoldPer10Mod)) {
205
             return false;
206
         }
207
         if(flatHPPoolMod == null) {
208
             if(other.flatHPPoolMod != null) {
209
                 return false;
210
             }
211
         }
212
         else if(!flatHPPoolMod.equals(other.flatHPPoolMod)) {
213
             return false;
214
         }
215
         if(flatHPRegenMod == null) {
216
             if(other.flatHPRegenMod != null) {
217
                 return false;
218
             }
219
         }
220
         else if(!flatHPRegenMod.equals(other.flatHPRegenMod)) {
221
             return false;
222
         }
223
         if(flatMPPoolMod == null) {
224
             if(other.flatMPPoolMod != null) {
225
                 return false;
226
             }
227
         }
228
         else if(!flatMPPoolMod.equals(other.flatMPPoolMod)) {
229
             return false;
230
         }
231
         if(flatMPRegenMod == null) {
232
             if(other.flatMPRegenMod != null) {
233
                 return false;
234
             }
235
         }
236
         else if(!flatMPRegenMod.equals(other.flatMPRegenMod)) {
237
             return false;
238
         }
239
         if(flatMagicDamageMod == null) {
240
             if(other.flatMagicDamageMod != null) {
241
                 return false;
242
             }
243
         }
244
         else if(!flatMagicDamageMod.equals(other.flatMagicDamageMod)) {
245
             return false;
246
         }
247
         if(flatMagicPenetrationMod == null) {
248
             if(other.flatMagicPenetrationMod != null) {
249
                 return false;
250
             }
251
         }
252
         else if(!flatMagicPenetrationMod.equals(other.flatMagicPenetrationMod)) {
253
             return false;
254
         }
255
         if(flatMovementSpeedMod == null) {
256
             if(other.flatMovementSpeedMod != null) {
257
                 return false;
258
             }
259
         }
260
         else if(!flatMovementSpeedMod.equals(other.flatMovementSpeedMod)) {
261
             return false;
262
         }
263
         if(flatPhysicalDamageMod == null) {
264
             if(other.flatPhysicalDamageMod != null) {
265
                 return false;
266
             }
267
         }
268
         else if(!flatPhysicalDamageMod.equals(other.flatPhysicalDamageMod)) {
269
             return false;
270
         }
271
         if(flatSpellBlockMod == null) {
272
             if(other.flatSpellBlockMod != null) {
273
                 return false;
274
             }
275
         }
276
         else if(!flatSpellBlockMod.equals(other.flatSpellBlockMod)) {
277
             return false;
278
         }
279
         if(percentArmorMod == null) {
280
             if(other.percentArmorMod != null) {
281
                 return false;
282
             }
283
         }
284
         else if(!percentArmorMod.equals(other.percentArmorMod)) {
285
             return false;
286
         }
287
         if(percentArmorPenetrationMod == null) {
288
             if(other.percentArmorPenetrationMod != null) {
289
                 return false;
290
             }
291
         }
292
         else if(!percentArmorPenetrationMod.equals(other.percentArmorPenetrationMod)) {
293
             return false;
294
         }
295
         if(percentAttackSpeedMod == null) {
296
             if(other.percentAttackSpeedMod != null) {
297
                 return false;
298
             }
299
         }
300
         else if(!percentAttackSpeedMod.equals(other.percentAttackSpeedMod)) {
301
             return false;
302
         }
303
         if(percentBlockMod == null) {
304
             if(other.percentBlockMod != null) {
305
                 return false;
306
             }
307
         }
308
         else if(!percentBlockMod.equals(other.percentBlockMod)) {
309
             return false;
310
         }
311
         if(percentCooldownMod == null) {
312
             if(other.percentCooldownMod != null) {
313
                 return false;
314
             }
315
         }
316
         else if(!percentCooldownMod.equals(other.percentCooldownMod)) {
317
             return false;
318
         }
319
         if(percentCritChanceMod == null) {
320
             if(other.percentCritChanceMod != null) {
321
                 return false;
322
             }
323
         }
324
         else if(!percentCritChanceMod.equals(other.percentCritChanceMod)) {
325
             return false;
326
         }
327
         if(percentCritDamageMod == null) {
328
             if(other.percentCritDamageMod != null) {
329
                 return false;
330
             }
331
         }
332
         else if(!percentCritDamageMod.equals(other.percentCritDamageMod)) {
333
             return false;
334
         }
335
         if(percentDodgeMod == null) {
336
             if(other.percentDodgeMod != null) {
337
                 return false;
338
             }
339
         }
340
         else if(!percentDodgeMod.equals(other.percentDodgeMod)) {
341
             return false;
342
         }
343
         if(percentEXPBonus == null) {
344
             if(other.percentEXPBonus != null) {
345
                 return false;
346
             }
347
         }
348
         else if(!percentEXPBonus.equals(other.percentEXPBonus)) {
349
             return false;
350
         }
351
         if(percentHPPoolMod == null) {
352
             if(other.percentHPPoolMod != null) {
353
                 return false;
354
             }
355
         }
356
         else if(!percentHPPoolMod.equals(other.percentHPPoolMod)) {
357
             return false;
358
         }
359
         if(percentHPRegenMod == null) {
360
             if(other.percentHPRegenMod != null) {
361
                 return false;
362
             }
363
         }
364
         else if(!percentHPRegenMod.equals(other.percentHPRegenMod)) {
365
             return false;
366
         }
367
         if(percentLifeStealMod == null) {
368
             if(other.percentLifeStealMod != null) {
369
                 return false;
370
             }
371
         }
372
         else if(!percentLifeStealMod.equals(other.percentLifeStealMod)) {
373
             return false;
374
         }
375
         if(percentMPPoolMod == null) {
376
             if(other.percentMPPoolMod != null) {
377
                 return false;
378
             }
379
         }
380
         else if(!percentMPPoolMod.equals(other.percentMPPoolMod)) {
381
             return false;
382
         }
383
         if(percentMPRegenMod == null) {
384
             if(other.percentMPRegenMod != null) {
385
                 return false;
386
             }
387
         }
388
         else if(!percentMPRegenMod.equals(other.percentMPRegenMod)) {
389
             return false;
390
         }
391
         if(percentMagicDamageMod == null) {
392
             if(other.percentMagicDamageMod != null) {
393
                 return false;
394
             }
395
         }
396
         else if(!percentMagicDamageMod.equals(other.percentMagicDamageMod)) {
397
             return false;
398
         }
399
         if(percentMagicPenetrationMod == null) {
400
             if(other.percentMagicPenetrationMod != null) {
401
                 return false;
402
             }
403
         }
404
         else if(!percentMagicPenetrationMod.equals(other.percentMagicPenetrationMod)) {
405
             return false;
406
         }
407
         if(percentMovementSpeedMod == null) {
408
             if(other.percentMovementSpeedMod != null) {
409
                 return false;
410
             }
411
         }
412
         else if(!percentMovementSpeedMod.equals(other.percentMovementSpeedMod)) {
413
             return false;
414
         }
415
         if(percentPhysicalDamageMod == null) {
416
             if(other.percentPhysicalDamageMod != null) {
417
                 return false;
418
             }
419
         }
420
         else if(!percentPhysicalDamageMod.equals(other.percentPhysicalDamageMod)) {
421
             return false;
422
         }
423
         if(percentSpellBlockMod == null) {
424
             if(other.percentSpellBlockMod != null) {
425
                 return false;
426
             }
427
         }
428
         else if(!percentSpellBlockMod.equals(other.percentSpellBlockMod)) {
429
             return false;
430
         }
431
         if(percentSpellVampMod == null) {
432
             if(other.percentSpellVampMod != null) {
433
                 return false;
434
             }
435
         }
436
         else if(!percentSpellVampMod.equals(other.percentSpellVampMod)) {
437
             return false;
438
         }
439
         if(rFlatArmorModPerLevel == null) {
440
             if(other.rFlatArmorModPerLevel != null) {
441
                 return false;
442
             }
443
         }
444
         else if(!rFlatArmorModPerLevel.equals(other.rFlatArmorModPerLevel)) {
445
             return false;
446
         }
447
         if(rFlatArmorPenetrationMod == null) {
448
             if(other.rFlatArmorPenetrationMod != null) {
449
                 return false;
450
             }
451
         }
452
         else if(!rFlatArmorPenetrationMod.equals(other.rFlatArmorPenetrationMod)) {
453
             return false;
454
         }
455
         if(rFlatArmorPenetrationModPerLevel == null) {
456
             if(other.rFlatArmorPenetrationModPerLevel != null) {
457
                 return false;
458
             }
459
         }
460
         else if(!rFlatArmorPenetrationModPerLevel.equals(other.rFlatArmorPenetrationModPerLevel)) {
461
             return false;
462
         }
463
         if(rFlatCritChanceModPerLevel == null) {
464
             if(other.rFlatCritChanceModPerLevel != null) {
465
                 return false;
466
             }
467
         }
468
         else if(!rFlatCritChanceModPerLevel.equals(other.rFlatCritChanceModPerLevel)) {
469
             return false;
470
         }
471
         if(rFlatCritDamageModPerLevel == null) {
472
             if(other.rFlatCritDamageModPerLevel != null) {
473
                 return false;
474
             }
475
         }
476
         else if(!rFlatCritDamageModPerLevel.equals(other.rFlatCritDamageModPerLevel)) {
477
             return false;
478
         }
479
         if(rFlatDodgeMod == null) {
480
             if(other.rFlatDodgeMod != null) {
481
                 return false;
482
             }
483
         }
484
         else if(!rFlatDodgeMod.equals(other.rFlatDodgeMod)) {
485
             return false;
486
         }
487
         if(rFlatDodgeModPerLevel == null) {
488
             if(other.rFlatDodgeModPerLevel != null) {
489
                 return false;
490
             }
491
         }
492
         else if(!rFlatDodgeModPerLevel.equals(other.rFlatDodgeModPerLevel)) {
493
             return false;
494
         }
495
         if(rFlatEnergyModPerLevel == null) {
496
             if(other.rFlatEnergyModPerLevel != null) {
497
                 return false;
498
             }
499
         }
500
         else if(!rFlatEnergyModPerLevel.equals(other.rFlatEnergyModPerLevel)) {
501
             return false;
502
         }
503
         if(rFlatEnergyRegenModPerLevel == null) {
504
             if(other.rFlatEnergyRegenModPerLevel != null) {
505
                 return false;
506
             }
507
         }
508
         else if(!rFlatEnergyRegenModPerLevel.equals(other.rFlatEnergyRegenModPerLevel)) {
509
             return false;
510
         }
511
         if(rFlatGoldPer10Mod == null) {
512
             if(other.rFlatGoldPer10Mod != null) {
513
                 return false;
514
             }
515
         }
516
         else if(!rFlatGoldPer10Mod.equals(other.rFlatGoldPer10Mod)) {
517
             return false;
518
         }
519
         if(rFlatHPModPerLevel == null) {
520
             if(other.rFlatHPModPerLevel != null) {
521
                 return false;
522
             }
523
         }
524
         else if(!rFlatHPModPerLevel.equals(other.rFlatHPModPerLevel)) {
525
             return false;
526
         }
527
         if(rFlatHPRegenModPerLevel == null) {
528
             if(other.rFlatHPRegenModPerLevel != null) {
529
                 return false;
530
             }
531
         }
532
         else if(!rFlatHPRegenModPerLevel.equals(other.rFlatHPRegenModPerLevel)) {
533
             return false;
534
         }
535
         if(rFlatMPModPerLevel == null) {
536
             if(other.rFlatMPModPerLevel != null) {
537
                 return false;
538
             }
539
         }
540
         else if(!rFlatMPModPerLevel.equals(other.rFlatMPModPerLevel)) {
541
             return false;
542
         }
543
         if(rFlatMPRegenModPerLevel == null) {
544
             if(other.rFlatMPRegenModPerLevel != null) {
545
                 return false;
546
             }
547
         }
548
         else if(!rFlatMPRegenModPerLevel.equals(other.rFlatMPRegenModPerLevel)) {
549
             return false;
550
         }
551
         if(rFlatMagicDamageModPerLevel == null) {
552
             if(other.rFlatMagicDamageModPerLevel != null) {
553
                 return false;
554
             }
555
         }
556
         else if(!rFlatMagicDamageModPerLevel.equals(other.rFlatMagicDamageModPerLevel)) {
557
             return false;
558
         }
559
         if(rFlatMagicPenetrationMod == null) {
560
             if(other.rFlatMagicPenetrationMod != null) {
561
                 return false;
562
             }
563
         }
564
         else if(!rFlatMagicPenetrationMod.equals(other.rFlatMagicPenetrationMod)) {
565
             return false;
566
         }
567
         if(rFlatMagicPenetrationModPerLevel == null) {
568
             if(other.rFlatMagicPenetrationModPerLevel != null) {
569
                 return false;
570
             }
571
         }
572
         else if(!rFlatMagicPenetrationModPerLevel.equals(other.rFlatMagicPenetrationModPerLevel)) {
573
             return false;
574
         }
575
         if(rFlatMovementSpeedModPerLevel == null) {
576
             if(other.rFlatMovementSpeedModPerLevel != null) {
577
                 return false;
578
             }
579
         }
580
         else if(!rFlatMovementSpeedModPerLevel.equals(other.rFlatMovementSpeedModPerLevel)) {
581
             return false;
582
         }
583
         if(rFlatPhysicalDamageModPerLevel == null) {
584
             if(other.rFlatPhysicalDamageModPerLevel != null) {
585
                 return false;
586
             }
587
         }
588
         else if(!rFlatPhysicalDamageModPerLevel.equals(other.rFlatPhysicalDamageModPerLevel)) {
589
             return false;
590
         }
591
         if(rFlatSpellBlockModPerLevel == null) {
592
             if(other.rFlatSpellBlockModPerLevel != null) {
593
                 return false;
594
             }
595
         }
596
         else if(!rFlatSpellBlockModPerLevel.equals(other.rFlatSpellBlockModPerLevel)) {
597
             return false;
598
         }
599
         if(rFlatTimeDeadMod == null) {
600
             if(other.rFlatTimeDeadMod != null) {
601
                 return false;
602
             }
603
         }
604
         else if(!rFlatTimeDeadMod.equals(other.rFlatTimeDeadMod)) {
605
             return false;
606
         }
607
         if(rFlatTimeDeadModPerLevel == null) {
608
             if(other.rFlatTimeDeadModPerLevel != null) {
609
                 return false;
610
             }
611
         }
612
         else if(!rFlatTimeDeadModPerLevel.equals(other.rFlatTimeDeadModPerLevel)) {
613
             return false;
614
         }
615
         if(rPercentArmorPenetrationMod == null) {
616
             if(other.rPercentArmorPenetrationMod != null) {
617
                 return false;
618
             }
619
         }
620
         else if(!rPercentArmorPenetrationMod.equals(other.rPercentArmorPenetrationMod)) {
621
             return false;
622
         }
623
         if(rPercentArmorPenetrationModPerLevel == null) {
624
             if(other.rPercentArmorPenetrationModPerLevel != null) {
625
                 return false;
626
             }
627
         }
628
         else if(!rPercentArmorPenetrationModPerLevel.equals(other.rPercentArmorPenetrationModPerLevel)) {
629
             return false;
630
         }
631
         if(rPercentAttackSpeedModPerLevel == null) {
632
             if(other.rPercentAttackSpeedModPerLevel != null) {
633
                 return false;
634
             }
635
         }
636
         else if(!rPercentAttackSpeedModPerLevel.equals(other.rPercentAttackSpeedModPerLevel)) {
637
             return false;
638
         }
639
         if(rPercentCooldownMod == null) {
640
             if(other.rPercentCooldownMod != null) {
641
                 return false;
642
             }
643
         }
644
         else if(!rPercentCooldownMod.equals(other.rPercentCooldownMod)) {
645
             return false;
646
         }
647
         if(rPercentCooldownModPerLevel == null) {
648
             if(other.rPercentCooldownModPerLevel != null) {
649
                 return false;
650
             }
651
         }
652
         else if(!rPercentCooldownModPerLevel.equals(other.rPercentCooldownModPerLevel)) {
653
             return false;
654
         }
655
         if(rPercentMagicPenetrationMod == null) {
656
             if(other.rPercentMagicPenetrationMod != null) {
657
                 return false;
658
             }
659
         }
660
         else if(!rPercentMagicPenetrationMod.equals(other.rPercentMagicPenetrationMod)) {
661
             return false;
662
         }
663
         if(rPercentMagicPenetrationModPerLevel == null) {
664
             if(other.rPercentMagicPenetrationModPerLevel != null) {
665
                 return false;
666
             }
667
         }
668
         else if(!rPercentMagicPenetrationModPerLevel.equals(other.rPercentMagicPenetrationModPerLevel)) {
669
             return false;
670
         }
671
         if(rPercentMovementSpeedModPerLevel == null) {
672
             if(other.rPercentMovementSpeedModPerLevel != null) {
673
                 return false;
674
             }
675
         }
676
         else if(!rPercentMovementSpeedModPerLevel.equals(other.rPercentMovementSpeedModPerLevel)) {
677
             return false;
678
         }
679
         if(rPercentTimeDeadMod == null) {
680
             if(other.rPercentTimeDeadMod != null) {
681
                 return false;
682
             }
683
         }
684
         else if(!rPercentTimeDeadMod.equals(other.rPercentTimeDeadMod)) {
685
             return false;
686
         }
687
         if(rPercentTimeDeadModPerLevel == null) {
688
             if(other.rPercentTimeDeadModPerLevel != null) {
689
                 return false;
690
             }
691
         }
692
         else if(!rPercentTimeDeadModPerLevel.equals(other.rPercentTimeDeadModPerLevel)) {
693
             return false;
694
         }
695
         return true;
696
     }
697
 
698
     @Override
699
     public int hashCode() {
700
         final int prime = 31;
701
         int result = 1;
702
         result = prime * result + (flatArmorMod == null ? 0 : flatArmorMod.hashCode());
703
         result = prime * result + (flatArmorPenetrationMod == null ? 0 : flatArmorPenetrationMod.hashCode());
704
         result = prime * result + (flatAttackSpeedMod == null ? 0 : flatAttackSpeedMod.hashCode());
705
         result = prime * result + (flatBlockMod == null ? 0 : flatBlockMod.hashCode());
706
         result = prime * result + (flatCritChanceMod == null ? 0 : flatCritChanceMod.hashCode());
707
         result = prime * result + (flatCritDamageMod == null ? 0 : flatCritDamageMod.hashCode());
708
         result = prime * result + (flatEXPBonus == null ? 0 : flatEXPBonus.hashCode());
709
         result = prime * result + (flatEnergyPoolMod == null ? 0 : flatEnergyPoolMod.hashCode());
710
         result = prime * result + (flatEnergyRegenMod == null ? 0 : flatEnergyRegenMod.hashCode());
711
         result = prime * result + (flatGoldPer10Mod == null ? 0 : flatGoldPer10Mod.hashCode());
712
         result = prime * result + (flatHPPoolMod == null ? 0 : flatHPPoolMod.hashCode());
713
         result = prime * result + (flatHPRegenMod == null ? 0 : flatHPRegenMod.hashCode());
714
         result = prime * result + (flatMPPoolMod == null ? 0 : flatMPPoolMod.hashCode());
715
         result = prime * result + (flatMPRegenMod == null ? 0 : flatMPRegenMod.hashCode());
716
         result = prime * result + (flatMagicDamageMod == null ? 0 : flatMagicDamageMod.hashCode());
717
         result = prime * result + (flatMagicPenetrationMod == null ? 0 : flatMagicPenetrationMod.hashCode());
718
         result = prime * result + (flatMovementSpeedMod == null ? 0 : flatMovementSpeedMod.hashCode());
719
         result = prime * result + (flatPhysicalDamageMod == null ? 0 : flatPhysicalDamageMod.hashCode());
720
         result = prime * result + (flatSpellBlockMod == null ? 0 : flatSpellBlockMod.hashCode());
721
         result = prime * result + (percentArmorMod == null ? 0 : percentArmorMod.hashCode());
722
         result = prime * result + (percentArmorPenetrationMod == null ? 0 : percentArmorPenetrationMod.hashCode());
723
         result = prime * result + (percentAttackSpeedMod == null ? 0 : percentAttackSpeedMod.hashCode());
724
         result = prime * result + (percentBlockMod == null ? 0 : percentBlockMod.hashCode());
725
         result = prime * result + (percentCooldownMod == null ? 0 : percentCooldownMod.hashCode());
726
         result = prime * result + (percentCritChanceMod == null ? 0 : percentCritChanceMod.hashCode());
727
         result = prime * result + (percentCritDamageMod == null ? 0 : percentCritDamageMod.hashCode());
728
         result = prime * result + (percentDodgeMod == null ? 0 : percentDodgeMod.hashCode());
729
         result = prime * result + (percentEXPBonus == null ? 0 : percentEXPBonus.hashCode());
730
         result = prime * result + (percentHPPoolMod == null ? 0 : percentHPPoolMod.hashCode());
731
         result = prime * result + (percentHPRegenMod == null ? 0 : percentHPRegenMod.hashCode());
732
         result = prime * result + (percentLifeStealMod == null ? 0 : percentLifeStealMod.hashCode());
733
         result = prime * result + (percentMPPoolMod == null ? 0 : percentMPPoolMod.hashCode());
734
         result = prime * result + (percentMPRegenMod == null ? 0 : percentMPRegenMod.hashCode());
735
         result = prime * result + (percentMagicDamageMod == null ? 0 : percentMagicDamageMod.hashCode());
736
         result = prime * result + (percentMagicPenetrationMod == null ? 0 : percentMagicPenetrationMod.hashCode());
737
         result = prime * result + (percentMovementSpeedMod == null ? 0 : percentMovementSpeedMod.hashCode());
738
         result = prime * result + (percentPhysicalDamageMod == null ? 0 : percentPhysicalDamageMod.hashCode());
739
         result = prime * result + (percentSpellBlockMod == null ? 0 : percentSpellBlockMod.hashCode());
740
         result = prime * result + (percentSpellVampMod == null ? 0 : percentSpellVampMod.hashCode());
741
         result = prime * result + (rFlatArmorModPerLevel == null ? 0 : rFlatArmorModPerLevel.hashCode());
742
         result = prime * result + (rFlatArmorPenetrationMod == null ? 0 : rFlatArmorPenetrationMod.hashCode());
743
         result = prime * result + (rFlatArmorPenetrationModPerLevel == null ? 0 : rFlatArmorPenetrationModPerLevel.hashCode());
744
         result = prime * result + (rFlatCritChanceModPerLevel == null ? 0 : rFlatCritChanceModPerLevel.hashCode());
745
         result = prime * result + (rFlatCritDamageModPerLevel == null ? 0 : rFlatCritDamageModPerLevel.hashCode());
746
         result = prime * result + (rFlatDodgeMod == null ? 0 : rFlatDodgeMod.hashCode());
747
         result = prime * result + (rFlatDodgeModPerLevel == null ? 0 : rFlatDodgeModPerLevel.hashCode());
748
         result = prime * result + (rFlatEnergyModPerLevel == null ? 0 : rFlatEnergyModPerLevel.hashCode());
749
         result = prime * result + (rFlatEnergyRegenModPerLevel == null ? 0 : rFlatEnergyRegenModPerLevel.hashCode());
750
         result = prime * result + (rFlatGoldPer10Mod == null ? 0 : rFlatGoldPer10Mod.hashCode());
751
         result = prime * result + (rFlatHPModPerLevel == null ? 0 : rFlatHPModPerLevel.hashCode());
752
         result = prime * result + (rFlatHPRegenModPerLevel == null ? 0 : rFlatHPRegenModPerLevel.hashCode());
753
         result = prime * result + (rFlatMPModPerLevel == null ? 0 : rFlatMPModPerLevel.hashCode());
754
         result = prime * result + (rFlatMPRegenModPerLevel == null ? 0 : rFlatMPRegenModPerLevel.hashCode());
755
         result = prime * result + (rFlatMagicDamageModPerLevel == null ? 0 : rFlatMagicDamageModPerLevel.hashCode());
756
         result = prime * result + (rFlatMagicPenetrationMod == null ? 0 : rFlatMagicPenetrationMod.hashCode());
757
         result = prime * result + (rFlatMagicPenetrationModPerLevel == null ? 0 : rFlatMagicPenetrationModPerLevel.hashCode());
758
         result = prime * result + (rFlatMovementSpeedModPerLevel == null ? 0 : rFlatMovementSpeedModPerLevel.hashCode());
759
         result = prime * result + (rFlatPhysicalDamageModPerLevel == null ? 0 : rFlatPhysicalDamageModPerLevel.hashCode());
760
         result = prime * result + (rFlatSpellBlockModPerLevel == null ? 0 : rFlatSpellBlockModPerLevel.hashCode());
761
         result = prime * result + (rFlatTimeDeadMod == null ? 0 : rFlatTimeDeadMod.hashCode());
762
         result = prime * result + (rFlatTimeDeadModPerLevel == null ? 0 : rFlatTimeDeadModPerLevel.hashCode());
763
         result = prime * result + (rPercentArmorPenetrationMod == null ? 0 : rPercentArmorPenetrationMod.hashCode());
764
         result = prime * result + (rPercentArmorPenetrationModPerLevel == null ? 0 : rPercentArmorPenetrationModPerLevel.hashCode());
765
         result = prime * result + (rPercentAttackSpeedModPerLevel == null ? 0 : rPercentAttackSpeedModPerLevel.hashCode());
766
         result = prime * result + (rPercentCooldownMod == null ? 0 : rPercentCooldownMod.hashCode());
767
         result = prime * result + (rPercentCooldownModPerLevel == null ? 0 : rPercentCooldownModPerLevel.hashCode());
768
         result = prime * result + (rPercentMagicPenetrationMod == null ? 0 : rPercentMagicPenetrationMod.hashCode());
769
         result = prime * result + (rPercentMagicPenetrationModPerLevel == null ? 0 : rPercentMagicPenetrationModPerLevel.hashCode());
770
         result = prime * result + (rPercentMovementSpeedModPerLevel == null ? 0 : rPercentMovementSpeedModPerLevel.hashCode());
771
         result = prime * result + (rPercentTimeDeadMod == null ? 0 : rPercentTimeDeadMod.hashCode());
772
         result = prime * result + (rPercentTimeDeadModPerLevel == null ? 0 : rPercentTimeDeadModPerLevel.hashCode());
773
         return result;
774
     }

    
 Gets only the stats which weren't null

 
 Returns:the non-null stats
780
 
781
     public Map<String, Double> nonNullStats() {
782
         final Map<String, Double> nonNull = new HashMap<String, Double>();
783
         if(flatArmorMod != null) {
784
             nonNull.put("flatArmorMod", flatArmorMod);
785
         }
786
         if(flatArmorPenetrationMod != null) {
787
             nonNull.put("flatArmorPenetrationMod", flatArmorPenetrationMod);
788
         }
789
         if(flatAttackSpeedMod != null) {
790
             nonNull.put("flatAttackSpeedMod", flatAttackSpeedMod);
791
         }
792
         if(flatBlockMod != null) {
793
             nonNull.put("flatBlockMod", flatBlockMod);
794
         }
795
         if(flatCritChanceMod != null) {
796
             nonNull.put("flatCritChanceMod", flatCritChanceMod);
797
         }
798
         if(flatCritDamageMod != null) {
799
             nonNull.put("flatCritDamageMod", flatCritDamageMod);
800
         }
801
         if(flatEXPBonus != null) {
802
             nonNull.put("flatEXPBonus", flatEXPBonus);
803
         }
804
         if(flatEnergyPoolMod != null) {
805
             nonNull.put("flatEnergyPoolMod", flatEnergyPoolMod);
806
         }
807
         if(flatEnergyRegenMod != null) {
808
             nonNull.put("flatEnergyRegenMod", flatEnergyRegenMod);
809
         }
810
         if(flatGoldPer10Mod != null) {
811
             nonNull.put("flatGoldPer10Mod", flatGoldPer10Mod);
812
         }
813
         if(flatHPPoolMod != null) {
814
             nonNull.put("flatHPPoolMod", flatHPPoolMod);
815
         }
816
         if(flatHPRegenMod != null) {
817
             nonNull.put("flatHPRegenMod", flatHPRegenMod);
818
         }
819
         if(flatMPPoolMod != null) {
820
             nonNull.put("flatMPPoolMod", flatMPPoolMod);
821
         }
822
         if(flatMPRegenMod != null) {
823
             nonNull.put("flatMPRegenMod", flatMPRegenMod);
824
         }
825
         if(flatMagicDamageMod != null) {
826
             nonNull.put("flatMagicDamageMod", flatMagicDamageMod);
827
         }
828
         if(flatMagicPenetrationMod != null) {
829
             nonNull.put("flatMagicPenetrationMod", flatMagicPenetrationMod);
830
         }
831
         if(flatMovementSpeedMod != null) {
832
             nonNull.put("flatMovementSpeedMod", flatMovementSpeedMod);
833
         }
834
         if(flatPhysicalDamageMod != null) {
835
             nonNull.put("flatPhysicalDamageMod", flatPhysicalDamageMod);
836
         }
837
         if(flatSpellBlockMod != null) {
838
             nonNull.put("flatSpellBlockMod", flatSpellBlockMod);
839
         }
840
         if(percentArmorMod != null) {
841
             nonNull.put("percentArmorMod", percentArmorMod);
842
         }
843
         if(percentArmorPenetrationMod != null) {
844
             nonNull.put("percentArmorPenetrationMod", percentArmorPenetrationMod);
845
         }
846
         if(percentAttackSpeedMod != null) {
847
             nonNull.put("percentAttackSpeedMod", percentAttackSpeedMod);
848
         }
849
         if(percentBlockMod != null) {
850
             nonNull.put("percentBlockMod", percentBlockMod);
851
         }
852
         if(percentCooldownMod != null) {
853
             nonNull.put("percentCooldownMod", percentCooldownMod);
854
         }
855
         if(percentCritChanceMod != null) {
856
             nonNull.put("percentCritChanceMod", percentCritChanceMod);
857
         }
858
         if(percentCritDamageMod != null) {
859
             nonNull.put("percentCritDamageMod", percentCritDamageMod);
860
         }
861
         if(percentDodgeMod != null) {
862
             nonNull.put("percentDodgeMod", percentDodgeMod);
863
         }
864
         if(percentEXPBonus != null) {
865
             nonNull.put("percentEXPBonus", percentEXPBonus);
866
         }
867
         if(percentHPPoolMod != null) {
868
             nonNull.put("percentHPPoolMod", percentHPPoolMod);
869
         }
870
         if(percentHPRegenMod != null) {
871
             nonNull.put("percentHPRegenMod", percentHPRegenMod);
872
         }
873
         if(percentLifeStealMod != null) {
874
             nonNull.put("percentLifeStealMod", percentLifeStealMod);
875
         }
876
         if(percentMPPoolMod != null) {
877
             nonNull.put("percentMPPoolMod", percentMPPoolMod);
878
         }
879
         if(percentMPRegenMod != null) {
880
             nonNull.put("percentMPRegenMod", percentMPRegenMod);
881
         }
882
         if(percentMagicDamageMod != null) {
883
             nonNull.put("percentMagicDamageMod", percentMagicDamageMod);
884
         }
885
         if(percentMagicPenetrationMod != null) {
886
             nonNull.put("percentMagicPenetrationMod", percentMagicPenetrationMod);
887
         }
888
         if(percentMovementSpeedMod != null) {
889
             nonNull.put("percentMovementSpeedMod", percentMovementSpeedMod);
890
         }
891
         if(percentPhysicalDamageMod != null) {
892
             nonNull.put("percentPhysicalDamageMod", percentPhysicalDamageMod);
893
         }
894
         if(percentSpellBlockMod != null) {
895
             nonNull.put("percentSpellBlockMod", percentSpellBlockMod);
896
         }
897
         if(percentSpellVampMod != null) {
898
             nonNull.put("percentSpellVampMod", percentSpellVampMod);
899
         }
900
         if(rFlatArmorModPerLevel != null) {
901
             nonNull.put("rFlatArmorModPerLevel", rFlatArmorModPerLevel);
902
         }
903
         if(rFlatArmorPenetrationMod != null) {
904
             nonNull.put("rFlatArmorPenetrationMod", rFlatArmorPenetrationMod);
905
         }
906
         if(rFlatArmorPenetrationModPerLevel != null) {
907
             nonNull.put("rFlatArmorPenetrationModPerLevel", rFlatArmorPenetrationModPerLevel);
908
         }
909
         if(rFlatCritChanceModPerLevel != null) {
910
             nonNull.put("rFlatCritChanceModPerLevel", rFlatCritChanceModPerLevel);
911
         }
912
         if(rFlatCritDamageModPerLevel != null) {
913
             nonNull.put("rFlatCritDamageModPerLevel", rFlatCritDamageModPerLevel);
914
         }
915
         if(rFlatDodgeMod != null) {
916
             nonNull.put("rFlatDodgeMod", rFlatDodgeMod);
917
         }
918
         if(rFlatDodgeModPerLevel != null) {
919
             nonNull.put("rFlatDodgeModPerLevel", rFlatDodgeModPerLevel);
920
         }
921
         if(rFlatEnergyModPerLevel != null) {
922
             nonNull.put("rFlatEnergyModPerLevel", rFlatEnergyModPerLevel);
923
         }
924
         if(rFlatEnergyRegenModPerLevel != null) {
925
             nonNull.put("rFlatEnergyRegenModPerLevel", rFlatEnergyRegenModPerLevel);
926
         }
927
         if(rFlatGoldPer10Mod != null) {
928
             nonNull.put("rFlatGoldPer10Mod", rFlatGoldPer10Mod);
929
         }
930
         if(rFlatHPModPerLevel != null) {
931
             nonNull.put("rFlatHPModPerLevel", rFlatHPModPerLevel);
932
         }
933
         if(rFlatHPRegenModPerLevel != null) {
934
             nonNull.put("rFlatHPRegenModPerLevel", rFlatHPRegenModPerLevel);
935
         }
936
         if(rFlatMPModPerLevel != null) {
937
             nonNull.put("rFlatMPModPerLevel", rFlatMPModPerLevel);
938
         }
939
         if(rFlatMPRegenModPerLevel != null) {
940
             nonNull.put("rFlatMPRegenModPerLevel", rFlatMPRegenModPerLevel);
941
         }
942
         if(rFlatMagicDamageModPerLevel != null) {
943
             nonNull.put("rFlatMagicDamageModPerLevel", rFlatMagicDamageModPerLevel);
944
         }
945
         if(rFlatMagicPenetrationMod != null) {
946
             nonNull.put("rFlatMagicPenetrationMod", rFlatMagicPenetrationMod);
947
         }
948
         if(rFlatMagicPenetrationModPerLevel != null) {
949
             nonNull.put("rFlatMagicPenetrationModPerLevel", rFlatMagicPenetrationModPerLevel);
950
         }
951
         if(rFlatMovementSpeedModPerLevel != null) {
952
             nonNull.put("rFlatMovementSpeedModPerLevel", rFlatMovementSpeedModPerLevel);
953
         }
954
         if(rFlatPhysicalDamageModPerLevel != null) {
955
             nonNull.put("rFlatPhysicalDamageModPerLevel", rFlatPhysicalDamageModPerLevel);
956
         }
957
         if(rFlatSpellBlockModPerLevel != null) {
958
             nonNull.put("rFlatSpellBlockModPerLevel", rFlatSpellBlockModPerLevel);
959
         }
960
         if(rFlatTimeDeadMod != null) {
961
             nonNull.put("rFlatTimeDeadMod", rFlatTimeDeadMod);
962
         }
963
         if(rFlatTimeDeadModPerLevel != null) {
964
             nonNull.put("rFlatTimeDeadModPerLevel", rFlatTimeDeadModPerLevel);
965
         }
966
         if(rPercentArmorPenetrationMod != null) {
967
             nonNull.put("rPercentArmorPenetrationMod", rPercentArmorPenetrationMod);
968
         }
969
         if(rPercentArmorPenetrationModPerLevel != null) {
970
             nonNull.put("rPercentArmorPenetrationModPerLevel", rPercentArmorPenetrationModPerLevel);
971
         }
972
         if(rPercentAttackSpeedModPerLevel != null) {
973
             nonNull.put("rPercentAttackSpeedModPerLevel", rPercentAttackSpeedModPerLevel);
974
         }
975
         if(rPercentCooldownMod != null) {
976
             nonNull.put("rPercentCooldownMod", rPercentCooldownMod);
977
         }
978
         if(rPercentCooldownModPerLevel != null) {
979
             nonNull.put("rPercentCooldownModPerLevel", rPercentCooldownModPerLevel);
980
         }
981
         if(rPercentMagicPenetrationMod != null) {
982
             nonNull.put("rPercentMagicPenetrationMod", rPercentMagicPenetrationMod);
983
         }
984
         if(rPercentMagicPenetrationModPerLevel != null) {
985
             nonNull.put("rPercentMagicPenetrationModPerLevel", rPercentMagicPenetrationModPerLevel);
986
         }
987
         if(rPercentMovementSpeedModPerLevel != null) {
988
             nonNull.put("rPercentMovementSpeedModPerLevel", rPercentMovementSpeedModPerLevel);
989
         }
990
         if(rPercentTimeDeadMod != null) {
991
             nonNull.put("rPercentTimeDeadMod", rPercentTimeDeadMod);
992
         }
993
         if(rPercentTimeDeadModPerLevel != null) {
994
             nonNull.put("rPercentTimeDeadModPerLevel", rPercentTimeDeadModPerLevel);
995
         }