游戏中精灵对象的属性功能设计

我们大部分it人事可能都玩过游戏，且不止一款游戏，都知道游戏有属性；
在游戏中，包含哪些属性，时候数值策划而定；

属性牵涉三个大问题，

1，属性不管是前期还是后期变更可能会非常大；

2，存在不同的属性系统，比如人物基础属性，坐骑属性，宠物属性等；

3，属性计算；属性最终计算；

 

第一条和第二条，是非常息息相关的功能块设计；需要做到统一，方便，且可扩展性设计；

有且是对策划在配置各种属性，各种系统中去配置属性，既要他们方便配置，思路清晰，又要方便程序扩展，转化；

1 package com.game.engine.struct;
2
3 import java.io.Serializable;
4
5 /**
6  * 基础属性结果
7  *
8  * <br>
9  * author 失足程序员<br>
10  * mail 492794628@qq.com<br>
11  * phone 13882122019<br>
12  */
13 public class BaseAbility implements Serializable {
14
15     private static final long serialVersionUID = 7331996190994084714L;
16     /**
17      * 攻击速度
18      */
19     private int attackSpeed;
20     /**
21      * 力量,1001
22      */
23     private int strength;
24     /**
25      * 主动,1002
26      */
27     private int initiative;
28     /**
29      * 智慧,1003
30      */
31     private int intelligence;
32     /**
33      * 意志,1004
34      */
35     private int willpower;
36     /**
37      * 体魄,1005
38      */
39     private int wounds;
40     //物理攻击下限
41     private int dcmin;
42     //物理攻击上限
43     private int dcmax;
44     //魔法攻击下限
45     private int mcmin;
46     //魔法攻击上限
47     private int mcmax;
48     //物理防御
49     private int ac;
50     //魔法防御
51     private int mac;
52     //闪避
53     private int duck;
54     //命中率
55     private int hit;
56     //韧性
57     private int toughness;
58     //暴击值（概率）
59     private int critValuePer;
60     //暴击值
61     private int critvalue;
62     //自动回血
63     private int autohp;
64     //战斗中回复
65     private int auto_battle_hp;
66     //自动回魔法值
67     private int automp;
68     //战斗中回复
69     private int auto_battle_mp;
70     //最大血量
71     private int hpmax;
72     //最大魔法
73     private int mpmax;
74     //升级的最大经验值
75     private long expmax;
76     //速度
77     private int speed;
78     //物理减伤
79     private int dcharmdel;
80     //魔法减伤
81     private int mcharmdel;
82     //物理反伤
83     private int undcharmdel;
84     //魔法反伤
85     private int unmcharmdel;
86     //吸血属性
87     private int drains;
88
89     //--------------上面需要传到前端，下面不需要----------------//
90     //经验加成
91     private int expmultiple;
92
93     //属性提供的战斗力
94     private int fight;
95
96     public BaseAbility() {
97     }
98
99     public int getAttackSpeed() {
100         return attackSpeed;
101     }
102
103     public void setAttackSpeed(int attackSpeed) {
104         this.attackSpeed = attackSpeed;
105     }
106
107     public int getStrength() {
108         return strength;
109     }
110
111     public void setStrength(int strength) {
112         this.strength = strength;
113     }
114
115     public int getInitiative() {
116         return initiative;
117     }
118
119     public void setInitiative(int initiative) {
120         this.initiative = initiative;
121     }
122
123     public int getIntelligence() {
124         return intelligence;
125     }
126
127     public void setIntelligence(int intelligence) {
128         this.intelligence = intelligence;
129     }
130
131     public int getWillpower() {
132         return willpower;
133     }
134
135     public void setWillpower(int willpower) {
136         this.willpower = willpower;
137     }
138
139     public int getWounds() {
140         return wounds;
141     }
142
143     public void setWounds(int wounds) {
144         this.wounds = wounds;
145     }
146
147     public int getDcmin() {
148         return dcmin;
149     }
150
151     public void setDcmin(int dcmin) {
152         this.dcmin = dcmin;
153     }
154
155     public int getDcmax() {
156         return dcmax;
157     }
158
159     public void setDcmax(int dcmax) {
160         this.dcmax = dcmax;
161     }
162
163     public int getMcmin() {
164         return mcmin;
165     }
166
167     public void setMcmin(int mcmin) {
168         this.mcmin = mcmin;
169     }
170
171     public int getMcmax() {
172         return mcmax;
173     }
174
175     public void setMcmax(int mcmax) {
176         this.mcmax = mcmax;
177     }
178
179     public int getAc() {
180         return ac;
181     }
182
183     public void setAc(int ac) {
184         this.ac = ac;
185     }
186
187     public int getMac() {
188         return mac;
189     }
190
191     public void setMac(int mac) {
192         this.mac = mac;
193     }
194
195     public int getDuck() {
196         return duck;
197     }
198
199     public void setDuck(int duck) {
200         this.duck = duck;
201     }
202
203     public int getHit() {
204         return hit;
205     }
206
207     public void setHit(int hit) {
208         this.hit = hit;
209     }
210
211     public int getToughness() {
212         return toughness;
213     }
214
215     public void setToughness(int toughness) {
216         this.toughness = toughness;
217     }
218
219     public int getCritValuePer() {
220         return critValuePer;
221     }
222
223     public void setCritValuePer(int critValuePer) {
224         this.critValuePer = critValuePer;
225     }
226
227     public int getCritvalue() {
228         return critvalue;
229     }
230
231     public void setCritvalue(int critvalue) {
232         this.critvalue = critvalue;
233     }
234
235     public int getAutohp() {
236         return autohp;
237     }
238
239     public void setAutohp(int autohp) {
240         this.autohp = autohp;
241     }
242
243     public int getAuto_battle_hp() {
244         return auto_battle_hp;
245     }
246
247     public void setAuto_battle_hp(int auto_battle_hp) {
248         this.auto_battle_hp = auto_battle_hp;
249     }
250
251     public int getAutomp() {
252         return automp;
253     }
254
255     public void setAutomp(int automp) {
256         this.automp = automp;
257     }
258
259     public int getAuto_battle_mp() {
260         return auto_battle_mp;
261     }
262
263     public void setAuto_battle_mp(int auto_battle_mp) {
264         this.auto_battle_mp = auto_battle_mp;
265     }
266
267     public int getHpmax() {
268         return hpmax;
269     }
270
271     public void setHpmax(int hpmax) {
272         this.hpmax = hpmax;
273     }
274
275     public int getMpmax() {
276         return mpmax;
277     }
278
279     public void setMpmax(int mpmax) {
280         this.mpmax = mpmax;
281     }
282
283     public long getExpmax() {
284         return expmax;
285     }
286
287     public void setExpmax(long expmax) {
288         this.expmax = expmax;
289     }
290
291     public int getSpeed() {
292         return speed;
293     }
294
295     public void setSpeed(int speed) {
296         this.speed = speed;
297     }
298
299     public int getDcharmdel() {
300         return dcharmdel;
301     }
302
303     public void setDcharmdel(int dcharmdel) {
304         this.dcharmdel = dcharmdel;
305     }
306
307     public int getMcharmdel() {
308         return mcharmdel;
309     }
310
311     public void setMcharmdel(int mcharmdel) {
312         this.mcharmdel = mcharmdel;
313     }
314
315     public int getUndcharmdel() {
316         return undcharmdel;
317     }
318
319     public void setUndcharmdel(int undcharmdel) {
320         this.undcharmdel = undcharmdel;
321     }
322
323     public int getUnmcharmdel() {
324         return unmcharmdel;
325     }
326
327     public void setUnmcharmdel(int unmcharmdel) {
328         this.unmcharmdel = unmcharmdel;
329     }
330
331     public int getDrains() {
332         return drains;
333     }
334
335     public void setDrains(int drains) {
336         this.drains = drains;
337     }
338
339     public int getExpmultiple() {
340         return expmultiple;
341     }
342
343     public void setExpmultiple(int expmultiple) {
344         this.expmultiple = expmultiple;
345     }
346
347     public int getFight() {
348         return fight;
349     }
350
351     public void setFight(int fight) {
352         this.fight = fight;
353     }
354
355     /**
356      * 属性清零
357      *
358      */
359     public void clearZero() {
360         this.strength = 0;
361         /**
362          * 主动,1002
363          */
364         this.initiative = 0;
365         /**
366          * 智慧,1003
367          */
368         this.intelligence = 0;
369         /**
370          * 意志,1004
371          */
372         this.willpower = 0;
373         /**
374          * 体魄,1005
375          */
376         this.wounds = 0;
377         this.attackSpeed = 0;
378         this.dcmin = 0;
379         this.dcmax = 0;
380         this.mcmin = 0;
381         this.mcmax = 0;
382         this.ac = 0;
383         this.mac = 0;
384         this.duck = 0;
385         this.hit = 0;
386         this.toughness = 0;
387         this.critvalue = 0;
388         this.critValuePer = 0;
389         this.autohp = 0;
390         this.auto_battle_hp = 0;
391         this.automp = 0;
392         this.auto_battle_mp = 0;
393         this.hpmax = 0;
394         this.mpmax = 0;
395         this.expmax = 0;
396         this.speed = 0;
397         this.dcharmdel = 0;
398         this.undcharmdel = 0;
399         this.mcharmdel = 0;
400         this.unmcharmdel = 0;
401         this.expmultiple = 0;
402         this.drains = 0;
403         this.fight = 0;
404     }
405
406     /**
407      * 属性小于0的处理
408      */
409     public void zeroAbility() {
410         this.strength = this.strength > 0 ? this.strength : 0;
411         /**
412          * 主动,1002
413          */
414         this.initiative = this.initiative > 0 ? this.initiative : 0;
415         /**
416          * 智慧,1003
417          */
418         this.intelligence = this.intelligence > 0 ? this.intelligence : 0;
419         /**
420          * 意志,1004
421          */
422         this.willpower = this.willpower > 0 ? this.willpower : 0;
423         /**
424          * 体魄,1005
425          */
426         this.wounds = this.wounds > 0 ? this.wounds : 0;
427         this.attackSpeed = this.attackSpeed > 0 ? this.attackSpeed : 0;
428         this.dcmin = this.dcmin > 0 ? this.dcmin : 0;
429         this.dcmax = this.dcmax > 0 ? this.dcmax : 0;
430         this.mcmin = this.mcmin > 0 ? this.mcmin : 0;
431         this.mcmax = this.mcmax > 0 ? this.mcmax : 0;
432         this.ac = this.ac > 0 ? this.ac : 0;
433         this.mac = this.mac > 0 ? this.mac : 0;
434         this.duck = this.duck > 0 ? this.duck : 0;
435         this.hit = this.hit > 0 ? this.hit : 0;
436         this.toughness = this.toughness > 0 ? this.toughness : 0;
437         this.critvalue = this.critvalue > 0 ? this.critvalue : 0;
438         this.critValuePer = this.critValuePer > 0 ? this.critValuePer : 0;
439         this.autohp = this.autohp > 0 ? this.autohp : 0;
440         this.auto_battle_hp = this.auto_battle_hp > 0 ? this.auto_battle_hp : 0;
441         this.automp = this.automp > 0 ? this.automp : 0;
442         this.auto_battle_mp = this.auto_battle_mp > 0 ? this.auto_battle_mp : 0;
443         this.hpmax = this.hpmax > 0 ? this.hpmax : 0;
444         this.mpmax = this.mpmax > 0 ? this.mpmax : 0;
445         this.expmax = this.expmax > 0 ? this.expmax : 0;
446         this.speed = this.speed < 0 ? 0 : (this.speed > 8000 ? 8000 : this.speed); // 移动速度介于 0 -8000
447         this.dcharmdel = this.dcharmdel > 0 ? this.dcharmdel : 0;
448         this.undcharmdel = this.undcharmdel > 0 ? this.undcharmdel : 0;
449         this.mcharmdel = this.mcharmdel > 0 ? this.mcharmdel : 0;
450         this.unmcharmdel = this.unmcharmdel > 0 ? this.unmcharmdel : 0;
451         this.expmultiple = this.expmultiple > 0 ? this.expmultiple : 0;
452         this.drains = this.drains > 0 ? this.drains : 0;
453     }
454
455     @Override
456     public String toString() {
457         return "BaseAbility{" + "attackSpeed=" + attackSpeed + ", strength=" + strength + ", initiative=" + initiative + ", intelligence=" + intelligence + ", willpower=" + willpower + ", wounds=" + wounds + ", dcmin=" + dcmin + ", dcmax=" + dcmax + ", mcmin=" + mcmin + ", mcmax=" + mcmax + ", ac=" + ac + ", mac=" + mac + ", duck=" + duck + ", hit=" + hit + ", toughness=" + toughness + ", crit=" + critValuePer + ", critvalue=" + critvalue + ", autohp=" + autohp + ", auto_battle_hp=" + auto_battle_hp + ", automp=" + automp + ", auto_battle_mp=" + auto_battle_mp + ", hpmax=" + hpmax + ", mpmax=" + mpmax + ", expmax=" + expmax + ", speed=" + speed + ", dcharmdel=" + dcharmdel + ", mcharmdel=" + mcharmdel + ", undcharmdel=" + undcharmdel + ", unmcharmdel=" + unmcharmdel + ", drains=" + drains + ", expmultiple=" + expmultiple + ", fight=" + fight + '}';
458     }
459
460 }

