129 【战斗】战斗系统-服务端（词条技能1020；增加效果5050 - 触发释放技能（按累计能量达到时释放））

hxp

9 天以前 7d3e60ddbd25e5dbc58450b8f5595bb431303330

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

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

        return

    

    def onRelease(self):

        ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收

        self._batObj = None

        return

    
    def GetPassiveEffByTrigger(self, triggerWay, connSkill=None, connSkillTypeID=0, connBuff=None):

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

                        优先级之后有需要再扩展

@@ -63,14 +68,18 @@
                    effectID = effect.GetEffectID()

                    if effectID == 0:

                        continue

                    triggerWay = effect.GetTriggerWay()

                    triggerSrc = effect.GetTriggerSrc()

                    if not triggerWay:

                    tWay = effect.GetTriggerWay()

                    tSrc = effect.GetTriggerSrc()

                    if not tWay:

                        continue

                    if triggerWay in ChConfig.TriggerWayNoLoadList:

                    if tWay in ChConfig.TriggerWayNoLoadList:

                        continue

                    if triggerSrc != ChConfig.TriggerSrc_SkillSelf:

                    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:

@@ -222,6 +231,10 @@
        self.Clear()

        return

    

    def onRelease(self):

        ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收

        return

    
    def Clear(self):

        self._objID = 0

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

@@ -267,6 +280,10 @@
        #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)

@@ -290,6 +307,10 @@
            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

@@ -316,6 +337,7 @@
    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 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()

@@ -323,34 +345,44 @@
    def GetLayerCnt(self): return self._ipyData.GetLayerCnt()

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

    def GetBuffRepeat(self): return self._ipyData.GetBuffRepeat() # Buff叠加规则

    def GetDieContinue(self): return self._ipyData.GetDieContinue() # 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, ipyData):

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

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

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

        self._buffID = 0

        self._ownerID = 0

        self._layer = 0

        self._calcTime = 0

        self._remainTime = 0

        self._value1 = 0 # 值需要通知前端，开发时注意20亿问题

        self._value2 = 0

        self._value3 = 0

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

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

        return

    
    def onRelease(self):

        ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收

        return

    

    def GetSkillData(self): return self._skillData

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

    def GetAddTiming(self): return self._addTiming

    def SetAddTiming(self, addTiming):

        self._addTiming = addTiming

        self._refreshState = 0 # 更新添加时机时需标记为未刷新

    def GetRefreshState(self): return self._refreshState

    def SetRefreshState(self, refreshState): self._refreshState = refreshState

    def GetBuffID(self): return self._buffID

    def SetBuffID(self, buffID): self._buffID = buffID

    def GetOwnerID(self): return self._ownerID

    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 SetBuffValueList(self, valueList):

@@ -367,6 +399,11 @@
    def SetValue2(self, value): self._value2 = value

    def GetValue3(self): return self._value3

    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

    

class BuffManager():

    ## 战斗对象buff管理器

@@ -379,6 +416,11 @@
        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):

@@ -468,6 +510,15 @@
            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

@@ -499,14 +550,16 @@
    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._tagObjList = [] # 本次技能目标列表 [BatObj, ...]

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

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

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

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

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

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

        self._energy = 0 # 技能能量，一般用于累计能量达到某种条件后做逻辑

        

        # 连击相关

        self._comboState = 0 # 连击状态 0-未重置，1-初始化连击相关可连击，2-连击已中断

@@ -515,9 +568,18 @@
        self._parryTagIDDict = {} # 单次连续连击中对方已格挡次数 {tagID:parryNum, ...}

        return

    

    def onRelease(self):

        ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收

        self.ResetUseRec()

        return

    
    def ResetUseRec(self):

        ## 重置技能使用记录

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

        self._batType = 0

        self._tagObjList = []

        self._killObjList = []

        self._effIgnoreObjIDList = []

        self._bySkill = None

        self._byBuff = None

        self._afterLogicList = []

@@ -525,6 +587,7 @@
        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()

@@ -548,6 +611,7 @@
    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 GetCoolDownInit(self): return self._skillData.GetCoolDownInit()

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

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

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

@@ -555,13 +619,10 @@
    def GetLayerCnt(self): return self._skillData.GetLayerCnt()

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

    def GetBuffRepeat(self): return self._skillData.GetBuffRepeat() # Buff叠加规则

    def GetDieContinue(self): return self._skillData.GetDieContinue() # 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

