6516 【后端】【2.0】战斗公式增加系数

hch

2019-04-18 2f95eaf5e679b2b798d3fa1988636a3795656cce

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Skill/PassiveBuffEffMng.py

@@ -21,12 +21,10 @@
        

#导入

import IPY_GameWorld

import ReadChConfig

import PassiveBuff

import GameWorld

import ChConfig

import IpyGameDataPY

#import SkillBoosts

import SkillCommon

import BuffSkill

import SkillShell

@@ -43,7 +41,6 @@
import PetControl

import QuestCommon



#GameWorld.ImportAll("Script\\Skill\\", "SkillBoosts")

GameWorld.ImportAll("Script\\Skill\\", "PassiveBuff")





@@ -260,6 +257,10 @@
    

    GetPassiveEffManager().RegistPassiveBuff(curPlayer)



    # 助战神兽技能

    GetPassiveEffManager().RegistPassiveEffDogz(curPlayer)

    
    GetPassiveEffManager().RegistSuperEquipSkillDict(curPlayer)



#-被动逻辑处理--------------------------------------------------------------------------------------------------

##离开地图处理

@@ -276,6 +277,11 @@
def GetTriggerTypeByEffectID(effectID):

    # 临时配置

    tdict = {

             2102:ChConfig.TriggerType_BeAttackOver,   # 被攻击后触发 20

             2104:ChConfig.TriggerType_LockHP, # 锁血触发技能 63

             2105:ChConfig.TriggerType_BeLuckyHit, # 被会心一击触发技能 64

             2106:ChConfig.TriggerType_BeSuperHit,  # 被暴击触发技能

             
             4000:ChConfig.TriggerType_BuffState,   # 进入4012的某个状态触发技能 2

             4001:ChConfig.TriggerType_TagBuffState,   # 目标进入4012的某个状态触发技能 2

             4002:ChConfig.TriggerType_AddDamagePer,   # 提高增加伤害属性值，计算时 3

@@ -299,7 +305,7 @@
             4021:ChConfig.TriggerType_AddSingleSkillPer,   # 持续性攻击的单次攻击逐次增加技能伤害18,

             4022:ChConfig.TriggerType_SkillOverNoAttack,   # 技能释放后 与TriggerType_AttackOver相反19,

             4023:ChConfig.TriggerType_BeAttackOver,   # 被攻击后触发 20

             4024:ChConfig.TriggerType_AddIceAtkPer,    # 攻击附加真实伤害百分比 21

             #4024:ChConfig.TriggerType_AddIceAtkPer,    # 攻击附加真实伤害百分比 21

             4025:ChConfig.TriggerType_AddIceAtk,    # 攻击附加真实伤害固定值 22

             4026:ChConfig.TriggerType_DebuffOff,    # 抵消一次debuff 23

             4027:ChConfig.TriggerType_AttackKill,   # նɱ 24

@@ -326,8 +332,38 @@
             4048:ChConfig.TriggerType_MissSkill,   # 闪避后触发释放技能

             4049:ChConfig.TriggerType_MissSuccessPer, # 闪避成功率提升

             4050:ChConfig.TriggerType_OneDamage,   # 伤害降低到1点

             4051:ChConfig.TriggerType_LuckyHit, # 会心一击时增加会心伤害固定值 50

             4052:ChConfig.TriggerType_Buff_SuckBloodPer,   # 攻击 百分比吸血

             4053:ChConfig.TriggerType_AddLayer, # BUFF层级增加时 52

             4054:ChConfig.TriggerType_AttackAddSkillPer,  # 所有攻击伤害(SkillPer)增加，含普攻，计算时 5

             4055:ChConfig.TriggerType_StormAttackReduceCD, # 类剑刃风暴攻击后触发效果

             4056:ChConfig.TriggerType_PassiveBuffValue, ## 被动buff值计算中二次获取被动值 54

             4057:ChConfig.TriggerType_AttackKillHappen, ## 对被动技能斩杀的概率增强 55

             4058:ChConfig.TriggerType_AddBuffOver, # 添加buff之后触发技能 56

             4059:ChConfig.TriggerType_StormAttackOneByOne, # 类剑刃风暴攻击1对1触发技能  57

             4060:ChConfig.TriggerType_StormAttackOver, # 类剑刃风暴攻击后触发技能  57

             4061:ChConfig.TriggerType_AttackOverPassive,  # 攻击（对敌技能）后被动技能被触发在其他被动效果处理后调用，触发顺序原因

             4062:ChConfig.TriggerType_AttackAddFinalPer, # 增加最终伤害百分比 59

             4063:ChConfig.TriggerType_SummonDie,   #自身召唤兽死亡触发技能 60

             4064:ChConfig.TriggerType_GiftReduceCD, # 天赋减少CD9, #CD

             4065:ChConfig.TriggerType_DamageReducePVP,   # PVP减少伤害

             4066:ChConfig.TriggerType_AddDamagePer,   # 提高增加伤害属性值，计算时 3

             4067:ChConfig.TriggerType_ProDefValue, # 神兵护盾值下降时 62

             4068:ChConfig.TriggerType_LockHP, # 锁血触发技能 63

             4069:ChConfig.TriggerType_ZhongjiZhansha, # 终极斩杀 64

             4070:ChConfig.TriggerType_DebuffOff,    # 抵消一次debuff 23

             4071:ChConfig.TriggerType_Buff_SuckBloodPer,   # 攻击 百分比吸血

             4072:ChConfig.TriggerType_SuperHitSkipCD, # 暴击无冷却 68

             4073:ChConfig.TriggerType_BuffHurtCnt, # 当持续buff伤害第X次时触发技能 69

             4074:ChConfig.TriggerType_BounceHP,   # 反弹伤害固定值14, 记录值

             4075:ChConfig.TriggerType_4074PerValue,   # 增加4074的反弹比例

             4076:ChConfig.TriggerType_dFinalHurtReducePer, # 防守方的最终伤害减少百分比 71 
             4077:ChConfig.TriggerType_AttackAddFinalPer, # 增加最终伤害百分比 59

             4078:ChConfig.TriggerType_AttackOver,  # 攻击（对敌技能）后被动技能被触发 4

             4079:ChConfig.TriggerType_IsDealy,  # 是否触发致命一击 72

             4080:ChConfig.TriggerType_BounceHPPer, # 反弹伤害百分比值17,

             }

    return tdict.get(effectID, -1)

    return tdict.get(effectID, -1) 
    #===========================================================================

    # # 此表配置 影响类型

    # ipyData = IpyGameDataPY.GetIpyGameData('SkillEffect', effectID)

