129 【战斗】战斗系统-服务端（贾诩所有技能；5022效果支持配置buff额外属性计算方式；）

hxp

5 天以前 a075f7841fb2d0a3b32bf10c8bc2df5bf02d6acb

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Attack/BattleObj.py

@@ -23,7 +23,6 @@
import ChNetSendPack

import ShareDefine

import ChConfig

import ObjPool

import TurnPassive

import TurnBuff



@@ -32,9 +31,17 @@
    

    def __init__(self, batObj):

        self._batObj = batObj

        # 被影响的技能ID: 0为所有技能

        self._objID = batObj.GetID() if batObj else 0

        
        # 技能

        self._AffectSkillDict = {} # 被动技能 {(触发方式, 有效来源):{技能ID:[effID, ...], ...}, ...}

        self._affectSkillEnhanceDict = {} # 未学习的额外子技能被动效果 {skillID:{(触发方式, 有效来源):[effID, ...], ...}, ...}

        self._skillTriggerWayList = [] # 技能有的触发方式 [触发方式, ...] ，优化效率用，减少多余逻辑

        
        # buff

        self._AffectBuffDict = {} # 被动buff {(触发方式, 有效来源):{buffID:[effID, ...], ...}, ...}

        self._buffSkillIDDict = {} # {buffID:skillID, ...}

        self._buffTriggerWayList = [] # buff有的触发方式 [触发方式, ...] ，优化效率用，减少多余逻辑

        return

    

    def onRelease(self):