@@ -572,6 +633,10 @@
    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 GetEffIgnoreObjIDList(self): return self._effIgnoreObjIDList # 额外技能效果无效的目标ID列表

    def SetEffIgnoreObjIDList(self, effIgnoreObjIDList): self._effIgnoreObjIDList = effIgnoreObjIDList

    def GetAfterLogicList(self): return self._afterLogicList

    def AddAfterLogic(self, logicType, logicData):

        '''添加技能释放后需要处理额外逻辑

@@ -628,6 +693,9 @@
    def GetTagParryNum(self, tagID): return self._parryTagIDDict.get(tagID, 0)

    def SetTagParryNum(self, tagID, parryNum): self._parryTagIDDict[tagID] = parryNum

    

    def GetEnergy(self): return self._energy # 累计能量

    def SetEnergy(self, energy): self._energy = energy

    
class SkillManager():

    ## 战斗对象技能管理器

    

@@ -635,6 +703,11 @@
        self._batObj = batObj

        self._skillList = [] # 技能列表 [PySkill, ...]

        self._skillDict = {} # {skillID:PySkill, ...}

        return

    
    def onRelease(self):

        ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收

        self._batObj = None

        return

    

    def SkillReset(self):

@@ -647,7 +720,7 @@
    

    def GetSkillCount(self): return len(self._skillList)

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

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

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

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

    def FindSkillByTypeID(self, skillTypeID):

        skill = None

@@ -718,12 +791,18 @@
        self._buffMgr = ObjPool.GetPoolMgr().acquire(BuffManager, self)

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

        self._lastHurtValue = 0

        self._harmSelfHP = 0 # 自残值

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

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

        

        # 统计

        self.hurtStat = 0 # 输出统计

        self.defStat = 0 # 承伤统计

        self.cureStat = 0 # 治疗统计

        return

    
    def onRelease(self):

        ## 回收前处理，主要处理一些其他不需要释放的对象池对象，防止被连同误回收

        return

    

    def InitBatAttr(self, initAttrDict, initXP=0):

@@ -742,20 +821,31 @@
        TurnPassive.RefreshPassive(self)

        return

    

    def TurnReset(self):

        ## 回合重置

        self._skillTurnUseCntDict = {}

        
    def UpdInitBatAttr(self, initAttrDict, skillIDList):

    def UpdInitBatAttr(self, initAttrDict, skillIDList=None):

        ## 更新战斗属性，一般只有主阵容需要更新，战斗中养成、装备变化等引起的主阵容属性变更时需要实时更新

        self._initAttrDict = initAttrDict

        learnNewSkill = False

        for skillID in skillIDList:

            if self._skillMgr.LearnSkillByID(skillID):

                learnNewSkill = True

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

@@ -767,6 +857,10 @@
    def GetTFGUID(self): return self.tfGUID # 所属的某场战斗

    def SetTFGUID(self, tfGUID): self.tfGUID = tfGUID

    def GetTurnFight(self): return TurnAttack.GetTurnFightMgr().getTurnFight(self.tfGUID)

    def GetBatLineup(self):

        turnFight = self.GetTurnFight()

        batFaction = turnFight.getBatFaction(self.faction)

        return batFaction.getBatlineup(self.lineupNum)

    def GetOwnerID(self): return self.ownerID # 如果是玩家战斗单位，则该值非0，为所属玩家ID

    def SetOwnerID(self, ownerID): self.ownerID = ownerID

    def GetID(self): return self.objID

@@ -830,18 +924,19 @@
                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):

    def IsInControlled(self): return self.IsInBuffStateGroup([1, 2]) # 是否被控制中

    def IsInControlledHard(self): return self.IsInBuffStateGroup([1]) # 是否被硬控中

    def IsInBuffStateGroup(self, buffStateGroups):

        '''是否在某个状态组中

                        已定义的组： 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

        for stateGroup in buffStateGroups:

            if str(stateGroup) not in buffStateGroupDict:

                continue

            for state in buffStateGroupDict[str(stateGroup)]:

                if self._buffMgr.IsInBuffState(state):

                    return state

        return

    

    def CanAction(self):

@@ -919,8 +1014,13 @@
        self._skillTempAttrDict[attrID] = self._skillTempAttrDict.get(attrID, 0) + value

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

    

    def GetSkillUseCnt(self, skillID): return self._skillUseCntDict.get(skillID, 0)

    def GetSkillTurnUseCnt(self, skillID): return self._skillTurnUseCntDict.get(skillID, 0)

    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._skillUseCntDict = {}

        self._skillTurnUseCntDict = {}

    def AddSkillUseCnt(self, skillID):

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

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

@@ -928,8 +1028,14 @@
    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 GetMainTagIDList(self): return self._mainTagIDList

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

    
    def GetTiming(self): return self._timing # 时间节点 0-回合前；1-回合后

    def SetTiming(self, timing): self._timing = timing

    

    def StatHurtValue(self, hurtValue):

        ## 统计输出

@@ -940,6 +1046,7 @@
        ## 统计承伤

        self.defStat += lostHP

        return self.defStat

    def GetStatDefValue(self): return self.defStat # 获取累计总承伤

    

    def StatCureValue(self, cureValue):

        ## 统计治疗