@@ -350,15 +386,27 @@
             4506:ChConfig.TriggerType_BeAttackOver, # BUFF类：被攻击触发技能  只刷新属性 不触发技能

             4507:ChConfig.TriggerType_Buff_AddSuperHitRate, # BUFF类:增加暴击率

             4508:ChConfig.TriggerType_Buff_AttackSubLayer,  # BUFF类：攻击减buff层，0消失

             4514:ChConfig.TriggerType_Buff_BeAttackSubLayer,  # BUFF类：被攻击减buff层，0消失

             4509:ChConfig.TriggerType_Buff_SuckBloodPer,   # BUFF类： 百分比吸血, 此处非属性类

             4510:ChConfig.TriggerType_Buff_MustBeHit,   # BUFF类： 无视闪避必中

             4511:ChConfig.TriggerType_AttackAddFinalValue,   #攻击增加输出伤害11

             4512:ChConfig.TriggerType_ReduceHurtHPPer, # 百分比减少攻击计算后伤害 

             4513:ChConfig.TriggerType_AttackAddFinalValue,   #攻击增加输出伤害11

             4515:ChConfig.TriggerType_AddIceAtkPer,    # BUFF类：攻击附加真实伤害百分比 
             4514:ChConfig.TriggerType_Buff_BeAttackSubLayer,  # BUFF类：被攻击减buff层，0消失

             #4515:ChConfig.TriggerType_AddIceAtkPer,    # BUFF类：攻击附加真实伤害百分比

             4516:ChConfig.TriggerType_ChangeHurtToHP,    # BUFF类：buff中把受到伤害的xx%转化为生命值

             4517:ChConfig.TriggerType_DebuffOff,   # BUFF类： 抵消debuff

             4518:ChConfig.TriggerType_ForbidenCure, # BUFF类： 禁止治疗 53

             4519:ChConfig.TriggerType_WillDead,   # BUFF类： 进入濒死状态 25

             4520:ChConfig.TriggerType_AddLayer, # BUFF类： 目标BUFF层级增加时 52

             4521:ChConfig.TriggerType_BeLuckyHitSubPer, # 减少受到的会心伤害 65

             4522:ChConfig.TriggerType_DebuffOff,   # BUFF类： 抵消debuff

             4523:ChConfig.TriggerType_SuperHitSkillPer, # 暴击时，增加技能伤害 10

             4524:ChConfig.TriggerType_SuperHitSubLayer, # 暴击减层 67

             4525:ChConfig.TriggerType_SuperHitSkipCD, # 暴击无冷却 68

             
             803:ChConfig.TriggerType_BloodShield,  # 血盾

             806:ChConfig.TriggerType_BloodShield,  # 血盾

             807:ChConfig.TriggerType_BloodShield,  # 血盾

             808:ChConfig.TriggerType_BloodShield,  # 血盾

             }

    return tdict.get(effectID, -1)

@@ -375,7 +423,9 @@
        self.AffectBuffDict = {}    # 当前正受影响的效果buff, key为触发点

        self.AffectSkillDict = {}    # 被动技能 {(触发模式， 被影响的技能ID):[被动技能ID，效果]

        self.AffectPassiveSkillSetDict = {}    # 被动技能装备 {(触发模式， 被影响的技能ID):[被动技能ID，效果]

    
        self.AffectDogzSkillDict = {}   # 神兽助战技能

        self.AffectSuperEquipSkillDict = {}   # 特殊装备持有技能，相同技能不重复，数值增长性衰减, 触发使用

        self.AffectSuperEquipEffectCntDict = {}  # 特殊装备技能效果对应的已计算后的数值，直接调用

    

    #记录会影响其他技能或者被动触发释放技能的BUFF

    def AddBuffInfoByEffect(self, effect, skillID):

