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

我们大部分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     }

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

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

 

posted on 2016-08-26 16:46  無心道（失足程序员）  阅读(916)  评论(7)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 無心道（失足程序员）
Powered by .NET 8.0 on Kubernetes