这个类是用于服务器程序计算的，

1 package com.game.engine.struct;
2
3 import com.game.engine.struct.PersonAttribute.AttKey;
4 import java.util.concurrent.ConcurrentHashMap;
5 import net.sz.engine.utils.RandomUtils;
6 import org.apache.log4j.Logger;
7
8 /**
9  * 属性
10  * <br>
11  * author 失足程序员<br>
12  * mail 492794628@qq.com<br>
13  * phone 13882122019<br>
14  */
15 public class PersonAttribute extends ConcurrentHashMap<AttKey, Integer> {
16
17     private static final Logger log = Logger.getLogger(PersonAttribute.class);
18
19     private static final long serialVersionUID = -3258690074056212218L;
20     private Long expMax = 0l;
21
22     public enum AttKey {
23
24         /**
25          * 120, "最大开孔数"
26          */
27         EGAP_KONGMAX(120, "最大开孔数"),
28         /**
29          * 121, "当前开孔数"
30          */
31         EGAP_KONG(121, "当前开孔数"),
32         /**
33          * 122, "孔1"
34          */
35         EGAP_KONG_1(122, "孔1"),
36         /**
37          * 123, "孔2"
38          */
39         EGAP_KONG_2(123, "孔2"),
40         /**
41          * 124, "孔3"
42          */
43         EGAP_KONG_3(124, "孔3"),
44         /**
45          * 125, "孔4"
46          */
47         EGAP_KONG_4(125, "孔4"),
48         /**
49          * 126, "孔5"
50          */
51         EGAP_KONG_5(126, "孔5"),
52         /**
53          * 144, "精炼消耗"
54          */
55         REFINE_Star_Cost(144, "精炼消耗"),
56         /**
57          * 力量,1001
58          */
59         Strength(1001, "力量"),
60         /**
61          * 主动,1002
62          */
63         Initiative(1002, "主动"),
64         /**
65          * 智慧,1003
66          */
67         Intelligence(1003, "智慧"),
68         /**
69          * 意志,1004
70          */
71         Willpower(1004, "意志"),
72         /**
73          * 体魄,1005
74          */
75         Wounds(1005, "体魄"),
76         /**
77          * 物理攻击下限,2001
78          */
79         DCmin(2001, "物理攻击下限"),
80         /**
81          * 物理攻击上限,2002
82          */
83         DCmax(2002, "物理攻击上限"),
84         /**
85          * 物理攻击增加,2003
86          */
87         DCcount(2003, "物理攻击增加"),
88         /**
89          * 物理攻击万分比提升,2004
90          */
91         DCper(2004, "物理攻击万分比提升"),
92         /**
93          * 魔法攻击下限,2011
94          */
95         MCmin(2011, "魔法攻击下限"),
96         /**
97          * 魔法攻击上限,2012
98          */
99         MCmax(2012, "魔法攻击上限"),
100         /**
101          * 魔法攻击增加，2013
102          */
103         MCcount(2013, "魔法攻击增加"),
104         /**
105          * 魔法攻击万分比提升,2014
106          */
107         MCper(2014, "魔法攻击万分比提升"),
108         /**
109          * 物理防御上限,2021
110          */
111         AC(2021, "物理防御"),
112         /**
113          * 物防增加,2023
114          */
115         ACCount(2023, "物防增加"),
116         /**
117          * 物理防御万分比提升,2024
118          */
119         ACPer(2024, "物理防御万分比提升"),
120         /**
121          * 魔法防御上限,2031
122          */
123         Mac(2031, "魔法防御"),
124         /**
125          * 魔防增加,2033
126          */
127         MacCount(2033, "魔防增加"),
128         /**
129          * 魔法防御万分比提升,2034
130          */
131         MacPer(2034, "魔法防御万分比提升"),
132         /**
133          * 最大魔法,2041
134          */
135         MpMax(2041, "最大魔法"),
136         /**
137          * 最大魔法万分比提升,2042
138          */
139         MPMaxper(2042, "最大魔法万分比提升"),
140         /**
141          * 当前魔法回复(战斗状态)，2043
142          */
143         MPFightCount(2043, "当前魔法回复(战斗状态)"),
144         /**
145          * 当前魔法回复(非战斗状态)，2044
146          */
147         MPCount(2044, "当前魔法回复(非战斗状态)"),
148         /**
149          * 当前魔法值回复万分比，2045
150          */
151         MPPer(2045, "当前魔法值回复万分比"),
152         /**
153          * 当前魔法值，2046
154          */
155         MP(2047, "当前魔法值"),
156         /**
157          * 自动回复生命，2058
158          */
159         AutoMP(2048, "自动回复魔法值"),
160         /**
161          * 战斗状态自动回复魔法值，2049
162          */
163         AutoBattleMP(2049, "战斗状态自动回复魔法值"),
164         /**
165          * 最大血量,2051
166          */
167         HPMax(2051, "最大血量"),
168         /**
169          * 最大血量万分比提升,2052
170          */
171         HPMaxper(2052, "最大血量万分比提升"),
172         /**
173          * 当前生命回复(战斗状态)，2053
174          */
175         HPFightCount(2053, "当前生命回复(战斗状态)"),
176         /**
177          * 当前生命回复(非战斗状态)，2054
178          */
179         HPCount(2054, "当前生命回复(非战斗状态)"),
180         /**
181          * 当前生命回复万分比，2055
182          */
183         HPPer(2055, "当前生命回复万分比"),
184         /**
185          * 当前生命，2057
186          */
187         HP(2057, "当前生命"),
188         /**
189          * 自动回复生命，2058
190          */
191         AutoHP(2058, "自动回复生命"),
192         /**
193          * 战斗状态自动回复生命，2059
194          */
195         AutoBattleHP(2059, "战斗状态自动回复生命"),
196         /**
197          * 闪避，2061
198          */
199         Dcuk(2061, "闪避"),
200         /**
201          * 韧性,2071
202          */
203         Toughness(2071, "韧性"),
204         /**
205          * 命中准确,2081
206          */
207         Hit(2081, "命中准确"),
208         /**
209          * 暴击,2091
210          */
211         CritValue(2091, "暴击"),
212         /**
213          * 物理伤害减免,2101
214          */
215         DCharmdel(2101, "物理伤害减免"),
216         /**
217          * 魔法减伤,2111
218          */
219         MCharmdel(2111, "魔法减伤"),
220         /**
221          * 物理反伤,2121
222          */
223         UnDCharmdel(2121, "物理反伤"),
224         /**
225          * 魔法反伤,2131
226          */
227         UnMCharmdel(2131, "魔法反伤"),
228         /**
229          * 暴击伤害加成的倍率,2141
230          */
231         CritValuePer(2141, "暴击伤害加成的倍率"),
232         /**
233          * 2151, "升级所需经验值"
234          */
235         //        ExpMax(2151, "升级所需经验值"),
236         /**
237          * 当前经验值,2152
238          */
239         Exp(2152, "获得经验值"),
240         /**
241          * 经验加成(万分比),2153
242          */
243         ExpPer(2153, "经验加成(万分比)"),
244         /**
245          * 经验加成(固定点数),2154
246          */
247         ExpCount(2154, "经验加成(固定点数)"),
248         /**
249          * 移动速度,2161
250          */
251         Speed(2161, "移动速度"),
252         /**
253          * 移动速度加成(万分比),2162
254          */
255         SpeedPer(2162, "移动速度加成(万分比)"),
256         /**
257          * 移动速度加成（点数）,2163
258          */
259         SpeedCount(2163, "移动速度加成（点数）"),
260         /**
261          * 攻击速度
262          */
263         AttackSpeed(2171, "攻击速度"),
264         /**
265          * 3001, "反伤盾所用的根据攻击力计算，根据不同的职业用不同的攻击力"
266          */
267         AttackPower(3001, "反伤盾所用的根据攻击力计算，根据不同的职业用不同的攻击力"),
268         /**
269          * 9993, "赠送道具"
270          */
271         Goods(9993, "赠送道具"),
272         /**
273          * 9994,魔法和生命值都加
274          */
275         HPMP(9994, "魔法和生命值都加"),
276         /**
277          * 9995,魔法和生命值都加，百分比
278          */
279         HPMPPer(9995, "魔法和生命值都加，百分比"),
280         /**
281          * 9996, vip经验
282          */
283         VIPExp(9996, "vip经验"),
284         /**
285          * 9997, "buff效果"
286          */
287         BuffState(9997, "buff效果"),
288         /**
289          * 9998, "脚本执行"
290          */
291         SCRIPT(9998, "脚本执行"),
292         /**
293          * 战斗力,9999
294          */
295         Fight(9999, "战斗力");
296
297         private int key;
298         private String value;
299
300         private AttKey(int key, String value) {
301             this.key = key;
302             this.value = value;
303         }
304
305         /**
306          * 根据索引获取key
307          *
308          * @param key
309          * @return
310          */
311         public static AttKey parse(int key) {
312             AttKey[] values = AttKey.values();
313             for (AttKey value : values) {
314                 if (value.getKey() == key) {
315                     return value;
316                 }
317             }
318             return null;
319         }
320
321         /**
322          *
323          * @param key
324          * @return
325          */
326         public static AttKey parse(String key) {
327             return Enum.valueOf(AttKey.class, key);
328         }
329
330         /**
331          * 键值
332          *
333          * @return
334          */
335         public int getKey() {
336             return key;
337         }
338
339         /**
340          * 描述字符
341          *
342          * @return
343          */
344         public String getValue() {
345             return value;
346         }
347
348     }
349
350     @Override
351     public Integer put(AttKey key, Integer value) {
352         return super.put(key, value); //To change body of generated methods, choose Tools | Templates.
353     }
354
355     /**
356      * 重写，如果没有建会返回0而不是null
357      *
358      * @param key
359      * @return
360      */
361     @Override
362     public Integer get(Object key) {
363         Integer value = super.get(key);
364         if (value != null) {
365             return value;
366         }
367         return 0;
368     }
369
370     /**
371      * 仅限buff计算调用
372      * <br>
373      * 慎重调用
374      *
375      * @param job 职业编号
376      * @param baseAbility
377      * @param attKey
378      */
379     @Deprecated
380     public static int getBuffAbility(int job, BaseAbility baseAbility, AttKey attKey) {
381         int value = 0;
382         switch (attKey) {
383             case AttackPower: //
384             {
385                 switch (job) {
386                     //物理系列
387                     case 1://骑士
388                     case 3://射手
389                     case 5://屠杀者
390                         value = RandomUtils.random(baseAbility.getDcmin(), baseAbility.getDcmax());
391                         break;
392                     //魔法系列
393                     case 2://法师
394                     case 4://刺客
395                         value = RandomUtils.random(baseAbility.getMcmin(), baseAbility.getMcmax());
396                         break;
397                 }
398             }
399             break;
400             case AC:
401             case ACCount:
402                 value = baseAbility.getAc();
403                 break;
404             case AttackSpeed:
405                 value = baseAbility.getAttackSpeed();
406                 break;
407             case AutoBattleHP:
408                 value = baseAbility.getAuto_battle_hp();
409                 break;
410             case AutoBattleMP:
411                 value = baseAbility.getAuto_battle_mp();
412                 break;
413             case AutoHP:
414                 value = baseAbility.getAutohp();
415                 break;
416             case AutoMP:
417                 value = baseAbility.getAutomp();
418                 break;
419             case CritValue:
420                 value = baseAbility.getCritvalue();
421                 break;
422             case CritValuePer:
423                 value = baseAbility.getCritValuePer();
424                 break;
425             case DCharmdel:
426                 value = baseAbility.getDcharmdel();
427                 break;
428             case DCmin:
429             case DCmax:
430                 value = RandomUtils.random(baseAbility.getDcmin(), baseAbility.getDcmax());
431                 break;
432             case Dcuk:
433                 value = baseAbility.getDuck();
434                 break;
435             case Fight:
436                 value = baseAbility.getFight();
437                 break;
438             case HPMax:
439                 value = baseAbility.getHpmax();
440                 break;
441             case Hit:
442                 value = baseAbility.getHit();
443                 break;
444             case Initiative:
445                 value = baseAbility.getInitiative();
446                 break;
447             case Intelligence:
448                 value = baseAbility.getIntelligence();
449                 break;
450             case MCharmdel:
451                 value = baseAbility.getMcharmdel();
452                 break;
453             case MCmax:
454             case MCmin:
455                 value = RandomUtils.random(baseAbility.getMcmin(), baseAbility.getMcmax());
456                 break;
457             case Mac:
458             case MacCount:
459                 value = baseAbility.getMac();
460                 break;
461             case MpMax:
462                 value = baseAbility.getMpmax();
463                 break;
464             case Strength:
465                 value = baseAbility.getStrength();
466                 break;
467             case Speed:
468             case SpeedCount:
469                 value = baseAbility.getSpeed();
470                 break;
471             case Toughness:
472                 value = baseAbility.getToughness();
473                 break;
474             case UnDCharmdel:
475                 value = baseAbility.getUndcharmdel();
476                 break;
477             case UnMCharmdel:
478                 value = baseAbility.getUnmcharmdel();
479                 break;
480             case Willpower:
481                 value = baseAbility.getWillpower();
482                 break;
483             case Wounds:
484                 value = baseAbility.getWounds();
485                 break;
486         }
487         return value;
488     }
489
490     /**
491      * 构建属性
492      * <br>
493      * 慎重调用
494      *
495      * @param baseAbility
496      */
497     @Deprecated
498     public void buildBaseAbility(BaseAbility baseAbility) {
499         baseAbility.setExpmax(baseAbility.getExpmax() + this.getExpMax());
500         for (Entry<AttKey, Integer> entry : this.entrySet()) {
501             AttKey key = entry.getKey();
502             Integer value = entry.getValue();
503             switch (key) {
504                 case AC:
505                 case ACCount:
506                     baseAbility.setAc(baseAbility.getAc() + value);
507                     break;
508                 case AttackSpeed:
509                     baseAbility.setAttackSpeed(baseAbility.getAttackSpeed() + value);
510                     break;
511                 case AutoBattleHP:
512                     baseAbility.setAuto_battle_hp(baseAbility.getAuto_battle_hp() + value);
513                     break;
514                 case AutoBattleMP:
515                     baseAbility.setAuto_battle_mp(baseAbility.getAuto_battle_mp() + value);
516                     break;
517                 case AutoHP:
518                     baseAbility.setAutohp(baseAbility.getAutohp() + value);
519                     break;
520                 case AutoMP:
521                     baseAbility.setAutomp(baseAbility.getAutomp() + value);
522                     break;
523                 case CritValue:
524                     baseAbility.setCritvalue(baseAbility.getCritvalue() + value);
525                     break;
526                 case CritValuePer:
527                     baseAbility.setCritValuePer(baseAbility.getCritValuePer() + value);
528                     break;
529                 case DCcount:
530                     baseAbility.setDcmin(baseAbility.getDcmin() + value);
531                     baseAbility.setDcmax(baseAbility.getDcmax() + value);
532                     break;
533                 case DCharmdel:
534                     baseAbility.setDcharmdel(baseAbility.getDcharmdel() + value);
535                     break;
536                 case DCmax:
537                     baseAbility.setDcmax(baseAbility.getDcmax() + value);
538                     break;
539                 case DCmin:
540                     baseAbility.setDcmin(baseAbility.getDcmin() + value);
541                     break;
542                 case Dcuk:
543                     baseAbility.setDuck(baseAbility.getDuck() + value);
544                     break;
545                 case Fight:
546                     baseAbility.setFight(baseAbility.getFight() + value);
547                     break;
548                 case HPMax:
549                     baseAbility.setHpmax(baseAbility.getHpmax() + value);
550                     break;
551                 case Hit:
552                     baseAbility.setHit(baseAbility.getHit() + value);
553                     break;
554                 case Initiative:
555                     baseAbility.setInitiative(baseAbility.getInitiative() + value);
556                     break;
557                 case Intelligence:
558                     baseAbility.setIntelligence(baseAbility.getIntelligence() + value);
559                     break;
560                 case MCcount:
561                     baseAbility.setMcmin(baseAbility.getMcmin() + value);
562                     baseAbility.setMcmax(baseAbility.getMcmax() + value);
563                     break;
564                 case MCharmdel:
565                     baseAbility.setMcharmdel(baseAbility.getMcharmdel() + value);
566                     break;
567                 case MCmax:
568                     baseAbility.setMcmax(baseAbility.getMcmax() + value);
569                     break;
570                 case MCmin:
571                     baseAbility.setMcmin(baseAbility.getMcmin() + value);
572                     break;
573                 case Mac:
574                 case MacCount:
575                     baseAbility.setMac(baseAbility.getMac() + value);
576                     break;
577                 case MpMax:
578                     baseAbility.setMpmax(baseAbility.getMpmax() + value);
579                     break;
580                 case Strength:
581                     baseAbility.setStrength(baseAbility.getStrength() + value);
582                     break;
583                 case Speed:
584                 case SpeedCount:
585                     baseAbility.setSpeed(baseAbility.getSpeed() + value);
586                     break;
587                 case Toughness:
588                     baseAbility.setToughness(baseAbility.getToughness() + value);
589                     break;
590                 case UnDCharmdel:
591                     baseAbility.setUndcharmdel(baseAbility.getUndcharmdel() + value);
592                     break;
593                 case UnMCharmdel:
594                     baseAbility.setUnmcharmdel(baseAbility.getUnmcharmdel() + value);
595                     break;
596                 case Willpower:
597                     baseAbility.setWillpower(baseAbility.getWillpower() + value);
598                     break;
599                 case Wounds:
600                     baseAbility.setWounds(baseAbility.getWounds() + value);
601                     break;
602             }
603         }
604     }
605
606     /**
607      * 构建属性，构建属性集合中比例属性加成，万分比格式
608      * <br>
609      * 慎重调用
610      *
611      * @param baseAbility
612      */
613     @Deprecated
614     public void buildBaseAbilityPer(BaseAbility baseAbility) {
615         for (Entry<AttKey, Integer> entry : this.entrySet()) {
616             AttKey key = entry.getKey();
617             Integer value = entry.getValue();
618             switch (key) {
619                 case ACPer:
620                     baseAbility.setAc(baseAbility.getAc() + (int) (baseAbility.getAc() * (value / 10000D)));
621                     break;
622                 case DCper:
623                     baseAbility.setDcmin(baseAbility.getDcmin() + (int) (baseAbility.getDcmin() * (value / 10000D)));
624                     baseAbility.setDcmax(baseAbility.getDcmax() + (int) (baseAbility.getDcmax() * (value / 10000D)));
625                     break;
626                 case HPMaxper:
627                     baseAbility.setHpmax(baseAbility.getHpmax() + (int) (baseAbility.getHpmax() * (value / 10000D)));
628                     break;
629                 case MCper:
630                     baseAbility.setMcmin(baseAbility.getMcmin() + (int) (baseAbility.getMcmin() * (value / 10000D)));
631                     baseAbility.setMcmax(baseAbility.getMcmax() + (int) (baseAbility.getMcmax() * (value / 10000D)));
632                     break;
633                 case MacPer:
634                     baseAbility.setMac(baseAbility.getMac() + (int) (baseAbility.getMac() * (value / 10000D)));
635                     break;
636                 case SpeedPer:
637                     baseAbility.setSpeed(baseAbility.getSpeed() + (int) (baseAbility.getSpeed() * (value / 10000D)));
638                     break;
639             }
640         }
641     }
642
643     @Override
644     public String toString() {
645         for (Entry<AttKey, Integer> entry : this.entrySet()) {
646             AttKey key = entry.getKey();
647             Integer value = entry.getValue();
648         }
649         return "PlayerAttribute{" + '}';
650     }
651
652     /**
653      * 所有属性清零
654      */
655     public void clearZoer() {
656         for (Entry<AttKey, Integer> entry : this.entrySet()) {
657             AttKey key = entry.getKey();
658             Integer value = entry.getValue();
659             this.put(key, 0);
660         }
661     }
662
663     /**
664      * 累计
665      *
666      * @param playerAttribute
667      */
668     public void add(PersonAttribute playerAttribute) {
669         for (Entry<AttKey, Integer> entry : playerAttribute.entrySet()) {
670             AttKey key = entry.getKey();
671             Integer value = entry.getValue();
672             Integer get = this.get(key);
673             value += get;
674             this.put(key, value);
675         }
676         this.expMax += playerAttribute.expMax;
677     }
678
679     /**
680      *
681      * @param key
682      * @param value
683      */
684     public void add(int key, Integer value) {
685         add(AttKey.parse(key), value);
686     }
687
688     /**
689      *
690      * @param key
691      * @param value
692      */
693     public void add(AttKey key, Integer value) {
694         if (key != null) {
695             Integer get = this.get(key);
696             value += get;
697             this.put(key, value);
698         }
699     }
700
701     public Long getExpMax() {
702         return expMax;
703     }
704
705     public void setExpMax(Long expMax) {
706         this.expMax = expMax;
707     }
708
709     public static void main(String[] args) {
710         String toString = PersonAttribute.AttKey.Initiative.toString();
711         System.out.println(toString);
712         System.out.println(PersonAttribute.AttKey.parse(toString).getValue());
713     }
714 }

