From 22bb99e929439653669b8b2e14325dcc865c7fe3 Mon Sep 17 00:00:00 2001
From: hxp <ale99527@vip.qq.com>
Date: 星期五, 17 十月 2025 16:05:08 +0800
Subject: [PATCH] 66 【公会】基础主体-服务端（快速加入公会失败提示）
---
ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Attack/BattleObj.py | 882 +++++++++++++++++++++++++++++++++++++++++++++++-----------
1 files changed, 714 insertions(+), 168 deletions(-)
diff --git a/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Attack/BattleObj.py b/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Attack/BattleObj.py
index a26c3d8..5437571 100644
--- a/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Attack/BattleObj.py
+++ b/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Attack/BattleObj.py
@@ -24,7 +24,206 @@
import ShareDefine
import ChConfig
import ObjPool
+import TurnPassive
+import TurnBuff
+class PassiveEffManager():
+ ## 被动效果管理器
+
+ def __init__(self, batObj):
+ self._batObj = batObj
+ # 被影响的技能ID: 0为所有技能
+ self._AffectSkillDict = {} # 被动技能 {(触发方式, 有效来源):{技能ID:[effID, ...], ...}, ...}
+ self._AffectBuffDict = {} # 被动buff {(触发方式, 有效来源):{buffID:[effID, ...], ...}, ...}
+ return
+
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ self._batObj = None
+ return
+
+ def GetPassiveEffByTrigger(self, triggerWay, connSkill=None, connSkillTypeID=0, connBuff=None):
+ '''获取可触发的效果列表，技能跟buff根据触发优先级按顺序触发，优先级越高越先执行，相同时技能优先
+ 优先级之后有需要再扩展
+ @return: [["skill/buff", skillID/buffID, effIDList], ...]
+ '''
+ effList = []
+
+ if not connSkillTypeID:
+ if connSkill:
+ connSkillTypeID = connSkill.GetSkillTypeID()
+ elif connBuff:
+ skillData = connBuff.GetSkillData()
+ connSkillTypeID = skillData.GetSkillTypeID()
+
+ # SkillData 对象暂时没有 GetObjID
+ if connSkill and hasattr(connSkill, "GetObjID") and self._batObj.GetID() == connSkill.GetObjID():
+ skillID = connSkill.GetSkillID()
+ skillManager = self._batObj.GetSkillManager()
+ # 非对象身上的技能，读取本技能被动触发的效果，一般是主技能拆分的子技能
+ if not skillManager.FindSkillByID(skillID):
+ effIDList = []
+ for index in xrange(connSkill.GetEffectCount()):
+ effect = connSkill.GetEffect(index)
+ effectID = effect.GetEffectID()
+ if effectID == 0:
+ continue
+ tWay = effect.GetTriggerWay()
+ tSrc = effect.GetTriggerSrc()
+ if not tWay:
+ continue
+ if tWay in ChConfig.TriggerWayNoLoadList:
+ continue
+ if tSrc != ChConfig.TriggerSrc_SkillSelf:
+ # 仅添加本技能的
+ continue
+ if tWay == ChConfig.TriggerWay_CalcEffValue:
+ tWay = "%s_%s" % (tWay, effectID)
+ if tWay != triggerWay:
+ continue
+ effIDList.append(effectID)
+ if effIDList:
+ effList.append(["skill", skillID, effIDList])
+
+ # 优先取关联技能的
+ if connSkillTypeID and connSkillTypeID not in [ChConfig.TriggerSrc_Skill, ChConfig.TriggerSrc_Buff, ChConfig.TriggerSrc_SkillSelf, ChConfig.TriggerSrc_BuffSelf]:
+ # 技能
+ key = (triggerWay, connSkillTypeID)
+ if key in self._AffectSkillDict:
+ effDict = self._AffectSkillDict[key]
+ for skillID, effIDList in effDict.items():
+ effList.append(["skill", skillID, effIDList])
+
+ # buff
+ key = (triggerWay, connSkillTypeID)
+ if key in self._AffectBuffDict:
+ effDict = self._AffectBuffDict[key]
+ for buffID, effIDList in effDict.items():
+ effList.append(["buff", buffID, effIDList])
+
+ # 所有技能有效的
+ key = (triggerWay, ChConfig.TriggerSrc_Skill)
+ effDict = self._AffectSkillDict.get(key, {})
+ for skillID, effIDList in effDict.items():
+ effList.append(["skill", skillID, effIDList])
+
+ # 所有buff有效的
+ key = (triggerWay, ChConfig.TriggerSrc_Buff)
+ effDict = self._AffectBuffDict.get(key, {})
+ for buffID, effIDList in effDict.items():
+ effList.append(["buff", buffID, effIDList])
+
+ return effList
+
+ def RefreshSkillPassiveEffect(self):
+ self._AffectSkillDict = {}
+
+ skillManager = self._batObj.GetSkillManager()
+ for index in range(0, skillManager.GetSkillCount()):
+ curSkill = skillManager.GetSkillByIndex(index)
+ if not curSkill:
+ continue
+ for index in xrange(curSkill.GetEffectCount()):
+ curEffect = curSkill.GetEffect(index)
+ effectID = curEffect.GetEffectID()
+ if effectID == 0:
+ continue
+ self.AddSkillPassiveEffect(curSkill, curEffect)
+
+ return self._AffectSkillDict
+
+ def AddSkillPassiveEffect(self, curSkill, effect):
+ ## 添加技能被动效果
+ triggerWay = effect.GetTriggerWay()
+ triggerSrc = effect.GetTriggerSrc()
+ if not triggerWay:
+ return
+ if triggerWay in ChConfig.TriggerWayNoLoadList:
+ return
+ if triggerSrc in [ChConfig.TriggerSrc_Buff, ChConfig.TriggerSrc_BuffSelf]:
+ # buff有效的不加进来
+ return
+
+ skillID = curSkill.GetSkillID()
+ effectID = effect.GetEffectID()
+
+ if triggerWay == ChConfig.TriggerWay_CalcEffValue:
+ triggerWay = "%s_%s" % (triggerWay, effectID)
+
+ if triggerSrc == ChConfig.TriggerSrc_SkillSelf:
+ triggerSrc = curSkill.GetSkillTypeID()
+
+ key = (triggerWay, triggerSrc)
+ if key not in self._AffectSkillDict:
+ self._AffectSkillDict[key] = {}
+ effDict = self._AffectSkillDict[key]
+ if skillID not in effDict:
+ effDict[skillID] = []
+ effDict[skillID].append(effectID)
+ return
+
+ def RefreshBuffPassiveEffect(self):
+ self._AffectBuffDict = {}
+ buffMgr = self._batObj.GetBuffManager()
+ for index in range(buffMgr.GetBuffCount()):
+ buff = buffMgr.GetBuffByIndex(index)
+ if not buff:
+ continue
+ skillData = buff.GetSkillData()
+ for index in xrange(skillData.GetEffectCount()):
+ curEffect = skillData.GetEffect(index)
+ effectID = curEffect.GetEffectID()
+ if effectID == 0:
+ continue
+ self.AddBuffPassiveEffect(buff, skillData, curEffect)
+
+ return self._AffectBuffDict
+
+ def AddBuffPassiveEffect(self, buff, skillData, effect):
+ '''添加Buff被动效果
+ 同个buff的技能ID如果叠加规则是独立的，那么可能同时存在多个相同技能效果的buff
+ 如果触发效果，就要触发多次，所以buff的效果以buffID为key
+ '''
+ triggerWay = effect.GetTriggerWay()
+ triggerSrc = effect.GetTriggerSrc()
+ if not triggerWay:
+ return
+ if triggerWay in ChConfig.TriggerWayNoLoadList:
+ return
+ if triggerSrc in [ChConfig.TriggerSrc_Skill, ChConfig.TriggerSrc_SkillSelf]:
+ # 技能有效的不加进来
+ return
+
+ buffID = buff.GetBuffID()
+ effectID = effect.GetEffectID()
+
+ if triggerWay == ChConfig.TriggerWay_CalcEffValue:
+ triggerWay = "%s_%s" % (triggerWay, effectID)
+
+ if triggerSrc == ChConfig.TriggerSrc_BuffSelf:
+ triggerSrc = skillData.GetSkillTypeID()
+
+ key = (triggerWay, triggerSrc)
+ if key not in self._AffectBuffDict:
+ self._AffectBuffDict[key] = {}
+ effDict = self._AffectBuffDict[key]
+ if buffID not in effDict:
+ effDict[buffID] = []
+ effIDList = effDict[buffID]
+ if effectID not in effIDList:
+ effIDList.append(effectID)
+ return
+
+ def DelBuffPassiveEffect(self, buffID):
+ ## 删除Buff被动效果
+ for key, effDict in self._AffectBuffDict.items():
+ if buffID not in effDict:
+ continue
+ effDict.pop(buffID)
+ if not effDict:
+ self._AffectBuffDict.pop(key)
+ return
+
class HurtObj():
## 伤血统计
@@ -32,10 +231,15 @@
self.Clear()
return
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ return
+
def Clear(self):
self._objID = 0
self._hurtTypes = 0 # 本次伤血类型，如闪避、暴击、格挡等，通过二进制或运算得到最终值，支持多种同时出现，如暴击的同时被格挡
- self._hurtHP = 0 # 伤血值
+ self._hurtHP = 0 # 公式最终计算的伤害值，一般用于飘血
+ self._realHurtHP = 0 # 真实伤血值，被承伤盾抵扣后的可伤血的值
self._lostHP = 0 # 实际掉血值
self._curHP = 0 # 更新血量
self._suckHP = 0 # 吸血量
@@ -52,9 +256,11 @@
return
def HaveHurtType(self, hurtType):
## 判断是否存在某种伤血类型
- return self._hurtTypes&pow(2, hurtType)
+ return self._hurtTypes & pow(2, hurtType)
def GetHurtHP(self): return self._hurtHP
def SetHurtHP(self, hurtHP): self._hurtHP = hurtHP
+ def GetRealHurtHP(self): return self._realHurtHP
+ def SetRealHurtHP(self, realHurtHP): self._realHurtHP = realHurtHP
def GetLostHP(self): return self._lostHP
def SetLostHP(self, lostHP): self._lostHP = lostHP
def GetCurHP(self): return self._curHP
@@ -64,15 +270,100 @@
def GetBounceHP(self): return self._bounceHP
def SetBounceHP(self, bounceHP): self._bounceHP = bounceHP
+class SkillEffect():
+
+ def __init__(self, effID, values, triggerWay=0, triggerSrc=0):
+ self._effID = effID
+ self._values = values
+ self._triggerWay = triggerWay
+ self._triggerSrc = triggerSrc
+ #self._triggerParams = triggerParams if triggerParams else []
+ return
+
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ return
+
+ def GetEffectID(self): return self._effID
+ def GetEffectValue(self, index): return self._values[index] if len(self._values) > index else 0
+ def GetEffectValueCount(self): return len(self._values)
+ def GetEffectValues(self): return self._values # 直接返回整个效果values
+ def GetTriggerWay(self): return self._triggerWay
+ def GetTriggerSrc(self): return self._triggerSrc
+ #def GetTriggerParams(self, index): return self._triggerParams[index] if len(self._triggerParams) > index else 0
+
+class SklllData():
+
+ def __init__(self, ipyData):
+ self._ipyData = ipyData
+ self._effList = [] # [Effect, ...]
+ self._effDict = {} # {(effID, triggerWay):Effect, ...} ，确保唯一，同个技能可能配置相同的效果ID
+ for num in range(1, 1 + 3):
+ effID = getattr(ipyData, "GetEffectID%s" % num)()
+ values = getattr(ipyData, "GetEffectValues%s" % num)()
+ triggerWay = getattr(ipyData, "GetTriggerWay%s" % num)()
+ triggerSrc = getattr(ipyData, "GetTriggerSrc%s" % num)()
+ #triggerParams = getattr(ipyData, "GetTriggerParams%s" % num)()
+ effect = ObjPool.GetPoolMgr().acquire(SkillEffect, effID, values, triggerWay, triggerSrc)
+ self._effList.append(effect)
+ self._effDict[(effID, triggerWay)] = effect
+ return
+
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ return
+
+ def GetIpyData(self): return self._ipyData
+ def GetSkillID(self): return self._ipyData.GetSkillID()
+ def GetSkillTypeID(self): return self._ipyData.GetSkillTypeID()
+ def GetSkillLV(self): return self._ipyData.GetSkillLV()
+ def GetSkillMaxLV(self): return self._ipyData.GetSkillMaxLV()
+ def GetSkillName(self): return self._ipyData.GetSkillName()
+ def GetFuncType(self): return self._ipyData.GetFuncType()
+ def GetSkillType(self): return self._ipyData.GetSkillType()
+ def GetHurtType(self): return self._ipyData.GetHurtType()
+ def GetAtkType(self): return self._ipyData.GetAtkType()
+ def GetTagAim(self): return self._ipyData.GetTagAim() # 瞄准位置
+ def GetTagFriendly(self): return self._ipyData.GetTagFriendly() # 敌我目标
+ def GetTagSelf(self): return self._ipyData.GetTagSelf() # 是否含自己
+ def GetTagAffect(self): return self._ipyData.GetTagAffect() # 目标细分
+ def GetTagCount(self): return self._ipyData.GetTagCount() # 目标个数
+ def GetCalcType(self): return self._ipyData.GetCalcType()
+ def GetSkillPer(self): return self._ipyData.GetSkillPer()
+ def GetSkillValue(self): return self._ipyData.GetSkillValue()
+ def GetHurtAtkPerMax(self): return self._ipyData.GetHurtAtkPerMax()
+ def GetHappenRate(self): return self._ipyData.GetHappenRate() # 触发概率
+ def GetEffect(self, index): return self._effList[index] if len(self._effList) > index else 0
+ def GetEffectCount(self): return len(self._effList)
+ def GetEffectByID(self, effID, triggerWay=0): return self._effDict.get((effID, triggerWay), None)
+ def GetConnSkill(self): return self._ipyData.GetConnSkill()
+ def GetCoolDownTime(self): return self._ipyData.GetCoolDownTime()
+ def GetBuffStateLimit(self): return self._ipyData.GetBuffStateLimit()
+ def GetCurBuffState(self): return self._ipyData.GetCurBuffState()
+ def GetLastTime(self): return self._ipyData.GetLastTime() # 持续时间
+ def GetLayerCnt(self): return self._ipyData.GetLayerCnt()
+ def GetLayerMax(self): return self._ipyData.GetLayerMax()
+ def GetBuffRepeat(self): return self._ipyData.GetBuffRepeat() # Buff叠加规则
+ def GetDispersedLimit(self): return self._ipyData.GetDispersedLimit() # 驱散限制
+ def GetFightPower(self): return self._ipyData.GetFightPower()
+ def GetSkillMotionName(self): return self._ipyData.GetSkillMotionName()
+
class PyBuff():
- def __init__(self, skillData):
- self._skillData = skillData
+ def __init__(self, ipyData):
+ self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)
self._buffID = 0
self._ownerID = 0
self._layer = 0
+ self._calcTime = 0
self._remainTime = 0
- self._valueList = []
+ self._value1 = 0 # 值需要通知前端，开发时注意20亿问题
+ self._value2 = 0
+ self._value3 = 0
+ return
+
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
return
def GetSkillData(self): return self._skillData
@@ -83,21 +374,41 @@
def SetOwnerID(self, ownerID): self._ownerID = ownerID
def GetLayer(self): return self._layer
def SetLayer(self, layer): self._layer = layer
+ def GetCalcTime(self): return self._calcTime
+ def SetCalcTime(self, calcTime): self._calcTime = calcTime
def GetRemainTime(self): return self._remainTime
def SetRemainTime(self, remainTime): self._remainTime = remainTime
- def SetValueList(self, valueList): self._valueList = valueList
- def GetValue(self, index):
- return self._valueList[index] if len(self._valueList) > index else 0
-
+ def SetBuffValueList(self, valueList):
+ for index, value in enumerate(valueList):
+ if index == 0:
+ self.SetValue1(value)
+ elif index == 1:
+ self.SetValue2(value)
+ elif index == 2:
+ self.SetValue3(value)
+ def GetValue1(self): return self._value1
+ def SetValue1(self, value): self._value1 = value
+ def GetValue2(self): return self._value2
+ def SetValue2(self, value): self._value2 = value
+ def GetValue3(self): return self._value3
+ def SetValue3(self, value): self._value3 = value
+
class BuffManager():
## 战斗对象buff管理器
- def __init__(self):
+ def __init__(self, batObj):
+ self._batObj = batObj
self._buffList = [] # [PyBuff, ...]
self._buffIDDict = {} # {buffID:PyBuff, ...}
self._skillTypeIDBuffIDs = {} # 技能TypeID对应的buff {skillTypeID:[buffID, ...], ...}
+ self._buffStateDict = {} # buff影响的状态 {state:[buffID, ...], ...}
self._buffID = 0 # 该对象的唯一buffID，递增，不同对象buffID可重复，buffID非skillID，不同buffID的skillID可能一样
# 该项目设定同一个对象可能同时存在多个相同skillID的buff，独立算CD
+ return
+
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ self._batObj = None
return
def ClearBuff(self):
@@ -107,55 +418,71 @@
self._buffList = []
self._buffIDDict = {}
self._skillTypeIDBuffIDs = {}
+ self._buffStateDict = {}
self._buffID = 0
return
def GetBuffCount(self): return len(self._buffList)
- def GetBuffByIndex(self, index):
- buff = self._buffList[index]
- #if False:
- # buff = PyBuff()
- return buff
-
+ def GetBuffByIndex(self, index): return self._buffList[index]
+
def AddBuff(self, skillID):
buff = None
- skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
- if not skillData:
+ ipyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
+ if not ipyData:
return buff
- skillTypeID = skillData.GetSkillTypeID()
+ skillTypeID = ipyData.GetSkillTypeID()
self._buffID += 1
- buff = ObjPool.GetPoolMgr().acquire(PyBuff, skillData)
- buff.SetBuffID(self._buffID)
+ buffID = self._buffID
+ buff = ObjPool.GetPoolMgr().acquire(PyBuff, ipyData)
+ buff.SetBuffID(buffID)
self._buffList.append(buff)
- self._buffIDDict[self._buffID] = buff
+ self._buffIDDict[buffID] = buff
+ #GameWorld.DebugLog("ObjBuff:%s, AddBuff buffID=%s, %s, %s, %s, %s, %s" % (self._batObj.GetID(), buffID, buff, len(self._buffList), len(self._buffIDDict), self._buffList, self._buffIDDict))
if skillTypeID not in self._skillTypeIDBuffIDs:
self._skillTypeIDBuffIDs[skillTypeID] = []
buffIDs = self._skillTypeIDBuffIDs[skillTypeID]
- if self._buffID not in buffIDs:
- buffIDs.append(self._buffID)
+ if buffID not in buffIDs:
+ buffIDs.append(buffID)
- #if False:
- # buff = PyBuff()
return buff
- def GetBuff(self, buffID):
- buff = None
- if buffID in self._buffIDDict:
- buff = self._buffIDDict[buffID]
- #if False:
- # buff = PyBuff()
- return buff
+ def DelBuff(self, buffID, release=True):
+ if buffID not in self._buffIDDict:
+ #GameWorld.DebugLog("ObjBuff:%s, DelBuff not in self._buffIDDict, buffID=%s, %s" % (self._batObj.GetID(), buffID, self._buffIDDict.keys()))
+ return
+ #GameWorld.DebugLog("ObjBuff:%s, DelBuff %s, buffID=%s, dict:%s, len:%s, list:%s" % (self._batObj.GetID(), release, buffID, self._buffIDDict, len(self._buffList), self._buffList))
+ buff = self._buffIDDict.pop(buffID)
+ if buff in self._buffList:
+ self._buffList.remove(buff)
+ else:
+ # 防范下找不到的情况
+ for lBuff in self._buffList[::-1]:
+ if lBuff.GetBuffID() == buffID:
+ self._buffList.remove(lBuff)
+ GameWorld.ErrLog("删除buff异常不在列表里! buffID=%s,lBuff=%s,buff=%s" % (buffID, lBuff, buff))
+ #GameWorld.DebugLog(" ObjBuff:%s, buffID=%s, dict:%s, len:%s, dictKeys:%s, list:%s" % (self._batObj.GetID(), buffID, len(self._buffIDDict), len(self._buffList), self._buffIDDict.keys(), self._buffList))
+ for skillTypeID, buffIDList in self._skillTypeIDBuffIDs.items():
+ if buffID not in buffIDList:
+ continue
+ buffIDList.remove(buffID)
+ if not buffIDList:
+ self._skillTypeIDBuffIDs.pop(skillTypeID)
+ break
+ if release:
+ ObjPool.GetPoolMgr().release(buff)
+ return
- def FindBuffIDBySkillID(self, skillID):
- ## 返回该技能ID的所有buffID列表
+ def GetBuff(self, buffID): return self._buffIDDict.get(buffID, None)
+ def FindBuffListBySkillID(self, skillID):
+ ## 返回该技能ID的所有buff列表
skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
if not skillData:
return []
- return self.FindBuffIDBySkillTypeID(skillData.GetSkillTypeID())
- def FindBuffIDBySkillTypeID(self, skillTypeID):
- ## 返回该技能TypeID的所有buffID列表
+ return self.FindBuffListBySkillTypeID(skillData.GetSkillTypeID())
+ def FindBuffListBySkillTypeID(self, skillTypeID):
+ ## 返回该技能TypeID的所有buff列表
if skillTypeID not in self._skillTypeIDBuffIDs:
return []
buffs = []
@@ -164,21 +491,92 @@
continue
buffs.append(self._buffIDDict[buffID])
return buffs
+ def FindBuffByState(self, state):
+ ## 查找某种buff状态的buff
+ buffIDList = self._buffStateDict.get(state, [])
+ if not buffIDList:
+ return
+ buffID = buffIDList[0]
+ return self._buffIDDict.get(buffID, None)
+ def FindBuffListByState(self, state):
+ ## 查找某种buff状态的buff列表
+ buffIDList = self._buffStateDict.get(state, [])
+ buffs = []
+ for buffID in buffIDList:
+ if buffID not in self._buffIDDict:
+ continue
+ buffs.append(self._buffIDDict[buffID])
+ return buffs
+
+ def AddBuffState(self, state, buffID):
+ ## 添加buff影响的状态，ChConfig.BatObjStateList
+ if state not in self._buffStateDict:
+ self._buffStateDict[state] = []
+ buffIDList = self._buffStateDict[state]
+ if buffID not in buffIDList:
+ buffIDList.append(buffID)
+ GameWorld.DebugLog(" AddBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))
+ return
+
+ def DelBuffState(self, state, buffID):
+ ## 删除buff影响的状态
+ if state not in self._buffStateDict: return
+ buffIDList = self._buffStateDict[state]
+ if buffID not in buffIDList:
+ return
+ buffIDList.remove(buffID)
+ if not buffIDList:
+ self._buffStateDict.pop(state)
+ GameWorld.DebugLog(" DelBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))
+ return
+
+ def IsInBuffState(self, state): return state in self._buffStateDict ## 是否处于某种状态下
+ def GetStateBuffIDList(self, state): return self._buffStateDict.get(state, []) # 获取某种状态的所有buffID列表
class PySkill():
- def __init__(self, skillData):
- self._skillData = skillData
+ def __init__(self, ipyData, objID):
+ self._objID = objID # 该技能谁的
+ self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)
+ self._calcTime = 0
self._remainTime = 0
self._batType = 0 # 战斗类型，普通、连击、反击、追击等
- self._enhanceBySkill = None # 由哪个主技能触发的
self._tagObjList = [] # 本次技能目标列表 [BatObj, ...]
- self._hurtList = [] # 本次伤血列表 [HurtObj, ...]
+ self._killObjList = [] # 本次技能击杀目标列表 [BatObj, ...]
+ self._hurtList = [] # 本次伤血列表，可能同一个对象有多个伤害，如弹射等 [HurtObj, ...]
+ self._bySkill = None # 由哪个技能触发的
+ self._byBuff = None # 由哪个buff触发的
+ self._afterLogicList = [] # 技能释放后需要处理逻辑 [[logicType, logicParams], ...]
+
+ # 连击相关
+ self._comboState = 0 # 连击状态 0-未重置，1-初始化连击相关可连击，2-连击已中断
+ self._comboNum = 0 # 连击次数
+ self._missTagIDDict = {} # 单次连续连击中对方已闪避次数 {tagID:missNum, ...}
+ self._parryTagIDDict = {} # 单次连续连击中对方已格挡次数 {tagID:parryNum, ...}
return
- def SetSkillData(self, skillData): self._skillData = skillData
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ self.ResetUseRec()
+ return
+
+ def ResetUseRec(self):
+ ## 重置技能使用记录
+ ## 注：有用到对象池相关对象的一定要重置，不然再回收技能对象时会连同该技能下的所有用到的对象池对象一并回收，导致后续使用对象错误
+ self._batType = 0
+ self._tagObjList = []
+ self._killObjList = []
+ self._bySkill = None
+ self._byBuff = None
+ self._afterLogicList = []
+ self.ClearHurtObj()
+ return
+
+ def GetObjID(self): return self._objID
+ def GetSkillData(self): return self._skillData
def GetSkillID(self): return self._skillData.GetSkillID()
def GetSkillTypeID(self): return self._skillData.GetSkillTypeID()
+ def GetSkillLV(self): return self._skillData.GetSkillLV()
def GetSkillMaxLV(self): return self._skillData.GetSkillMaxLV()
def GetSkillName(self): return self._skillData.GetSkillName()
def GetFuncType(self): return self._skillData.GetFuncType()
@@ -190,54 +588,49 @@
def GetTagSelf(self): return self._skillData.GetTagSelf() # 是否含自己
def GetTagAffect(self): return self._skillData.GetTagAffect() # 目标细分
def GetTagCount(self): return self._skillData.GetTagCount() # 目标个数
- def GetHappenRate(self): return self._skillData.GetHappenRate() # 释放或添加几率
- def GetLastTime(self): return self._skillData.GetLastTime() # 持续时间
+ def GetCalcType(self): return self._skillData.GetCalcType()
+ def GetSkillPer(self): return self._skillData.GetSkillPer()
+ def GetSkillValue(self): return self._skillData.GetSkillValue()
+ def GetHurtAtkPerMax(self): return self._skillData.GetHurtAtkPerMax()
+ def GetHappenRate(self): return self._skillData.GetHappenRate() # 触发概率
+ def GetEffect(self, index): return self._skillData.GetEffect(index)
+ def GetEffectCount(self): return self._skillData.GetEffectCount()
+ def GetEffectByID(self, effID, triggerWay=0): return self._skillData.GetEffectByID(effID, triggerWay)
+ def GetConnSkill(self): return self._skillData.GetConnSkill()
def GetCoolDownTime(self): return self._skillData.GetCoolDownTime()
- def FindEffectID(self, effID):
- ## 查找是否有某个效果ID
- # @return: 大于0该ID所在的效果ID编号； 0-不存在该效果ID
- for idNum in range(1, 1 + 3):
- if self.GetEffectID(idNum) == effID:
- return idNum
- return 0
- def GetEffectID(self, idNum):
- ## 获取效果ID
- # @param idNum: 效果ID编号，从1开始
- if idNum == 1:
- return self._skillData.GetEffectID1()
- if idNum == 2:
- return self._skillData.GetEffectID2()
- if idNum == 3:
- return self._skillData.GetEffectID3()
- return 0
- def GetEffectValue(self, idNum, index):
- ## 获取效果对应值
- # @param idNum: 效果ID编号，从1开始
- # @param index: 值索引，从0开始代表第1个值
- if idNum <= 0:
- return 0
- if idNum == 1:
- values = self._skillData.GetEffectValues1()
- elif idNum == 2:
- values = self._skillData.GetEffectValues2()
- elif idNum == 3:
- values = self._skillData.GetEffectValues3()
- else:
- return 0
- return values[index] if len(values) > index else 0
- def GetConnSkill(self): return self._skillData.GetConnSkill() # 关联技能
- def GetEnhanceSkillList(self): return self._skillData.GetEnhanceSkillList() # 额外触发的技能ID列表
+ def GetBuffStateLimit(self): return self._skillData.GetBuffStateLimit()
+ def GetCurBuffState(self): return self._skillData.GetCurBuffState()
+ def GetLastTime(self): return self._skillData.GetLastTime() # 持续时间
+ def GetLayerCnt(self): return self._skillData.GetLayerCnt()
+ def GetLayerMax(self): return self._skillData.GetLayerMax()
+ def GetBuffRepeat(self): return self._skillData.GetBuffRepeat() # Buff叠加规则
+ def GetDispersedLimit(self): return self._skillData.GetDispersedLimit() # 驱散限制
def GetFightPower(self): return self._skillData.GetFightPower()
+ def GetSkillMotionName(self): return self._skillData.GetSkillMotionName()
## ---------------------------------- 非技能表内容 ----------------------------------
+ def GetCalcTime(self): return self._calcTime
+ def SetCalcTime(self, calcTime): self._calcTime = calcTime
def GetRemainTime(self): return self._remainTime
def SetRemainTime(self, remainTime): self._remainTime = remainTime
def GetBatType(self): return self._batType
def SetBatType(self, batType): self._batType = batType
- def GetEnhanceBySkill(self): return self._enhanceBySkill
- def SetEnhanceBySkill(self, enhanceBySkill): self._enhanceBySkill = enhanceBySkill
+ def GetBySkill(self): return self._bySkill
+ def SetBySkill(self, bySkill): self._bySkill = bySkill
+ def GetByBuff(self): return self._byBuff
+ def SetByBuff(self, byBuff): self._byBuff = byBuff
def GetTagObjList(self): return self._tagObjList # 技能目标列表
def SetTagObjList(self, tagObjList): self._tagObjList = tagObjList
+ def GetKillObjList(self): return self._killObjList # 击杀目标列表
+ def SetKillObjList(self, killObjList): self._killObjList = killObjList
+ def GetAfterLogicList(self): return self._afterLogicList
+ def AddAfterLogic(self, logicType, logicData):
+ '''添加技能释放后需要处理额外逻辑
+ @param logicType: 逻辑类型
+ @param logicData: 逻辑对应的数据
+ '''
+ self._afterLogicList.append([logicType, logicData])
+ return
def ClearHurtObj(self):
## 清空伤血统计
poolMgr = ObjPool.GetPoolMgr()
@@ -252,19 +645,52 @@
self._hurtList.append(hurtObj)
return hurtObj
def GetHurtObjList(self): return self._hurtList
- def GetHurtObj(self, tagID):
- ## 获取某个伤血，如果目标没有在伤血列表里则返回None
- for hurtObj in self._hurtList:
- if hurtObj.GetObjID() == tagID:
- return hurtObj
+
+ def __commboClear(self):
+ ## 连击相关清空
+ self._comboState = 0
+ self._comboNum = 0
+ self._missTagIDDict = {}
+ self._parryTagIDDict = {}
return
+
+ def ComboCheckStart(self, force=False):
+ ## 检查并设置开始连击相关，一般是开始使用技能时调用
+ if not force:
+ if self._comboState == 1:
+ #GameWorld.DebugLog("连击进行中，不重置")
+ return
+ self.__commboClear()
+ self._comboState = 1 # 设置已初始化连击相关
+ #GameWorld.DebugLog("连击重置")
+ return
+
+ def ComboEnable(self): return self._comboState == 1 ## 可否执行连击相关
+
+ def ComboInterrupt(self):
+ ## 连击中断，概率不再触发连击时需要设置中断
+ self._comboState = 2
+ return
+
+ def GetComboNum(self): return self._comboNum # 已连击次数
+ def SetComboNum(self, comboNum): self._comboNum = comboNum
+ def GetTagMissNum(self, tagID): return self._missTagIDDict.get(tagID, 0)
+ def SetTagMissNum(self, tagID, missNum): self._missTagIDDict[tagID] = missNum
+ def GetTagParryNum(self, tagID): return self._parryTagIDDict.get(tagID, 0)
+ def SetTagParryNum(self, tagID, parryNum): self._parryTagIDDict[tagID] = parryNum
class SkillManager():
## 战斗对象技能管理器
- def __init__(self):
+ def __init__(self, batObj):
+ self._batObj = batObj
self._skillList = [] # 技能列表 [PySkill, ...]
self._skillDict = {} # {skillID:PySkill, ...}
+ return
+
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ self._batObj = None
return
def SkillReset(self):
@@ -276,70 +702,79 @@
return
def GetSkillCount(self): return len(self._skillList)
- def GetSkillByIndex(self, index):
- skill = self._skillList[index]
- #if False:
- # skill = PySkill()
- return skill
- def FindSkillByID(self, skillID):
- skill = self._skillDict.get(skillID, None)
- #if False:
- # skill = PySkill()
- return skill
+ def GetSkillByIndex(self, index): return self._skillList[index]
+ def GetSkillIDList(self): return self._skillDict.keys()
+ def FindSkillByID(self, skillID): return self._skillDict.get(skillID, None)
def FindSkillByTypeID(self, skillTypeID):
skill = None
for s in self._skillList:
if s.GetSkillTypeID() == skillTypeID:
skill = s
break
- #if False:
- # skill = PySkill()
return skill
def LearnSkillByID(self, skillID):
- skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
- if not skillData:
+ ipyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
+ if not ipyData:
return
if skillID in self._skillDict:
return
- skillTypeID = skillData.GetSkillTypeID()
+ skillTypeID = ipyData.GetSkillTypeID()
curSkill = self.FindSkillByTypeID(skillTypeID)
if curSkill:
if curSkill.GetSkillID() >= skillID:
return
- # 升级技能
- curSkill.SetSkillData(skillData)
- else:
- # 学新技能
- curSkill = ObjPool.GetPoolMgr().acquire(PySkill, skillData)
- self._skillDict[skillID] = curSkill
- self._skillList.append(curSkill)
+ self.__deleteSkill(curSkill)
+
+ # 学新技能
+ curSkill = ObjPool.GetPoolMgr().acquire(PySkill, ipyData, self._batObj.GetID())
+ self._skillDict[skillID] = curSkill
+ self._skillList.append(curSkill)
return curSkill
+
+ def __deleteSkill(self, curSkill):
+ skillID = curSkill.GetSkillID()
+ self._skillDict.pop(skillID, None)
+ if curSkill in self._skillList:
+ self._skillList.remove(curSkill)
+ ObjPool.GetPoolMgr().release(curSkill)
+ return
class BatObj():
## 战斗实体对象数据，目前与某个NPCObj绑定
def __init__(self):
self.tfGUID = "" # 所属的某场回合战斗的guid
+ self.ownerID = 0 # 所属玩家ID，可能为0，0代表非玩家的战斗实体
self.objID = 0
self.objName = ""
self.npcID = 0
- self.ownerID = 0 # 所属玩家ID，可能为0，0代表非玩家的战斗实体
self.heroID = 0
self.skinID = 0
+ self.country = 0
+ self.atkDistType = 0
+ self.specialty = 0 # 特长
+ self.sex = 0
+ self.job = 0
self.lv = 1
self.fightPower = 0
self.faction = 0 # 所属阵营，一般只有双方阵营， 1 或 2，发起方默认1
self.lineupNum = 1 # 阵容位置编号，一般多V多时有用，通常默认1
self.posNum = 0 # 所在阵容站位
+ self._hp = 0 # 当前生命值
+ self._xp = 0 # 当前怒气值
+ self._isAlive = True # 是否活着
self._initAttrDict = {} # 初始化时的属性，固定不变，初始化时已经算好的属性 {attrID:value, ...}
- self._batAttrDict = {} # 实际战斗属性，包含buff层级的实际属性
- self._skillTempAttrDict = {} # 某次技能释放中临时的属性增减 {attrID:+-value, ...}
+ self._batAttrDict = {} # 实际战斗属性，包含buff层级的实际属性 {attrID:+-value, ...} value可能是负值
+ self._skillTempAttrDict = {} # 某次技能释放中临时的属性增减 {attrID:+-value, ...} value可能是负值
self._kvDict = {} # 自定义kv字典
self._skillUseCntDict = {} # 技能累计使用次数 {skillID:useCnt, ...}
self._skillTurnUseCntDict = {} # 技能单回合累计使用次数 {skillID:useCnt, ...}
- self._skillMgr = ObjPool.GetPoolMgr().acquire(SkillManager)
- self._buffMgr = ObjPool.GetPoolMgr().acquire(BuffManager)
+ self._skillMgr = ObjPool.GetPoolMgr().acquire(SkillManager, self)
+ self._buffMgr = ObjPool.GetPoolMgr().acquire(BuffManager, self)
+ self._passiveEffMgr = ObjPool.GetPoolMgr().acquire(PassiveEffManager, self)
+ self._lastHurtValue = 0
+ self._mainTagIDList = [] # 主技能目标ID列表，一般用于技能拆分成多个技能效果时，子技能可能会用到主技能的对象做逻辑
# 统计
self.hurtStat = 0 # 输出统计
@@ -347,28 +782,86 @@
self.cureStat = 0 # 治疗统计
return
+ def onRelease(self):
+ ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收
+ return
+
def InitBatAttr(self, initAttrDict, initXP=0):
- ## 初始化战斗属性
+ '''初始化战斗属性
+ @param initAttrDict: 已经算好的在阵容中的属性，包含羁绊、阵容属性等，战斗中只要计算buff属性即可
+ @param initXP: 初始化的怒气值
+ '''
self._initAttrDict = initAttrDict
self._batAttrDict = {}
self._batAttrDict.update(initAttrDict)
- self._batAttrDict[ChConfig.AttrID_XP] = initXP
- self._batAttrDict[ChConfig.AttrID_HP] = initAttrDict.get(ChConfig.AttrID_MaxHP, 1)
+ self.__onUpdBatAttr()
self._skillTempAttrDict = {}
+ self.SetXP(initXP, False)
+ self.SetHPFull(False)
+ TurnBuff.RefreshBuffAttr(self)
+ TurnPassive.RefreshPassive(self)
return
+
+ def TurnReset(self):
+ ## 回合重置
+ self._skillTurnUseCntDict = {}
+
+ def UpdInitBatAttr(self, initAttrDict, skillIDList=None):
+ ## 更新战斗属性，一般只有主阵容需要更新，战斗中养成、装备变化等引起的主阵容属性变更时需要实时更新
+ self._initAttrDict = initAttrDict
+ learnNewSkill = False
+ if skillIDList:
+ for skillID in skillIDList:
+ if self._skillMgr.LearnSkillByID(skillID):
+ learnNewSkill = True
+ TurnBuff.RefreshBuffAttr(self)
+ if learnNewSkill: # 有学新技能时重刷技能被动
+ self._passiveEffMgr.RefreshSkillPassiveEffect()
+ return
+
+ def GMSetBatAttr(self, attrID, attrValue):
+ ## GM设置战斗属性
+ self._initAttrDict[attrID] = attrValue # 需要同步设置初始化属性，防止刷属性后被重置
+ if attrID == ChConfig.AttrID_HP:
+ self.SetHP(attrValue, True)
+ if attrValue > self.GetMaxHP():
+ self._initAttrDict[ChConfig.AttrID_MaxHP] = attrValue
+ self.SetMaxHP(attrValue, True)
+ elif attrID == ChConfig.AttrID_XP:
+ self.SetXP(attrValue, True)
+ else:
+ self.SetBatAttrValue(attrID, attrValue)
+ return
+
+ def ResetBattleEffect(self):
+ self._batAttrDict = {}
+ self._batAttrDict.update(self._initAttrDict)
+ self.__onUpdBatAttr()
+ return self._batAttrDict
+
def GetTFGUID(self): return self.tfGUID # 所属的某场战斗
def SetTFGUID(self, tfGUID): self.tfGUID = tfGUID
def GetTurnFight(self): return TurnAttack.GetTurnFightMgr().getTurnFight(self.tfGUID)
+ def GetOwnerID(self): return self.ownerID # 如果是玩家战斗单位，则该值非0，为所属玩家ID
+ def SetOwnerID(self, ownerID): self.ownerID = ownerID
def GetID(self): return self.objID
def GetName(self): return self.objName
def SetName(self, name): self.objName = name
+ def GetCountry(self): return self.country
+ def SetCountry(self, country): self.country = country
+ def GetAtkDistType(self): return self.atkDistType
+ def SetAtkDistType(self, atkDistType): self.atkDistType = atkDistType
+ def GetSpecialty(self): return self.specialty
+ def SetSpecialty(self, specialty): self.specialty = specialty
+ def GetSex(self): return self.sex
+ def SetSex(self, sex): self.sex = sex
+ def GetJob(self): return self.job
+ def SetJob(self, job): self.job = job
def GetNPCID(self): return self.npcID # 如果是NPC战斗单位，则该值非0
def SetNPCID(self, npcID): self.npcID = npcID # 设置所属的NPCID
- def GetOwnerID(self): return self.ownerID # 如果是玩家战斗单位，则该值非0，为所属玩家ID
- def GetHeroID(self): return self.heroID # 仅玩家有值，某个武将ID
+ def GetHeroID(self): return self.heroID
def GetSkinID(self): return self.skinID # 仅玩家有值，武将皮肤
- def SetOwnerHero(self, ownerID, heroID, skinID): # 设置所属的玩家及武将
- self.ownerID = ownerID
+ def SetHero(self, heroID, skinID=0): # 设置所属武将
self.heroID = heroID
self.skinID = skinID
def SetLineupPos(self, posNum, lineupNum=1):
@@ -390,6 +883,7 @@
def GetSkillManager(self): return self._skillMgr
def GetBuffManager(self):return self._buffMgr
+ def GetPassiveEffManager(self):return self._passiveEffMgr
def GetCanAttack(self):
## 可否被攻击
@@ -398,31 +892,102 @@
# return False
return True
+ def CheckInState(self, checkInState):
+ ## 是否处于某种状态下
+ if isinstance(checkInState, int):
+ checkInStateList = [checkInState]
+ elif isinstance(checkInState, list) or isinstance(checkInState, tuple):
+ checkInStateList = checkInState
+ else:
+ return False
+ for state in checkInStateList:
+ if self._buffMgr.IsInBuffState(state):
+ return True
+ return False
+
+ def IsInControlled(self): return self.IsInBuffStateGroup(1) or self.IsInBuffStateGroup(2) # 是否被控制中
+ def IsInControlledHard(self): return self.IsInBuffStateGroup(1) # 是否被硬控中
+ def IsInBuffStateGroup(self, buffStateGroup):
+ '''是否在某个状态组中
+ 已定义的组： 1 - 硬控组；2 - 软控组；3 - 限制普攻组；4 - 限制怒技组；5 - 限制被动动态组
+ '''
+ buffStateGroupDict = IpyGameDataPY.GetFuncEvalCfg("BuffStateGroup", 1, {})
+ if buffStateGroup not in buffStateGroupDict:
+ return
+ for state in buffStateGroupDict[buffStateGroup]:
+ if self._buffMgr.IsInBuffState(state):
+ return state
+ return
+
+ def CanAction(self):
+ ## 是否可以行动
+ if not self.IsAlive():
+ return False
+ if self.IsInControlledHard():
+ return False
+ return True
+
+ def GetSneerTagObj(self):
+ ## 获取被嘲讽的目标，如果存在则一定是活着的目标
+ buffIDList = self._buffMgr.GetStateBuffIDList(ChConfig.BatObjState_Sneer)
+ if not buffIDList:
+ return
+ objMgr = GetBatObjMgr()
+ for buffID in buffIDList:
+ buff = self._buffMgr.GetBuff(buffID)
+ if not buff:
+ continue
+ tagObj = objMgr.getBatObj(buff.GetOwnerID())
+ if tagObj and tagObj.IsAlive(): # 活着才有效
+ return tagObj
+ return
+
# 战斗属性
- def GetMaxHP(self): return self._batAttrDict.get(ChConfig.AttrID_MaxHP, 0)
- def SetMaxHP(self, maxHP): self._batAttrDict[ChConfig.AttrID_MaxHP] = maxHP
- def GetHP(self): return self._batAttrDict.get(ChConfig.AttrID_HP, 0)
+ def IsAlive(self): return self._isAlive # 是否活着
+ def SetDead(self):
+ self._isAlive = False
+ self._hp = 0
+ def GetMaxHP(self): return int(self._batAttrDict.get(ChConfig.AttrID_MaxHP, 0))
+ def SetMaxHP(self, maxHP, isNotify=False):
+ maxHP = int(maxHP)
+ self._batAttrDict[ChConfig.AttrID_MaxHP] = maxHP
+ if isNotify:
+ NotifyObjInfoRefresh(self, ChConfig.AttrID_MaxHP, maxHP)
+ return
+ def GetHP(self): return self._hp
def SetHP(self, hp, isNotify=False):
- self._batAttrDict[ChConfig.AttrID_HP] = hp
+ hp = int(hp)
+ self._hp = hp
if isNotify:
NotifyObjInfoRefresh(self, ChConfig.AttrID_HP, hp)
return
- def SetHPFull(self, isNotify=True): self.SetHP(self.GetMaxHP())
- def GetXP(self): return self._batAttrDict.get(ChConfig.AttrID_XP, 0)
+ def SetHPFull(self, isNotify=True): self.SetHP(self.GetMaxHP(), isNotify)
+ def GetXP(self): return self._xp
def SetXP(self, xp, isNotify=True):
- self._batAttrDict[ChConfig.AttrID_XP] = xp
+ xp = int(xp)
+ self._xp = xp
if isNotify:
NotifyObjInfoRefresh(self, ChConfig.AttrID_XP, xp)
return
- def GetAtk(self): return self.GetAttrValue(ChConfig.AttrID_Atk)
- def GetDef(self): return self.GetAttrValue(ChConfig.AttrID_Def)
+ def GetAtk(self): return self.GetBatAttrValue(ChConfig.AttrID_Atk)
+ def GetDef(self): return self.GetBatAttrValue(ChConfig.AttrID_Def)
- def GetAttrValue(self, attrID):
+ def GetBatAttrDict(self): return self._batAttrDict
+ def GetBatAttrValue(self, attrID, includeTemp=True):
+ #ChConfig.AttrID_HP ChConfig.AttrID_XP
value = self._batAttrDict.get(attrID, 0)
- if attrID in self._skillTempAttrDict:
+ if includeTemp and attrID in self._skillTempAttrDict:
value += self._skillTempAttrDict[attrID] # 支持正负值
- value = max(1, value)
+ #value = max(1, value)
return value
+ def SetBatAttrValue(self, attrID, value):
+ self._batAttrDict[attrID] = value
+ self.__onUpdBatAttr()
+ return
+ def __onUpdBatAttr(self):
+ for attrID in [ChConfig.AttrID_MaxHP]:
+ self._batAttrDict[attrID] = int(self._batAttrDict.get(attrID, 0))
+ return
def AddSkillTempAttr(self, attrID, value):
## 增加技能临时属性，支持正负值
# @param value: 正值-加属性；负值-减属性
@@ -435,6 +1000,12 @@
self._skillUseCntDict[skillID] = self._skillUseCntDict.get(skillID, 0) + 1
self._skillTurnUseCntDict[skillID] = self._skillTurnUseCntDict.get(skillID, 0) + 1
+ def GetLastHurtValue(self): return self._lastHurtValue
+ def SetLastHurtValue(self, lastHurtValue): self._lastHurtValue = lastHurtValue
+
+ def GetMainTagIDList(self): return self._mainTagIDList
+ def SetMainTagIDList(self, mainTagIDList): self._mainTagIDList = mainTagIDList
+
def StatHurtValue(self, hurtValue):
## 统计输出
self.hurtStat += hurtValue
@@ -444,38 +1015,12 @@
## 统计承伤
self.defStat += lostHP
return self.defStat
+ def GetStatDefValue(self): return self.defStat # 获取累计总承伤
def StatCureValue(self, cureValue):
## 统计治疗
self.cureStat += cureValue
return self.cureStat
-
- def TurnReset(self):
- ## 回合重置
- self._skillTurnUseCntDict = {}
-
- def ResetBatObj(self, isReborn=True):
- ## 重置战斗相关
- # @param isReborn: 死亡的是否复活
-
- # 重置统计
- self.hurtStat = 0
- self.defStat = 0
- self.cureStat = 0
-
- if self.GetHP() <= 0 and not isReborn:
- return
-
- # 清除buff
-
- # 回满血
- self.SetHPFull()
-
- # 重置怒气
- initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
- self.SetXP(initXP)
- return
-
class BattleObjMgr():
## 战斗对象管理器
@@ -532,14 +1077,15 @@
return
objID = batObj.objID
GameWorld.DebugLog("回收战斗单位: objID=%s" % (objID))
- turnFight = batObj.GetTurnFight()
- if turnFight:
- # //04 07 NPC消失#tagNPCDisappear 此处通知消失，与回合制死亡区分
- clientPack = ChNetSendPack.tagNPCDisappear()
- clientPack.NPCID = [objID]
- clientPack.Count = len(clientPack.NPCID)
- turnFight.addBatPack(clientPack)
-
+ #前端确认不需要通知消失
+ #turnFight = batObj.GetTurnFight()
+ #if turnFight:
+ # # //04 07 NPC消失#tagNPCDisappear 此处通知消失，与回合制死亡区分
+ # clientPack = ChNetSendPack.tagNPCDisappear()
+ # clientPack.NPCID = [objID]
+ # clientPack.Count = len(clientPack.NPCID)
+ # turnFight.addBatPack(clientPack)
+
# 最后回收对象
ObjPool.GetPoolMgr().release(batObj)
if objID not in self._freeIDList: # 回收ID，重复利用
--
Gitblit v1.8.0