@@ -430,6 +480,76 @@
        return self.AffectBuffDict.get((triggerType, 0), {})

     

    

    # 重刷神兽助战技能

    def RefreshDogzBattleSkill(self):

        self.AffectDogzSkillDict = {}

        skills = FindDogzBattleSkills(self.gameObj)

        
        for curSkill in skills:

            if not SkillCommon.isPassiveTriggerSkill(curSkill):

                continue

            
            skillTypeID = curSkill.GetSkillTypeID()

            
            connSkillID = SkillShell.GetConnectSkillID(curSkill)    # 关联技能ID, 0代表不限技能

            for i in xrange(curSkill.GetEffectCount()):

                curEffect = curSkill.GetEffect(i)

                effectID = curEffect.GetEffectID()

                if effectID == 0:

                    continue

                
                triggerType = GetTriggerTypeByEffectID(effectID)

                if triggerType == -1:

                    continue

                
                key = (triggerType,connSkillID)

                if key not in self.AffectDogzSkillDict:

                    self.AffectDogzSkillDict[key] = []

                    
                self.AffectDogzSkillDict[key].append((skillTypeID, effectID))

        
        return self.AffectDogzSkillDict

    
    
    # 重刷特殊装备技能

    def RefreshSuperEquipSkillDict(self):

        self.AffectSuperEquipSkillDict = {}

        self.AffectSuperEquipEffectCntDict = {}

        skillsDict = FindSuperEquipSkills(self.gameObj)

        
        for skillID, value in skillsDict.items():

            curSkill = GameWorld.GetGameData().GetSkillBySkillID(skillID)

            if not curSkill:

                continue

            if not SkillCommon.isPassiveTriggerSkill(curSkill):

                continue

            
            skillTypeID = curSkill.GetSkillTypeID()

            
            connSkillID = SkillShell.GetConnectSkillID(curSkill)    # 关联技能ID, 0代表不限技能

            for i in xrange(curSkill.GetEffectCount()):

                curEffect = curSkill.GetEffect(i)

                effectID = curEffect.GetEffectID()

                if effectID == 0:

                    continue

                
                triggerType = GetTriggerTypeByEffectID(effectID)

                if triggerType == -1:

                    continue

                
                key = (triggerType,connSkillID)

                if key not in self.AffectSuperEquipSkillDict:

                    self.AffectSuperEquipSkillDict[key] = []

                    
                self.AffectSuperEquipSkillDict[key].append((skillTypeID, effectID))

                # 效果叠加根据技能个数会衰减 = 1-pow((1-初始值),相同技能个数)

                self.AffectSuperEquipEffectCntDict[effectID] = 1 - pow((1 - curEffect.GetEffectValue(0)),value)

        
        GameWorld.DebugLog("RefreshSuperEquipSkillDict %s-%s"%(self.AffectSuperEquipSkillDict, self.AffectSuperEquipEffectCntDict))

        
        return self.AffectSuperEquipSkillDict

    
    
    # 重刷可装备的被动技能

    def RefreshPassiveSkillSet(self):

        self.AffectPassiveSkillSetDict = {}

@@ -474,8 +594,9 @@
            if not SkillCommon.isPassiveTriggerSkill(curSkill):

                continue

            

            if curSkill.GetFuncType() == ChConfig.Def_SkillFuncType_FbPassiveSkill:

                # 被动技能需装备

            if curSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_FbPassiveSkill,

                                          ChConfig.Def_SkillFuncType_Dogz]:

                # 被动技能和神兽需设置才有效

                continue

            

            skillTypeID = curSkill.GetSkillTypeID()

@@ -535,10 +656,14 @@
        ## skillList=self.AffectSkillDict.get((triggerType, connSkillID), [])再用extend会导致AffectSkillDict无限增长

        skillList.extend(self.AffectSkillDict.get((triggerType, connSkillID), []))

        skillList.extend(self.AffectPassiveSkillSetDict.get((triggerType, connSkillID), []))

        skillList.extend(self.AffectDogzSkillDict.get((triggerType, connSkillID), []))

        skillList.extend(self.AffectSuperEquipSkillDict.get((triggerType, connSkillID), []))

        
        if connSkillID != 0 and connSkillID != ChConfig.Def_SkillID_Somersault:

            skillList.extend(self.AffectSkillDict.get((triggerType, 0), []))

            skillList.extend(self.AffectPassiveSkillSetDict.get((triggerType, 0), []))

            
            skillList.extend(self.AffectDogzSkillDict.get((triggerType, 0), []))

            skillList.extend(self.AffectSuperEquipSkillDict.get((triggerType, 0), []))

        return skillList

        

#所有obj的被动效果管理