这个类用于策划配置方式解析的，

策划在配置属性的时候只需要配置出来，就能通用解析。

1     // <editor-fold defaultstate="collapsed" desc="返回属性键值对 public static void getAttribute(PersonAttribute attribute, String attString)">
2     /**
3      * 返回属性键值对
4      *
5      * @param attribute
6      * @param attString 配置的属性
7      */
8     public static void getAttribute(PersonAttribute attribute, String attString) {
9         if (StringUtil.isNullOrEmpty(attString)) {
10             return;
11         }
12         String[] atts = attString.split(DOUHAO_REG);
13         for (String att : atts) {
14             String[] split = att.split("=");
15             Integer integer = Integer.parseInt(split[0]);
16             Integer integer1 = Integer.parseInt(split[1]);
17             attribute.add(integer, integer1);
18         }
19     }
20     // </editor-fold>
21
22     public static void main(String[] args) {
23         String str = "34052=792,34050=1291,34051=3";
24         PersonAttribute personAttribute = new PersonAttribute();
25         getAttribute(personAttribute, str);
26     }

在精灵对象身上只需要挂载

1     // 属性
2     //最终计算属性
3     protected BaseAbility finalAbility = new BaseAbility();
4
5     //-------------------属性部分-------------------------//
6     private /*transient这样可能会导致离线竞技场角色数据不正确*/ HashMap<Integer, PersonAttribute> attributes = new HashMap<>();
7     //其他属性
8     protected PersonAttribute otherAttribute = new PersonAttribute();