@@ -45,24 +52,16 @@
    def GetPassiveEffByTrigger(self, triggerWay, connSkill=None, connSkillTypeID=0, connBuff=None):

        '''获取可触发的效果列表，技能跟buff根据触发优先级按顺序触发，优先级越高越先执行，相同时技能优先

                        优先级之后有需要再扩展

        @return: [["skill/buff", skillID/buffID, effIDList], ...]

        @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():

        # 额外子技能的一般是未学习的技能，直接加载自身的被动效果

        if connSkill and not isinstance(connSkill, IpyGameDataPY.IPY_Skill) and self._objID == connSkill.GetObjID() \

            and connSkill.GetBatType() == ChConfig.TurnBattleType_Enhance:

            skillID = connSkill.GetSkillID()

            skillManager = self._batObj.GetSkillManager()

            # 非对象身上的技能，读取本技能被动触发的效果，一般是主技能拆分的子技能

            if not skillManager.FindSkillByID(skillID):

                effIDList = []

            if skillID not in self._affectSkillEnhanceDict:

                effDict = {}

                for index in xrange(connSkill.GetEffectCount()):

                    effect = connSkill.GetEffect(index)

                    effectID = effect.GetEffectID()

@@ -75,16 +74,32 @@
                    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])

                    
                        
                    key = (tWay, tSrc)

                    if key not in effDict:

                        effDict[key] = {}

                    effList = effDict[key]

                    if effectID not in effList:

                        effList.append(effList)

                self._affectSkillEnhanceDict[skillID] = effDict

                
            effDict = self._affectSkillEnhanceDict[skillID]

            if triggerWay in effDict:

                effList.append(["skill", skillID, 0, effDict[triggerWay]])

                
        if triggerWay not in self._skillTriggerWayList and triggerWay not in self._buffTriggerWayList:

            return effList

        
        if not connSkillTypeID:

            if connSkill:

                connSkillTypeID = connSkill.GetSkillTypeID()

            elif connBuff:

                connSkillTypeID = connBuff.GetSkillTypeID()

                
        # 优先取关联技能的

        if connSkillTypeID and connSkillTypeID not in [ChConfig.TriggerSrc_Skill, ChConfig.TriggerSrc_Buff, ChConfig.TriggerSrc_SkillSelf, ChConfig.TriggerSrc_BuffSelf]:

            # 技能

@@ -92,31 +107,36 @@
            if key in self._AffectSkillDict:

                effDict = self._AffectSkillDict[key]

                for skillID, effIDList in effDict.items():

                    effList.append(["skill", skillID, effIDList])

                    effList.append(["skill", skillID, 0, 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])

                    skillID = self._buffSkillIDDict[buffID] if buffID in self._buffSkillIDDict else 0

                    effList.append(["buff", skillID, buffID, effIDList])

                    

        # 所有技能有效的

        key = (triggerWay, ChConfig.TriggerSrc_Skill)

        effDict = self._AffectSkillDict.get(key, {})

        for skillID, effIDList in effDict.items():

            effList.append(["skill", skillID, effIDList])

        if key in self._AffectSkillDict:

            effDict = self._AffectSkillDict[key]

            for skillID, effIDList in effDict.items():

                effList.append(["skill", skillID, 0, effIDList])

            

        # 所有buff有效的

        key = (triggerWay, ChConfig.TriggerSrc_Buff)

        effDict = self._AffectBuffDict.get(key, {})

        for buffID, effIDList in effDict.items():

            effList.append(["buff", buffID, effIDList])

        if key in self._AffectBuffDict:

            effDict = self._AffectBuffDict[key]

            for buffID, effIDList in effDict.items():

                skillID = self._buffSkillIDDict[buffID] if buffID in self._buffSkillIDDict else 0

                effList.append(["buff", skillID, buffID, effIDList])

            

        return effList

    

    def RefreshSkillPassiveEffect(self):

        self._AffectSkillDict = {}

        self._skillTriggerWayList = []

        

        skillManager = self._batObj.GetSkillManager()

        for index in range(0, skillManager.GetSkillCount()):

@@ -140,7 +160,7 @@
            return

        if triggerWay in ChConfig.TriggerWayNoLoadList:

            return

        if triggerSrc in [ChConfig.TriggerSrc_Buff, ChConfig.TriggerSrc_BuffSelf]:

        if effect.GetTriggerBuffEnable():

            # buff有效的不加进来

            return

        

@@ -160,10 +180,14 @@
        if skillID not in effDict:

            effDict[skillID] = []

        effDict[skillID].append(effectID)

        if triggerWay not in self._skillTriggerWayList:

            self._skillTriggerWayList.append(triggerWay)

        return

        

    def RefreshBuffPassiveEffect(self):

        self._AffectBuffDict = {}

        self._buffTriggerWayList = []

        
        buffMgr = self._batObj.GetBuffManager()

        for index in range(buffMgr.GetBuffCount()):

            buff = buffMgr.GetBuffByIndex(index)

@@ -190,8 +214,8 @@
            return

        if triggerWay in ChConfig.TriggerWayNoLoadList:

            return

        if triggerSrc in [ChConfig.TriggerSrc_Skill, ChConfig.TriggerSrc_SkillSelf]:

            # 技能有效的不加进来

        if not effect.GetTriggerBuffEnable():

            # 非buff有效的不加进来

            return

        

        buffID = buff.GetBuffID()

@@ -212,6 +236,9 @@
        effIDList = effDict[buffID]

        if effectID not in effIDList:

            effIDList.append(effectID)

        self._buffSkillIDDict[buffID] = skillData.GetSkillID()

        if triggerWay not in self._buffTriggerWayList:

            self._buffTriggerWayList.append(triggerWay)

        return

    

    def DelBuffPassiveEffect(self, buffID):

@@ -219,9 +246,19 @@
        for key, effDict in self._AffectBuffDict.items():

            if buffID not in effDict:

                continue

            self._buffSkillIDDict.pop(buffID, 0)

            effDict.pop(buffID)

            if not effDict:

                self._AffectBuffDict.pop(key)

                # 检查移除存在的触发方式

                triggerWay = key[0]

                hasTrigger = False

                for k in self._AffectBuffDict.keys():

                    if triggerWay == k[0]:

                        hasTrigger = True

                        break

                if not hasTrigger and triggerWay in self._buffTriggerWayList:

                    self._buffTriggerWayList.remove(triggerWay)

        return

    

class HurtObj():

@@ -239,11 +276,11 @@
        self._objID = 0

        self._hurtTypes = 0 # 本次伤血类型，如闪避、暴击、格挡等，通过二进制或运算得到最终值，支持多种同时出现，如暴击的同时被格挡

        self._hurtHP = 0 # 公式最终计算的伤害值，一般用于飘血

        self._realHurtHP = 0 # 真实伤血值，被承伤盾抵扣后的可伤血的值

        self._lostHP = 0 # 实际掉血值

        self._curHP = 0 # 更新血量

        self._suckHP = 0 # 吸血量

        self._bounceHP = 0 # 反弹血量

        self._hurtListEx = [] # 额外伤血列表，一般后端单技能执行多次伤害逻辑时有用，如弹射的平摊伤害 [HurtObj, ...]

        return

    

    def GetObjID(self): return self._objID

@@ -253,14 +290,12 @@
    def AddHurtType(self, hurtType):

        ## 添加伤血类型，单次伤害支持多种类型同时出现

        self._hurtTypes |= pow(2, hurtType)

        return

        return self._hurtTypes

    def HaveHurtType(self, 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

@@ -269,15 +304,25 @@
    def SetSuckHP(self, suckHP): self._suckHP = suckHP

    def GetBounceHP(self): return self._bounceHP

    def SetBounceHP(self, bounceHP): self._bounceHP = bounceHP

    def ClearHurtObjEx(self):

        self._hurtListEx = []

        return

    def AddHurtObjEx(self, tagID):

        hurtObj = HurtObj()

        hurtObj.SetObjID(tagID)

        self._hurtListEx.append(hurtObj)

        return hurtObj

    def GetHurtObjListEx(self): return self._hurtListEx # 某个伤害的额外伤害列表

    

class SkillEffect():

    

    def __init__(self, effID, values, triggerWay=0, triggerSrc=0):

    def __init__(self, effID, values, triggerWay=0, triggerSrcs=[]):

        # @param triggerSrcs: 触发参数 [触发来源, buff时是否有效默认无效]

        self._effID = effID

        self._values = values

        self._triggerWay = triggerWay

        self._triggerSrc = triggerSrc

        #self._triggerParams = triggerParams if triggerParams else []

        self._triggerSrc = triggerSrcs[0] if len(triggerSrcs) > 0 else 0

        self._triggerBuffEnable = triggerSrcs[1] if len(triggerSrcs) > 1 else 0

        return

    

    def onRelease(self):

@@ -290,12 +335,19 @@
    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



    def GetTriggerBuffEnable(self):

        if self.GetTriggerSrc() in [ChConfig.TriggerSrc_Buff, ChConfig.TriggerSrc_BuffSelf]:

            return True

        if self._triggerBuffEnable:

            return True

        return False

    
class SklllData():

    

    def __init__(self, ipyData):

        self._ipyData = ipyData

        self._skillID = self._ipyData.GetSkillID()

        self._skillTypeID = self._ipyData.GetSkillTypeID()

        self._effList = [] # [Effect, ...]

        self._effDict = {} # {(effID, triggerWay):Effect, ...} ，确保唯一，同个技能可能配置相同的效果ID

        for num in range(1, 1 + 3):

@@ -303,8 +355,7 @@
            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)

            effect = SkillEffect(effID, values, triggerWay, triggerSrc)

            self._effList.append(effect)

            self._effDict[(effID, triggerWay)] = effect

        return

@@ -313,9 +364,11 @@
        ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收

        return

    

    def GetObjID(self): return 0 # 减少判断 hasattr 用

    def GetBatType(self): return -1 # 减少判断 hasattr 用

    def GetIpyData(self): return self._ipyData

    def GetSkillID(self): return self._ipyData.GetSkillID()

    def GetSkillTypeID(self): return self._ipyData.GetSkillTypeID()

    def GetSkillID(self): return self._skillID

    def GetSkillTypeID(self): return  self._skillTypeID

    def GetSkillLV(self): return self._ipyData.GetSkillLV()

    def GetSkillMaxLV(self): return self._ipyData.GetSkillMaxLV()

    def GetSkillName(self): return self._ipyData.GetSkillName()

@@ -333,25 +386,31 @@
    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 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 GetEffectByID(self, effID, triggerWay=0):

        if (effID, triggerWay) in self._effDict:

            return self._effDict[(effID, triggerWay)]

    def GetConnSkill(self): return self._ipyData.GetConnSkill()

    def GetCoolDownInit(self): return self._ipyData.GetCoolDownInit()

    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 GetLastTimeType(self): return self._ipyData.GetLastTimeType() # 持续时间规则

    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 GetDispersedLimit(self): return self._ipyData.GetDispersedLimit() or self._ipyData.GetSkillType() == ChConfig.Def_SkillType_Halo # 驱散限制

    def GetBuffRetain(self): return self._ipyData.GetBuffRetain()

    def GetFightPower(self): return self._ipyData.GetFightPower()

    

class PyBuff():

    

    def __init__(self, ipyData):

        self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)

        self._skillData = SklllData(ipyData)

        self._skillID = self._skillData.GetSkillID()

        self._skillTypeID = self._skillData.GetSkillTypeID()

        self._addTiming = 0 # 添加该buff时间点，0-自身回合前；1-自身回合后

        self._refreshState = 0 # 添加buff后是否刷新过剩余回合，未刷新过的需要先设置为已刷新，防止添加后马上被扣除1回合的时长

        self._buffID = 0

@@ -362,7 +421,8 @@
        self._value2 = 0

        self._value3 = 0

        self._isCopy = 0 # 是否复制的buff

        self._effExDict = {} # 效果ID额外数值 {effID:value, ...} # 计算方式取决于本buff技能中属性效果ID的配置

        self._effExDict = {} # 效果ID额外数值 {(effID, calcType):value, ...} # 计算方式取决于本buff技能中属性效果ID的配置

        self._haloObjIDList = [] # 光环有效目标ID列表 [objID, ...]，ownerID为自己时即为光源，包含光源

        return

    

    def onRelease(self):

@@ -370,7 +430,11 @@
        return

    

    def GetSkillData(self): return self._skillData

    def GetSkillID(self): return self._skillData.GetSkillID()

    def GetSkillID(self): return self._skillID

    def GetSkillTypeID(self): return self._skillTypeID

    def GetCurBuffState(self): return self._skillData.GetCurBuffState()

    def GetDispersedLimit(self): return self._skillData.GetDispersedLimit()

    def GetBuffRetain(self): return self._skillData.GetBuffRetain()

    def GetAddTiming(self): return self._addTiming

    def SetAddTiming(self, addTiming):

        self._addTiming = addTiming

@@ -401,9 +465,14 @@
    def SetValue3(self, value): self._value3 = value

    def GetIsCopy(self): return self._isCopy

    def SetIsCopy(self, isCopy): self._isCopy = isCopy

    def GetEffectValueEx(self, effID): return self._effExDict.get(effID, 0)

    def ResetEffectValueEx(self): self._effExDict = {}

    def AddEffectValueEx(self, effID, valueEx): self._effExDict[effID] = self._effExDict.get(effID, 0) + valueEx

    def AddEffectValueEx(self, effID, valueEx, calcType=1): self._effExDict[(effID, calcType)] = self._effExDict.get((effID, calcType), 0) + valueEx

    def GetEffectExDict(self): return self._effExDict

    def GetHaloObjIDList(self): return self._haloObjIDList

    def SetHaloObjIDList(self, haloObjIDList): self._haloObjIDList = haloObjIDList

    def AddHaloObjID(self, objID):

        if objID not in self._haloObjIDList:

            self._haloObjIDList.append(objID)

    

class BuffManager():

    ## 战斗对象buff管理器

@@ -424,9 +493,6 @@
        return

    

    def ClearBuff(self):

        poolMgr = ObjPool.GetPoolMgr()

        for buff in self._buffList:

            poolMgr.release(buff)

        self._buffList = []

        self._buffIDDict = {}

        self._skillTypeIDBuffIDs = {}

@@ -446,12 +512,12 @@
        self._buffID += 1

        

        buffID = self._buffID

        buff = ObjPool.GetPoolMgr().acquire(PyBuff, ipyData)

        buff = PyBuff(ipyData)

        buff.SetBuffID(buffID)

        

        self._buffList.append(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))

        #GameWorld.DebugLogEx("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]

@@ -462,9 +528,9 @@
    

    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()))

            #GameWorld.DebugLogEx("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))

        #GameWorld.DebugLogEx("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)

@@ -474,7 +540,7 @@
                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))

        #GameWorld.DebugLogEx("    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

@@ -482,11 +548,11 @@
            if not buffIDList:

                self._skillTypeIDBuffIDs.pop(skillTypeID)

            break

        if release:

            ObjPool.GetPoolMgr().release(buff)

        return

    

    def GetBuff(self, buffID): return self._buffIDDict.get(buffID, None)

    def GetBuff(self, buffID):

        if buffID in self._buffIDDict:

            return self._buffIDDict[buffID]

    def FindBuffListBySkillID(self, skillID):

        ## 返回该技能ID的所有buff列表

        skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)

@@ -503,16 +569,31 @@
                continue

            buffs.append(self._buffIDDict[buffID])

        return buffs

    def FindBuffBySkillID(self, skillID, ownerID=0):

        ## 查找某个技能ID的buff

        # @param ownerID: 可指定查找指定来源的buff

        buffList = self.FindBuffListBySkillID(skillID)

        if not ownerID:

            return buffList[0] if buffList else None

        for buff in buffList:

            if buff.GetOwnerID() == ownerID:

                return buff

        return

    def FindBuffByState(self, state):

        ## 查找某种buff状态的buff

        buffIDList = self._buffStateDict.get(state, [])

        if state not in self._buffStateDict:

            return

        buffIDList = self._buffStateDict[state]

        if not buffIDList:

            return

        buffID = buffIDList[0]

        return self._buffIDDict.get(buffID, None)

        if buffID in self._buffIDDict:

            return self._buffIDDict[buffID]

    def FindBuffListByState(self, state):

        ## 查找某种buff状态的buff列表

        buffIDList = self._buffStateDict.get(state, [])

        if state not in self._buffStateDict:

            return []

        buffIDList = self._buffStateDict[state]

        buffs = []

        for buffID in buffIDList:

            if buffID not in self._buffIDDict:

@@ -527,7 +608,7 @@
        buffIDList = self._buffStateDict[state]

        if buffID not in buffIDList:

            buffIDList.append(buffID)

        GameWorld.DebugLog("    AddBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))

        GameWorld.DebugLogEx("    AddBuffState state=%s,buffID=%s,%s", state, buffID, self._buffStateDict)

        return

    

    def DelBuffState(self, state, buffID):

@@ -539,23 +620,30 @@
        buffIDList.remove(buffID)

        if not buffIDList:

            self._buffStateDict.pop(state)

        GameWorld.DebugLog("    DelBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))

        GameWorld.DebugLogEx("    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列表

    def GetStateBuffIDList(self, state): # 获取某种状态的所有buffID列表

        if state in self._buffStateDict:

            return self._buffStateDict[state]

        return []

    

class PySkill():

    

    def __init__(self, ipyData, objID):

        self._objID = objID # 该技能谁的

        self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)

        self._skillData = SklllData(ipyData)

        self._skillID = self._skillData.GetSkillID()

        self._skillTypeID = self._skillData.GetSkillTypeID()

        self._remainTime = 0

        self._batType = 0 # 战斗类型，普通、连击、反击、追击等

        self._tagObjList = [] # 本次技能目标列表 [BatObj, ...]

        self._tagObjList = [] # 本次技能主要目标列表 [BatObj, ...]

        self._tagObjListEx = [] # 本次技能额外目标列表，平摊伤害、溅射等 [BatObj, ...]

        self._killObjList = [] # 本次技能击杀目标列表 [BatObj, ...]

        self._effIgnoreObjIDList = [] # 额外技能效果无效的目标ID列表，一般是被闪避、免疫等

        self._hurtList = [] # 本次伤血列表，可能同一个对象有多个伤害，如弹射等 [HurtObj, ...]

        self._hurtList = [] # 主要伤血列表，可能同一个对象有多个伤害，如弹射等 [HurtObj, ...]

        self._hurtListEx = [] # 额外伤血列表，如平摊、溅射 [HurtObj, ...]

        self._bySkill = None # 由哪个技能触发的

        self._byBuff = None # 由哪个buff触发的

        self._afterLogicList = [] # 技能释放后需要处理逻辑 [[logicType, logicParams], ...]

@@ -578,6 +666,7 @@
        ## 注：有用到对象池相关对象的一定要重置，不然再回收技能对象时会连同该技能下的所有用到的对象池对象一并回收，导致后续使用对象错误

        self._batType = 0

        self._tagObjList = []

        self._tagObjListEx = []

        self._killObjList = []

        self._effIgnoreObjIDList = []

        self._bySkill = None

@@ -588,8 +677,8 @@
    

    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 GetSkillID(self): return self._skillID

    def GetSkillTypeID(self): return self._skillTypeID

    def GetSkillLV(self): return self._skillData.GetSkillLV()

    def GetSkillMaxLV(self): return self._skillData.GetSkillMaxLV()

    def GetSkillName(self): return self._skillData.GetSkillName()

@@ -616,10 +705,12 @@
    def GetBuffStateLimit(self): return self._skillData.GetBuffStateLimit()

    def GetCurBuffState(self): return self._skillData.GetCurBuffState()

    def GetLastTime(self): return self._skillData.GetLastTime() # 持续时间

    def GetLastTimeType(self): return self._skillData.GetLastTimeType() # 持续时间规则

    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 GetBuffRetain(self): return self._ipyData.GetBuffRetain()

    def GetFightPower(self): return self._skillData.GetFightPower()

    

    ## ---------------------------------- 非技能表内容 ----------------------------------

@@ -631,8 +722,12 @@
    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 GetTagObjList(self): return self._tagObjList # 技能主要目标列表

    def SetTagObjList(self, tagObjList): self._tagObjList = tagObjList

    def GetTagObjListEx(self): return self._tagObjListEx # 技能额外目标列表

    def AddTagObjEx(self, tagObj):

        if tagObj not in self._tagObjList and tagObj not in self._tagObjListEx:

            self._tagObjListEx.append(tagObj)

    def GetKillObjList(self): return self._killObjList # 击杀目标列表

    def SetKillObjList(self, killObjList): self._killObjList = killObjList

    def GetEffIgnoreObjIDList(self): return self._effIgnoreObjIDList # 额外技能效果无效的目标ID列表

@@ -647,18 +742,27 @@
        return

    def ClearHurtObj(self):

        ## 清空伤血统计

        poolMgr = ObjPool.GetPoolMgr()

        for hurtObj in self._hurtList:

            poolMgr.release(hurtObj)

            hurtObj.ClearHurtObjEx()

        self._hurtList = []

        
        for hurtObjEx in self._hurtListEx:

            hurtObjEx.ClearHurtObjEx()

        self._hurtListEx = []

        return

    def AddHurtObj(self, tagID):

    def AddHurtObj(self, tagID, isEx=False):

        ## 添加某个伤血

        hurtObj = ObjPool.GetPoolMgr().acquire(HurtObj)

        # @param isEx: 是否额外伤血

        hurtObj = HurtObj()

        hurtObj.SetObjID(tagID)

        self._hurtList.append(hurtObj)

        if isEx:

            self._hurtListEx.append(hurtObj)

        else:

            self._hurtList.append(hurtObj)

        return hurtObj

    def GetHurtObjList(self): return self._hurtList

    def GetHurtObjList(self): return self._hurtList # 技能主要伤血列表

    def GetHurtObjListEx(self): return self._hurtListEx # 技能额外伤血列表

    def GetHurtObjListAll(self): return self._hurtList + self._hurtListEx # 技能所有伤血列表

    

    def __commboClear(self):

        ## 连击相关清空

@@ -672,11 +776,11 @@
        ## 检查并设置开始连击相关，一般是开始使用技能时调用

        if not force:

            if self._comboState == 1:

                #GameWorld.DebugLog("连击进行中，不重置")

                #GameWorld.DebugLogEx("连击进行中，不重置")

                return

        self.__commboClear()

        self._comboState = 1 # 设置已初始化连击相关

        #GameWorld.DebugLog("连击重置")

        #GameWorld.DebugLogEx("连击重置")

        return

    

    def ComboEnable(self): return self._comboState == 1 ## 可否执行连击相关

@@ -711,9 +815,6 @@
        return

    

    def SkillReset(self):

        poolMgr = ObjPool.GetPoolMgr()

        for skill in self._skillList:

            poolMgr.release(skill)

        self._skillList = []

        self._skillDict = {}

        return

@@ -721,7 +822,9 @@
    def GetSkillCount(self): return len(self._skillList)

    def GetSkillByIndex(self, index): return self._skillList[index]

    def GetSkillIDList(self): return sorted(self._skillDict.keys())

    def FindSkillByID(self, skillID): return self._skillDict.get(skillID, None)

    def FindSkillByID(self, skillID):

        if skillID in self._skillDict:

            return self._skillDict[skillID]

    def FindSkillByTypeID(self, skillTypeID):

        skill = None

        for s in self._skillList:

@@ -744,7 +847,7 @@
            self.__deleteSkill(curSkill)

            

        # 学新技能

        curSkill = ObjPool.GetPoolMgr().acquire(PySkill, ipyData, self._batObj.GetID())

        curSkill = PySkill(ipyData, self._batObj.GetID())

        self._skillDict[skillID] = curSkill

        self._skillList.append(curSkill)

        return curSkill

@@ -754,7 +857,6 @@
        self._skillDict.pop(skillID, None)

        if curSkill in self._skillList:

            self._skillList.remove(curSkill)

        ObjPool.GetPoolMgr().release(curSkill)

        return

    

class BatObj():

@@ -774,6 +876,7 @@
        self.sex = 0

        self.job = 0

        self.lv = 1

        self._star = 0

        self.fightPower = 0

        self.faction = 0 # 所属阵营，一般只有双方阵营， 1 或 2，发起方默认1

        self.lineupNum = 1 # 阵容位置编号，一般多V多时有用，通常默认1

@@ -785,15 +888,19 @@
        self._batAttrDict = {} # 实际战斗属性，包含buff层级的实际属性 {attrID:+-value, ...} value可能是负值

        self._skillTempAttrDict = {} # 某次技能释放中临时的属性增减 {attrID:+-value, ...} value可能是负值

        self._kvDict = {} # 自定义kv字典

        self._bigTurnAtkbackCnt = 0 # 大回合累计反击次数

        self._incrementValue = 0 # 自增值，每场战斗重置，用于确保唯一的场景，如 Skill tag 标签

        self._skillHappenFailCntDict = {} # 技能累计概率触发次数，使用成功后重置 {skillID:failCnt, ...}

        self._skillUseCntDict = {} # 技能累计使用次数 {skillID:useCnt, ...}

        self._skillTurnUseCntDict = {} # 技能单回合累计使用次数 {skillID:useCnt, ...}

        self._skillMgr = ObjPool.GetPoolMgr().acquire(SkillManager, self)

        self._buffMgr = ObjPool.GetPoolMgr().acquire(BuffManager, self)

        self._passiveEffMgr = ObjPool.GetPoolMgr().acquire(PassiveEffManager, self)

        self._skillMgr = SkillManager(self)

        self._buffMgr = BuffManager(self)

        self._passiveEffMgr = PassiveEffManager(self)

        self._lastHurtValue = 0

        self._harmSelfHP = 0 # 自残值

        self._mainTagIDList = [] # 主技能目标ID列表，一般用于技能拆分成多个技能效果时，子技能可能会用到主技能的对象做逻辑

        self._timing = 0 # 当前武将时间节点： 0-回合前；1-回合后

        self._angerOverflow = 0 # 怒气技能怒气溢出值，子技能也生效，因为主技能释放后怒气会被扣除，所以这里做个记录

        

        # 统计

        self.hurtStat = 0 # 输出统计

@@ -817,7 +924,7 @@
        self._skillTempAttrDict = {}

        self.SetXP(initXP, False)

        self.SetHPFull(False)

        TurnBuff.RefreshBuffAttr(self)

        TurnBuff.RefreshBuffAttr(self, isInit=True)

        TurnPassive.RefreshPassive(self)

        return

    

@@ -849,6 +956,7 @@
        return

    

    def ResetBattleEffect(self):

        ## 重置战斗属性，一般刷属性前调用

        self._batAttrDict = {}

        self._batAttrDict.update(self._initAttrDict)

        self.__onUpdBatAttr()

@@ -897,6 +1005,8 @@
    def SetFightPower(self, fightPower): self.fightPower = fightPower

    def GetLV(self): return self.lv

    def SetLV(self, lv): self.lv = lv

    def GetStar(self): return self._star

    def SetStar(self, star): self._star = star

    def GetDictByKey(self, key): return self._kvDict.get(key, 0)

    def SetDict(self, key, value): self._kvDict[key] = value

    

@@ -967,6 +1077,9 @@
    def SetDead(self):

        self._isAlive = False

        self._hp = 0

    def SetRevive(self, hp):

        self._isAlive = True

        self._hp = hp

    def GetMaxHP(self): return int(self._batAttrDict.get(ChConfig.AttrID_MaxHP, 0))

    def SetMaxHP(self, maxHP, isNotify=False):

        maxHP = int(maxHP)

@@ -1014,22 +1127,46 @@
        self._skillTempAttrDict[attrID] = self._skillTempAttrDict.get(attrID, 0) + value

    def ClearSkillTempAttr(self): self._skillTempAttrDict = {}

    

    def GetSkillHappenFailCnt(self, skillID): return self._skillHappenFailCntDict.get(skillID, 0) # 技能概率触发失败累计次数

    def IsSkillCanHappen(self, skillID, happenRate):

        if happenRate and not GameWorld.CanHappen(happenRate, ChConfig.Def_MaxRateValue):

            self._skillHappenFailCntDict[skillID] = self._skillHappenFailCntDict.get(skillID, 0) + 1

            return False

        self._skillHappenFailCntDict.pop(skillID, 0)

        return True

    
    def GetSkillUseCnt(self, skillID): return self._skillUseCntDict.get(skillID, 0) # 单场战斗累计使用次数

    def GetSkillTurnUseCnt(self, skillID): return self._skillTurnUseCntDict.get(skillID, 0) # 单回合累计使用次数

    def ResetSkillTurnUseCnt(self):

        self._skillTurnUseCntDict = {}

    def ResetSkillUseCnt(self):

        ## 每场战斗开始时重置

        self._skillHappenFailCntDict = {}

        self._skillUseCntDict = {}

        self._skillTurnUseCntDict = {}

        self._incrementValue = 0

    def AddSkillUseCnt(self, skillID):

        self._skillUseCntDict[skillID] = self._skillUseCntDict.get(skillID, 0) + 1

        self._skillTurnUseCntDict[skillID] = self._skillTurnUseCntDict.get(skillID, 0) + 1

        

    def GetBigTurnAtkbackCnt(self): return self._bigTurnAtkbackCnt

    def AddBigTurnAtkbackCnt(self):  self._bigTurnAtkbackCnt += 1

    
    def ResetBigTurn(self):

        ## 每大回合重置

        self._bigTurnAtkbackCnt = 0

        self._skillTurnUseCntDict = {}

    
    def GetIncrementValue(self):

        self._incrementValue += 1

        return self._incrementValue

    
    def GetLastHurtValue(self): return self._lastHurtValue

    def SetLastHurtValue(self, lastHurtValue): self._lastHurtValue = lastHurtValue

    

    def GetHarmSelfHP(self): return self._harmSelfHP

    def SetHarmSelfHP(self, harmSelfHP): self._harmSelfHP = harmSelfHP

    
    def GetAngerOverflow(self): return self._angerOverflow

    def SetAngerOverflow(self, angerOverflow): self._angerOverflow = angerOverflow

    

    def GetMainTagIDList(self): return self._mainTagIDList

    def SetMainTagIDList(self, mainTagIDList): self._mainTagIDList = mainTagIDList

@@ -1084,10 +1221,10 @@
        newObjID = self.__getNewObjID()

        if not newObjID:

            return newBatObj

        newBatObj = ObjPool.GetPoolMgr().acquire(BatObj)

        newBatObj = BatObj()

        newBatObj.objID = newObjID

        self.batObjDict[newObjID] = newBatObj

        GameWorld.DebugLog("添加战斗单位: objID=%s" % (newObjID))

        GameWorld.DebugLogEx("添加战斗单位: objID=%s", newObjID)

        if False:

            newBatObj = BatObj(None, 0)

        return newBatObj

@@ -1107,7 +1244,7 @@
        if not batObj:

            return

        objID = batObj.objID

        GameWorld.DebugLog("回收战斗单位: objID=%s" % (objID))

        GameWorld.DebugLogEx("回收战斗单位: objID=%s", objID)

        #前端确认不需要通知消失

        #turnFight = batObj.GetTurnFight()

        #if turnFight:

@@ -1118,7 +1255,6 @@
        #    turnFight.addBatPack(clientPack)

        

        # 最后回收对象

        ObjPool.GetPoolMgr().release(batObj)

        if objID not in self._freeIDList: # 回收ID，重复利用

            self._freeIDList.append(objID)

        return

@@ -1131,7 +1267,7 @@
    return batObjMgr



def OnMinute():

    GameWorld.Log("战斗单位数量: %s" % len(GetBatObjMgr().batObjDict))

    #GameWorld.Log("战斗单位数量: %s" % len(GetBatObjMgr().batObjDict))

    return



def NotifyObjInfoRefresh(batObj, attrID, value):

@@ -1142,7 +1278,7 @@
    turnFight = TurnAttack.GetTurnFightMgr().getTurnFight(batObj.GetTFGUID())

    if not turnFight:

        return

    clientPack = ObjPool.GetPoolMgr().acquire(ChNetSendPack.tagObjInfoRefresh)

    clientPack = ChNetSendPack.tagObjInfoRefresh()

    clientPack.ObjID = batObj.GetID()

    clientPack.RefreshType = refreshType

    if isBig: