我们大部分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 [email protected]<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 [email protected]<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 }
只是我们游戏目前属性计算方式；
没有特别的说明，也没有多少描述，简单的贴出代码和一些思路；
时间： 2024-10-27 21:34:51