就能分门别类的计算全部属性

1     @Override
2     public void computeAttribute(Player player, boolean updateTopListFightPower) {
3         synchronized (player.abilityLock) {
4             player.abilityLock.update();
5
6             PersonAttribute finalAbility = new PersonAttribute();
7
8             HashMap<Integer, PersonAttribute> attributes = player.getAttributes();
9             //先把非buff的属性计算完成
10             for (Map.Entry<Integer, PersonAttribute> entry : attributes.entrySet()) {
11                 Integer key = entry.getKey();
12                 if (key != PersonAttributeType.BUFF) {
13                     PersonAttribute playerAttribute = entry.getValue();
14                     if (playerAttribute != null) {
15                         finalAbility.add(playerAttribute);
16                     }
17                 }
18             }
19             player.getFinalAbility().clearZero();
20             //构建基础属性
21             finalAbility.buildBaseAbility(player.getFinalAbility());
22             finalAbility.buildBaseAbilityPer(player.getFinalAbility());
23
24             //清零后计算buff
25             finalAbility.clear();
26
27             //再计算buff的属性计算完成
28             for (Map.Entry<Integer, PersonAttribute> entry : attributes.entrySet()) {
29                 Integer key = entry.getKey();
30                 if (key == PersonAttributeType.BUFF) {
31                     PersonAttribute playerAttribute = entry.getValue();
32                     if (playerAttribute != null) {
33                         finalAbility.add(playerAttribute);
34                     }
35                 }
36             }
37             //构建基础属性
38             //先计算buff加成
39             finalAbility.buildBaseAbilityPer(player.getFinalAbility());
40             //在计算buff基础点数
41             finalAbility.buildBaseAbility(player.getFinalAbility());
42             //设置经验比例加成
43             player.setExpMultiple(1 + finalAbility.get(PersonAttribute.AttKey.ExpPer)); // 特殊处理经验BUFF经验BUFF
44             player.getFinalAbility().zeroAbility();
45             log.error("当前速度：" + player.getFinalAbility().getSpeed());
46             {
47                 //属性，加成
48                 //物理攻击加成
49                 player.getFinalAbility().setDcmin(player.getFinalAbility().getDcmin() + player.getFinalAbility().getStrength());
50                 player.getFinalAbility().setDcmax(player.getFinalAbility().getDcmax() + player.getFinalAbility().getStrength());
51                 //物理防御
52                 player.getFinalAbility().setAc(player.getFinalAbility().getAc() + player.getFinalAbility().getStrength());
53                 //生命上限
54                 player.getFinalAbility().setHpmax(player.getFinalAbility().getHpmax() + player.getFinalAbility().getWounds() * 8);
55                 //魔法攻击
56                 player.getFinalAbility().setMcmin(player.getFinalAbility().getMcmin() + player.getFinalAbility().getIntelligence());
57                 player.getFinalAbility().setMcmax(player.getFinalAbility().getMcmax() + player.getFinalAbility().getIntelligence());
58                 //魔法防御
59                 player.getFinalAbility().setMac(player.getFinalAbility().getMac() + player.getFinalAbility().getIntelligence());
60                 //魔法值上限
61                 player.getFinalAbility().setMpmax(player.getFinalAbility().getMpmax() + player.getFinalAbility().getIntelligence() * 6);
62                 //闪避
63                 player.getFinalAbility().setDuck(player.getFinalAbility().getDuck() + player.getFinalAbility().getInitiative());
64                 //韧性
65                 player.getFinalAbility().setToughness(player.getFinalAbility().getToughness() + (int) (player.getFinalAbility().getInitiative() * 0.5));
66                 //命中
67                 player.getFinalAbility().setHit(player.getFinalAbility().getHit() + (int) (player.getFinalAbility().getWillpower() * 0.5));
68                 //暴击
69                 player.getFinalAbility().setCritValuePer(player.getFinalAbility().getCritValuePer() + (int) (player.getFinalAbility().getWillpower()));
70
71             }
72
73             if (updateTopListFightPower && !player.isArenaRobot() && player.getLevel() >= TopListManager.SYNC_PLAYER_LEVEL) { // 如BUFF等改变玩家属性,将不触发排行榜
74 //                log.error("玩家战斗力改变，触发战力排行榜");
75                 TopListManager.getInstance().updateAllTopData(player, null, TopListManager.TOP_POWER);
76             }
77         }
78     }

只是我们游戏目前属性计算方式；

没有特别的说明，也没有多少描述，简单的贴出代码和一些思路；