@@ -601,6 +726,35 @@
        return

        

        

    # 人物需同步注册神兽技能

    def RegistPassiveEffDogz(self, gameObj):

        passiveEff = self.GetPassiveEff(gameObj)

        if not passiveEff:

            # 强制刷新所有被动技能

            passiveEff = PassiveEff(gameObj)

            if not passiveEff.RefreshDogzBattleSkill():

                return

            self.AddPassiveEff(gameObj, passiveEff)

        else:

            passiveEff.RefreshDogzBattleSkill()

        return

        
        
        
    # 人物需同步注册装备技能，技能目前为可触发的被动类，若有定义冲突则可用功能类型划分

    def RegistSuperEquipSkillDict(self, gameObj):

        passiveEff = self.GetPassiveEff(gameObj)

        if not passiveEff:

            # 强制刷新所有被动技能

            passiveEff = PassiveEff(gameObj)

            if not passiveEff.RefreshSuperEquipSkillDict():

                return

            self.AddPassiveEff(gameObj, passiveEff)

        else:

            passiveEff.RefreshSuperEquipSkillDict()

        return

        
        
    def RegistPassiveBuff(self, gameObj):

        # buff # 筛选buffType 否则NPC没有此接口会报错

        for buffType in [IPY_GameWorld.bfBuff, IPY_GameWorld.bfDeBuff, IPY_GameWorld.bfProcessBuff

@@ -650,34 +804,6 @@
    return PyGameData.g_PassiveEffManager





## 当前释放技能 skillData

#def CalcBuffTriggerSkill(attacker, skillData, target, tick):

#    #===========================================================================

#    # passiveEff = GetPassiveEffManager().GetPassiveEff(attacker, False)

#    # if not passiveEff:

#    #    return

#    # #影响技能的BUFF

#    # buffTriggerSkillDict = passiveEff.GetBuffTriggerSkill(skillData.GetSkillID())

#    # if not buffTriggerSkillDict:

#    #    return

#    # 
#    # passiveEff.CalcBuffTriggerSkill(attacker, target, skillData, buffTriggerSkillDict, tick)

#    #===========================================================================

#    OnPassiveSkillTrigger(attacker, target, ChConfig.TriggerType_AttackOver, tick)



# 判断PK关系是否可攻击 Def_BattleRelationType_CommNoBoss也可攻击 只是攻击无效果

def CheckBattleRelationType(skillBattleType, battleRelationType):

    if skillBattleType in [ChConfig.Def_BattleRelationType_Comm, ChConfig.Def_BattleRelationType_CommNoBoss]:

        return True

    
    #if battleRelationType in [ChConfig.Def_BattleRelationType_Comm, ChConfig.Def_BattleRelationType_CommNoBoss]:

    #    return True

    
    if skillBattleType != battleRelationType:

        # PK模式的判定

        return False

    return True



# 查找被动技能时的对象

def GetPassiveDefender(attacker, defender):

    # 寻找被击者，1.目标排除是自己（后面逻辑会更换） 2. 查客户端伤害队列，3.查服务端伤害队列    

@@ -699,46 +825,66 @@
        return

    

    return GameWorld.GetObj(curHurt.GetObjID(), curHurt.GetObjType())

        


# 被动技能触发释放

def OnPassiveSkillTrigger(attacker, defender, connSkill, triggerType, tick, isEnhanceSkill=False, skillIDSet=None):

# 当前有效被动触发技能, 可用于基础使用判定   
def IsValidPassiveSkill(curSkill):

    validMap = SkillShell.GetAttrMapID(curSkill)

    if validMap and validMap != GameWorld.GetMap().GetMapID():

        # 有效地图可触发

        return False

    
    return True



# 多种被动技能优先触发释放一个，如被动 血量40%触发无敌技能，血量一定是停留在40%

# 先锁血，后触发技能 同 DelayUsePassiveTriggerSkill 使用

def OnPassiveSkillLockHP(attacker, defender, connSkill, triggerType, tick, isEnhanceSkill=False):

    attacker = FindRealAttacker(attacker)

    if not attacker:

        return False

        return 0, 0



    stopPassiveSkill = False   # 被动技能不能再触发被动技能，但可以触发天赋技能

    if connSkill:

        if not connSkill.GetFuncType():

            # 非功能类技能，避免死循环

            return False

            return 0, 0

        if SkillCommon.isPassiveSkill(connSkill):

            #GameWorld.DebugLog("被动技能不能再次触发被动技能")

            return False

            stopPassiveSkill = True

        

    if SkillCommon.GetUsingPassiveSkill(attacker) and triggerType != ChConfig.TriggerType_BuffState:

        # 防范被动技能触发的 非被动技能

        GameWorld.DebugLog("被动技能不能再次触发被动技能---%s"%triggerType)

        return

        stopPassiveSkill = True

    

    passiveEff = GetPassiveEffManager().GetPassiveEff(attacker)

    if not passiveEff:

        return False

    
        return 0, 0

        
    connSkillID = connSkill.GetSkillTypeID() if connSkill else 0

    skills = passiveEff.GetPassiveSkillsByTriggerType(triggerType, connSkillID)

    if not skills:

        return False

    
        return 0, 0

        
    defender = GetPassiveDefender(attacker, defender)



    # 当前战斗关系 pvp pve

    battleRelationType = AttackCommon.GetBattleRelationType(attacker, defender)

    #GameWorld.DebugLog("OnPassiveSkillTrigger-----------%s-%s"%(skills, battleRelationType))

    #GameWorld.DebugLog("OnPriorityPassiveSkillTrigger-----------%s-%s"%(skills, battleRelationType))

    
    lockHPPerMax = 0  ## 取有效的最高血量

    lockHPSkillID = 0

    for skillTypeID, effectID in skills:

        if connSkillID == skillTypeID:

            continue

        curSkill = attacker.GetSkillManager().FindSkillBySkillTypeID(skillTypeID)

        if not curSkill:

            continue



        if not IsValidPassiveSkill(curSkill):

            continue

        
        if stopPassiveSkill and curSkill.GetFuncType() != ChConfig.Def_SkillFuncType_GiftSkill:

            # 只有天赋才可以再次被触发

            continue 
        
        effect = SkillCommon.GetSkillEffectByEffectID(curSkill, effectID)

        if not effect:

            continue

@@ -747,7 +893,161 @@
            continue

        

        skillBattleType = SkillCommon.GetSkillBattleType(curSkill)

        if not CheckBattleRelationType(skillBattleType, battleRelationType):

        if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

            # PK模式的判定

            continue

        
        pyName = "PassiveSkill_%s" % effectID

        callFunc = GameWorld.GetExecFunc(PassiveBuff, "%s.%s" % (pyName, "CheckCanHappen"))

        if not callFunc:

            continue

        if not callFunc(attacker, defender, effect, curSkill):

            continue

        
        # 最终取最高值来决定当前生命值，卡血设定

        if effect.GetEffectValue(0) > lockHPPerMax:

            lockHPPerMax = effect.GetEffectValue(0)

            lockHPSkillID = skillTypeID

        
    return lockHPSkillID, lockHPPerMax





# 锁血功能的技能 含人物和宠物

def OnObjsPassiveSkillLockHP(attacker, defender, connSkill, triggerType, tick,):

    if attacker.GetGameObjType() != IPY_GameWorld.gotPlayer:

        return 0

    
    lockHPSkillID, lockHPPerMax = OnPassiveSkillLockHP(attacker, defender, connSkill, triggerType, tick)

    rolePet = attacker.GetPetMgr().GetFightPet()

    if rolePet:

        lockHPSkillIDPet, lockHPPerMaxPet = OnPassiveSkillLockHP(rolePet, defender, connSkill, triggerType, tick)

    
        if lockHPPerMax + lockHPPerMaxPet == 0:

            # 无触发

            return 0

        
        # 触发宠物技能标志

        if lockHPPerMaxPet > lockHPPerMax:

            rolePet.SetDict(ChConfig.Def_PlayerKey_LockHPSkillID, lockHPSkillIDPet)

            return lockHPPerMaxPet

    
    if lockHPPerMax == 0:

        return 0

    
    # 触发人物技能标志

    attacker.SetDict(ChConfig.Def_PlayerKey_LockHPSkillID, lockHPSkillID)

    return lockHPPerMax





# 从伤血延后到技能结束触发被动技能

def DelayUsePassiveTriggerSkill(attacker, curSkill, defender, tick):

    if attacker.GetGameObjType() != IPY_GameWorld.gotPlayer:

        return

    
    # 检查是宠物还是人物技能

    skillTypeID = attacker.GetDictByKey(ChConfig.Def_PlayerKey_LockHPSkillID)

    if not skillTypeID:

        rolePet = attacker.GetPetMgr().GetFightPet()

        if not rolePet:

            return

        skillTypeID = rolePet.GetDictByKey(ChConfig.Def_PlayerKey_LockHPSkillID)

        if not skillTypeID:

            return

        attacker = rolePet

        GameWorld.DebugLog("DelayUsePassiveTriggerSkill-----pet")

    
    # 一定要清标志

    attacker.SetDict(ChConfig.Def_PlayerKey_LockHPSkillID, 0)

    
    curSkill = attacker.GetSkillManager().FindSkillBySkillTypeID(skillTypeID)

    if not curSkill:

        return

    
    GameWorld.DebugLog("DelayUsePassiveTriggerSkill-----skillTypeID-%s"%skillTypeID)

    # 设置标志避免被动技能触发被动技能, 被动当中可能会触发多种类型技能，故不用isPassiveSkill做屏蔽

    SkillCommon.SetUsingPassiveSkill(attacker, 1)

    if not SkillShell.UsePassiveTriggerSkill(attacker, curSkill, defender, tick):

        # 不管技能是否是否成功都必须进入CD

        SkillCommon.SetSkillRemainTime(curSkill, PlayerControl.GetReduceSkillCDPer(attacker), tick, attacker)

        
    SkillCommon.SetUsingPassiveSkill(attacker, 0)

    return





# 灵宠部分技能需要通过主人触发，灵宠自己触发的逻辑依然走 OnPassiveSkillTrigger

def OnPetPassiveSkillTrigger(attacker, defender, connSkill, triggerType, tick):

    if attacker.GetGameObjType() != IPY_GameWorld.gotPlayer:

        return

    
    rolePet = attacker.GetPetMgr().GetFightPet()

    #无出战宠物

    if rolePet == None:

        return



    OnPassiveSkillTrigger(rolePet, defender, connSkill, triggerType, tick)





# 被动技能触发释放

def OnPassiveSkillTrigger(attacker, defender, connSkill, triggerType, tick, isEnhanceSkill=False, skillIDSet=None):

    attacker = FindRealAttacker(attacker)

    if not attacker:

        return False



    stopPassiveSkill = False   # 被动技能不能再触发被动技能，但可以触发天赋技能

    if connSkill:

        if not connSkill.GetFuncType():

            # 非功能类技能，避免死循环

            return False

        if SkillCommon.isPassiveSkill(connSkill):

            #GameWorld.DebugLog("被动技能不能再次触发被动技能")

            #return False

            stopPassiveSkill = True

        
    if SkillCommon.GetUsingPassiveSkill(attacker) and triggerType != ChConfig.TriggerType_BuffState:

        # 防范被动技能触发的 非被动技能

        #GameWorld.DebugLog("被动技能释放中不能再次触发被动技能---%s"%triggerType)

        #return 
        stopPassiveSkill = True

    
    passiveEff = GetPassiveEffManager().GetPassiveEff(attacker)

    if not passiveEff:

        return False

        
    connSkillID = connSkill.GetSkillTypeID() if connSkill else 0

    skills = passiveEff.GetPassiveSkillsByTriggerType(triggerType, connSkillID)

    if not skills:

        return False

        
    defender = GetPassiveDefender(attacker, defender)



    result = False

    # 当前战斗关系 pvp pve

    battleRelationType = AttackCommon.GetBattleRelationType(attacker, defender)

    #GameWorld.DebugLog("OnPassiveSkillTrigger-----------%s-%s"%(skills, battleRelationType))

    for skillTypeID, effectID in skills:

        if connSkillID == skillTypeID:

            continue

        curSkill = attacker.GetSkillManager().FindSkillBySkillTypeID(skillTypeID)

        if not curSkill:

            continue



        if not IsValidPassiveSkill(curSkill):

            continue

        
        if stopPassiveSkill and curSkill.GetFuncType() != ChConfig.Def_SkillFuncType_GiftSkill:

            # 只有天赋才可以再次被触发

            continue 
        
        effect = SkillCommon.GetSkillEffectByEffectID(curSkill, effectID)

        if not effect:

            continue



        if SkillCommon.RefreshSkillRemainTime(curSkill, tick):

            continue

        result = True   # 代表有效触发，但不关系触发结果

        
        skillBattleType = SkillCommon.GetSkillBattleType(curSkill)

        if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

            # PK模式的判定

            continue

        

@@ -763,8 +1063,14 @@
                curSkill.SetRemainTime(0)  # 一次攻击多次调用 ，在外层统一调用CD

                skillIDSet.add(skillTypeID)

        SkillCommon.SetUsingPassiveSkill(attacker, 0)

        
    return True

      
    # 代表有效触发，但不关系触发结果, 外层根据需求使用，如减少循环判断  
    return result





#ntSummon：（3）普通召唤兽，可继承主人基础属性如攻击 
#ntElf：（4）玩家替身，完全拥有玩家属性和被动功能

#ntFairy ：（7）同ntSummon，但技能可触发被动功能



# ntElf 定义为人物使用对地持续性技能，并且人物可以移动，则需要ntElf做依托物的情况

# 那么ntElf执行人物的伤害计算和被动触发效果

@@ -775,7 +1081,7 @@
        return attacker

    

    npcType = attacker.GetType()

    if npcType not in [IPY_GameWorld.ntPet, IPY_GameWorld.ntElf]:

    if npcType not in [IPY_GameWorld.ntPet, IPY_GameWorld.ntElf, IPY_GameWorld.ntFairy]:

        if attacker.GetIsBoss():

            return attacker

        return

@@ -784,7 +1090,7 @@
        # --宠物

        return attacker

    

    if npcType == IPY_GameWorld.ntElf:

    else:

        # ntElf 定义为人物使用对地持续性技能，并且人物可以移动，则需要ntElf做依托物的情况

        # 那么ntElf执行人物的伤害计算和被动触发效果

        attacker = NPCCommon.GetSummonNPCOwner(IPY_GameWorld.gotPlayer, attacker)

@@ -798,9 +1104,12 @@
    if not attacker:

        return 0

    

    stopPassiveSkill = False   # 被动技能不能再触发被动技能，但可以触发天赋技能

    if connSkill and SkillCommon.isPassiveSkill(connSkill):

        #GameWorld.DebugLog("被动技能不能再次触发被动技能")

        return 0

        #return 0

        stopPassiveSkill = True

        
    passiveEff = GetPassiveEffManager().GetPassiveEff(attacker)

    if not passiveEff:

        return 0

@@ -815,9 +1124,19 @@
    curValue = 0



    for skillTypeID, effectID in skills:

        if connSkillID == skillTypeID:

            continue

        curSkill = attacker.GetSkillManager().FindSkillBySkillTypeID(skillTypeID)

        if not curSkill:

            continue

        
        if not IsValidPassiveSkill(curSkill):

            continue

        
        if stopPassiveSkill and curSkill.GetFuncType() != ChConfig.Def_SkillFuncType_GiftSkill:

            # 只有天赋才可以再次被触发

            continue 
        
        if curSkill.GetCoolDownTime() and SkillCommon.RefreshSkillRemainTime(curSkill, tick):

            #有配置CD的才判断

            continue

@@ -826,11 +1145,11 @@
        if not effect:

            continue

        skillBattleType = SkillCommon.GetSkillBattleType(curSkill)

        if not CheckBattleRelationType(skillBattleType, battleRelationType):

        if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

            continue

        

        pyName = "PassiveSkill_%s" % effectID

        


        callFunc = GameWorld.GetExecFunc(PassiveBuff, "%s.%s" % (pyName, "CheckCanHappen"))

        

        # 条件不满足

@@ -869,17 +1188,22 @@
    #tick = GameWorld.GetGameWorld().GetTick()

    skillList = []

    for skillTypeID, effectID in skills:

        if connSkillID == skillTypeID:

            continue

        curSkill = attacker.GetSkillManager().FindSkillBySkillTypeID(skillTypeID)

        #if SkillCommon.RefreshSkillRemainTime(curSkill, tick):

        #    continue

        if not curSkill:

            continue

        

        if not IsValidPassiveSkill(curSkill):

            continue



        effect = SkillCommon.GetSkillEffectByEffectID(curSkill, effectID)

        if not effect:

            continue

        skillBattleType = SkillCommon.GetSkillBattleType(curSkill)

        if not CheckBattleRelationType(skillBattleType, battleRelationType):

        if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

            continue

        

        pyName = "PassiveSkill_%s" % effectID

@@ -914,8 +1238,13 @@
    battleRelationType = AttackCommon.GetBattleRelationType(attacker, defender)

    

    for skillTypeID, effectID in skills:

        if connSkillID == skillTypeID:

            continue

        curSkill = attacker.GetSkillManager().FindSkillBySkillTypeID(skillTypeID)

        if not curSkill:

            continue

        
        if not IsValidPassiveSkill(curSkill):

            continue

        

        effect = SkillCommon.GetSkillEffectByEffectID(curSkill, effectID)

@@ -924,7 +1253,7 @@
        if SkillCommon.RefreshSkillRemainTime(curSkill, tick):

            continue

        skillBattleType = SkillCommon.GetSkillBattleType(curSkill)

        if not CheckBattleRelationType(skillBattleType, battleRelationType):

        if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

            # PK模式的判定

            continue

            

@@ -942,42 +1271,37 @@
    return False







#------------------------Buff类 被动触发, 并非全是被动技能-----------------------------------------------



#buff类触发释放技能，无CD验证

def OnPassiveBuffTrigger(attacker, defender, useSkill, triggerType, tick):

# 被动技能触发但无需释放，如抵消debuff，只需走CD即可

def OnPassiveBuffHappen(attacker, defender, tagSkill, triggerType, tick):

    attacker = FindRealAttacker(attacker)

    if not attacker:

        return

    if useSkill:

        if not useSkill.GetFuncType():

            # 非功能类技能，避免死循环

            return

        if SkillCommon.isPassiveSkill(useSkill):

            #GameWorld.DebugLog("被动技能不能再次触发被动技能")

            return

        
    if SkillCommon.GetUsingPassiveSkill(attacker):

        # 防范被动技能触发的 非被动技能

        GameWorld.DebugLog("被动技能不能再次触发被动技能---%s"%triggerType)

        return

        
        
        return False



    passiveEff = GetPassiveEffManager().GetPassiveEff(attacker)

    if not passiveEff:

        return

    
        return False

    buffDict = passiveEff.GetBuffsByTriggerType(triggerType)

    if not buffDict:

        return

        return False

    

    defender = GetPassiveDefender(attacker, defender)

        
    # 当前战斗关系 pvp pve

    battleRelationType = AttackCommon.GetBattleRelationType(attacker, defender)

    skillBattleType = SkillCommon.GetSkillBattleType(tagSkill)

    if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

        return



    tagSkillID = tagSkill.GetSkillID() if tagSkill else 0

    

    for skillID, effectList in buffDict.items():

        if tagSkillID == skillID:

            continue

        
        curSkill = GameWorld.GetGameData().GetSkillBySkillID(skillID)

        if not curSkill:

            continue

        
        if not IsValidPassiveSkill(curSkill):

            continue

        for passiveEffect in effectList:

            # 被动触发的技能

            pyName = "PassiveBuff_%s"%passiveEffect.GetEffectID()

@@ -986,7 +1310,75 @@
            if not callFunc:

                continue

            

            if not callFunc(attacker, defender, passiveEffect, skillID):

            if not callFunc(attacker, defender, passiveEffect, tagSkill):

                continue

            
            callFunc = GameWorld.GetExecFunc(PassiveBuff, "%s.%s" % (pyName, "DoLogic"))

            if callFunc:

                callFunc(attacker, defender, passiveEffect, tagSkill, skillID)



            return True

        
    return False

#------------------------Buff类 被动触发, 并非全是被动技能-----------------------------------------------



#buff类触发释放技能，无CD验证

def OnPassiveBuffTrigger(attacker, defender, useSkill, triggerType, tick):

    attacker = FindRealAttacker(attacker)

    if not attacker:

        return



    stopPassiveSkill = False   # 被动技能不能再触发被动技能，但可以触发天赋技能

    if useSkill:

        if not useSkill.GetFuncType():

            # 非功能类技能，避免死循环

            return

        if SkillCommon.isPassiveSkill(useSkill):

            #GameWorld.DebugLog("被动技能不能再次触发被动技能")

            #return

            stopPassiveSkill = True

        
    if SkillCommon.GetUsingPassiveSkill(attacker):

        # 防范被动技能触发的 非被动技能

        #GameWorld.DebugLog("被动技能不能再次触发被动技能---%s"%triggerType)

        #return

        stopPassiveSkill = True

        
    passiveEff = GetPassiveEffManager().GetPassiveEff(attacker)

    if not passiveEff:

        return

    
    buffDict = passiveEff.GetBuffsByTriggerType(triggerType)

    if not buffDict:

        return



    defender = GetPassiveDefender(attacker, defender)

        
    # 当前战斗关系 pvp pve

    battleRelationType = AttackCommon.GetBattleRelationType(attacker, defender)

    useSkillID = useSkill.GetSkillID() if useSkill else 0



    for skillID, effectList in buffDict.items():

        if skillID == useSkillID:

            continue

        curSkill = GameWorld.GetGameData().GetSkillBySkillID(skillID)

        if not curSkill:

            continue

        
        if stopPassiveSkill and curSkill.GetFuncType() != ChConfig.Def_SkillFuncType_GiftSkill:

            # 只有天赋才可以再次被触发

            continue 
        
        if not IsValidPassiveSkill(curSkill):

            continue

        for passiveEffect in effectList:

            # 被动触发的技能

            pyName = "PassiveBuff_%s"%passiveEffect.GetEffectID()

            callFunc = GameWorld.GetExecFunc(PassiveBuff, "%s.%s" % (pyName, "CheckCanHappen"))

            if not callFunc:

                continue

            
            if not callFunc(attacker, defender, passiveEffect, skillID, useSkill=useSkill):

                continue

            

            callFunc = GameWorld.GetExecFunc(PassiveBuff, "%s.%s" % (pyName, "GetSkillData"))

@@ -998,7 +1390,7 @@
                continue



            skillBattleType = SkillCommon.GetSkillBattleType(skillData)

            if not CheckBattleRelationType(skillBattleType, battleRelationType):

            if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

                # PK模式的判定

                continue

            

@@ -1021,9 +1413,13 @@
    attacker = FindRealAttacker(attacker)

    if not attacker:

        return 0

    
    stopPassiveSkill = False   # 被动技能不能再触发被动技能，但可以触发天赋技能

    if useSkill and SkillCommon.isPassiveSkill(useSkill):

        #GameWorld.DebugLog("被动技能不能再次触发被动技能")

        return 0

        #return 0

        stopPassiveSkill = True





    passiveEff = GetPassiveEffManager().GetPassiveEff(attacker)

    if not passiveEff:

@@ -1035,14 +1431,28 @@
    # 当前战斗关系 pvp pve

    battleRelationType = AttackCommon.GetBattleRelationType(attacker, defender)

    skillBattleType = SkillCommon.GetSkillBattleType(useSkill)

    if not CheckBattleRelationType(skillBattleType, battleRelationType):

    if not AttackCommon.CheckBattleRelationType(skillBattleType, battleRelationType):

        return 0

            
    
    useSkillID = useSkill.GetSkillID() if useSkill else 0

    #tick = GameWorld.GetGameWorld().GetTick()

    curValue = 0



    
    for skillID, effectList in buffDict.items():

        if skillID == useSkillID:

            continue

        curSkill = GameWorld.GetGameData().GetSkillBySkillID(skillID)

        if not curSkill:

            continue

        
        if not IsValidPassiveSkill(curSkill):

            continue

        
        for passiveEffect in effectList:

            if stopPassiveSkill and curSkill.GetFuncType() != ChConfig.Def_SkillFuncType_GiftSkill:

                # 只有天赋才可以再次被触发

                continue 
            
            # 被动触发的技能

            pyName = "PassiveBuff_%s"%passiveEffect.GetEffectID()

            

@@ -1050,18 +1460,108 @@
            if not callFunc:

                continue

            

            if not callFunc:

                continue

            
            # 条件不满足

            if not callFunc(attacker, defender, passiveEffect, skillID):

            if not callFunc(attacker, defender, passiveEffect, skillID, useSkill=useSkill):

                continue

            

            callFunc = GameWorld.GetExecFunc(PassiveBuff, "%s.%s" % (pyName, "GetValue"))

            if callFunc is None:

                continue

            

            # 如被动技能：千幻冥炎真实伤害从2变4倍

            curValue += GetPassiveSkillValueByTriggerType(attacker, defender, curSkill, ChConfig.TriggerType_PassiveBuffValue)

            curValue += callFunc(attacker, defender, passiveEffect)

            

    return curValue





# 因为要兼容低等级技能，所以技能只能是在助战的时候，先删除神兽技能再学习新的助战神兽技能

def PlayerDogzSkill(curPlayer):



    dogzSkills = [] # 需要学习的技能

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    for i in xrange(ipyDataMgr.GetDogzCount()):

        ipyData = ipyDataMgr.GetDogzByIndex(i)

        if not GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_DogzFightState, i):

            continue

        
        dogzSkills.extend(ipyData.GetHelpBattleSkills())

    
    delDogzSkills = [] # 删除不在助战神兽队列的技能

    skillManager = curPlayer.GetSkillManager()

    for i in xrange(skillManager.GetSkillCount()):

        curSkill = skillManager.GetSkillByIndex(i)

        if curSkill.GetFuncType() != ChConfig.Def_SkillFuncType_Dogz:

            continue

        skillID = curSkill.GetSkillID()

        
        delDogzSkills.append(skillID)

        
    GameWorld.DebugLog("PlayerDogzSkill:%s - 删除%s"%(dogzSkills, delDogzSkills))

    
    # 删除神兽技能

    for skillID in delDogzSkills:

        skillManager.DeleteSkillBySkillID(skillID, False)

    
    # 添加助战技能，同类技能取最高

    dogzSkills.sort()

    for skillID in dogzSkills:

        skillData = GameWorld.GetGameData().GetSkillBySkillID(skillID)

        if not skillData:

            continue

        if skillData.GetSkillType() == ChConfig.Def_SkillType_AttrSkillNoLearn:

            # 同技能可多个叠加的技能不能学，算属性时直接取表

            continue

        
        skillManager.LearnSkillByID(skillID, False)

    
    # 刷被动效果

    GetPassiveEffManager().RegistPassiveEffDogz(curPlayer)

    return





# 获取助战神兽的技能列表

def FindDogzBattleSkills(gameObj):

    skills = []

    if gameObj.GetGameObjType() != IPY_GameWorld.gotPlayer:

        return skills

    
    skillManager = gameObj.GetSkillManager()

    for i in xrange(skillManager.GetSkillCount()):

        curSkill = skillManager.GetSkillByIndex(i)

        if not curSkill:

            continue

        
        if curSkill.GetFuncType() != ChConfig.Def_SkillFuncType_Dogz:

            continue

        skills.append(curSkill)

        
    return skills





# 遍历身上装备技能以及各自个数，装备技能不需要学习

# 保证不同的装备技能不会有相同的效果， 效果数值的衰减是根据相同技能个数计算而不是效果个数 1-pow((1-初始值),相同技能个数)

def FindSuperEquipSkills(gameObj):

    skillsDict = {}

    if gameObj.GetGameObjType() != IPY_GameWorld.gotPlayer:

        return skillsDict

    
    equipPack = gameObj.GetItemManager().GetPack(IPY_GameWorld.rptEquip)

    for i in xrange(equipPack.GetCount()):

        curEquip = equipPack.GetAt(i)

        
        if not curEquip or curEquip.IsEmpty():

            continue

        
        if curEquip.GetAddSkill(0) == 0:

            #无技能

            continue

        
        for j in xrange(curEquip.GetAddSkillCount()):

            skillID = curEquip.GetAddSkill(j)

            if skillID == 0:

                break

            
            skillsDict[skillID] = skillsDict.get(skillID, 0) + 1  
            
    return skillsDict