#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Skill.TurnSkill
#
# @todo:»ØºÏÕ½¶·¼¼ÄÜ
# @author hxp
# @date 2025-08-06
# @version 1.0
#
# ÏêϸÃèÊö: »ØºÏÕ½¶·¼¼ÄÜ
#
#-------------------------------------------------------------------------------
#"""Version = 2025-08-06 18:30"""
#-------------------------------------------------------------------------------

import ChConfig
import GameWorld
import BattleObj
import SkillCommon
import IpyGameDataPY
import IPY_GameWorld
import ChPyNetSendPack
import PlayerControl
import ShareDefine
import TurnPassive
import TurnAttack
import TurnBuff
import ObjPool
import FBLogic

import random

def GetPMType(batObj, useSkill):
    ## »ñÈ¡Îï·¨É˺¦ÀàÐÍ
    # GetHurtType ¸öλÊýÓ÷¨¸Ä³É pvp pve±êʶ£¬Ê®Î»Êý-Îï¹¥·¨¹¥ IPY_GameWorld.ghtPhy = 1
    #---¼¼Äܹ¥»÷, ¶Á±í»ñÈ¡¹¥»÷ÀàÐÍ---
    ght = useSkill.GetHurtType() % 10
    if ght == IPY_GameWorld.ghtMag: # ×öÅäÖüæÈÝÓã¬ÓÅÏÈÑéÖ¤·¨ÉË£¬·ñÔòĬÈÏÎïÉË
        return IPY_GameWorld.ghtMag
    return IPY_GameWorld.ghtPhy

def IsIgnoreDef(useSkill):
    ## ÊÇ·ñÎÞÊÓ·ÀÓù
    return useSkill.GetHurtType() / 10 == 1 # 2ΪÕæÉË£¬´ýÀ©Õ¹

def OnUseSkill(turnFight, curBatObj, useSkill, tagObjList=None, batType=ChConfig.TurnBattleType_Normal, bySkill=None, byBuff=None, comboLimit=False, atkBackTag=None):
    '''ʹÓü¼ÄÜͨÓÃÈë¿Ú
    @param useSkill: ʹÓõļ¼ÄÜ£¬×¢Òâ²¢²»Ò»¶¨ÊÇÉíÉϵļ¼ÄÜ£¬¿ÉÄÜÖ»ÊÇ SkillData ±íÊý¾Ý
    @param bySkill: ÓÉÄĸö¼¼ÄܶîÍâ´¥·¢µÄ£¬±ÈÈ總¼Ó´¥·¢µÄ¼¼ÄÜ»ò±»¶¯¼¼Äܾù¿ÉÄÜÓÉij¸ö¼¼ÄÜ´¥·¢
    @param comboLimit: ÊÇ·ñÇ¿ÖÆÏÞÖÆÁ¬»÷
    @param atkBackTag: ·´»÷Ä¿±ê
    @return: ÊÇ·ñ³É¹¦
    '''
    if not useSkill:
        return
    
    skillID = useSkill.GetSkillID()
    if not skillID:
        return
    
    if not curBatObj.IsAlive():
        return
    
    objID = curBatObj.GetID()
    
    if hasattr(useSkill, "GetRemainTime") and useSkill.GetRemainTime() > 0:
        GameWorld.DebugLog("¼¼ÄÜCDÖÐ! skillID=%s,RemainTime=%s" % (skillID, useSkill.GetRemainTime()))
        return
    
    buffStateGroups = useSkill.GetBuffStateLimit()
    if buffStateGroups:
        limitState = curBatObj.IsInBuffStateGroup(buffStateGroups)
        if limitState:
            GameWorld.DebugLog("¼¼ÄÜʹÓô¦ÓÚbuff״̬ÏÞÖÆÖÐ! skillID=%s,buffStateGroups=%s,limitState=%s" % (skillID, buffStateGroups, limitState))
            return
        
    if CheckSkillUseCntLimit(curBatObj, useSkill):
        return
    
    #ûÓÐÖ¸¶¨Ä¿±ê£¬Ôò°´¼¼ÄÜ×ÔÉíµÄÄ¿±êÂß¼­
    if not tagObjList:
        tagObjList = GetSkillTags(turnFight, curBatObj, useSkill, atkBackTag)
        rate = useSkill.GetHappenRate()
        if rate:
            rate += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddSkillRate, useSkill)
            for tagObj in tagObjList[::-1]:
                if not GameWorld.CanHappen(rate, ChConfig.Def_MaxRateValue):
                    tagObjList.remove(tagObj)
                    
    if not tagObjList:
        # ¿ÉÀ©Õ¹ÆäËûÄ¿±êÑ¡Ôñ£¬È縴»î¼¼ÄÜûÓÐËÀÍöµ¥Î»Ê±ÔòʹÓÃÁíÍâµÄЧ¹û
        GameWorld.DebugLog("ÕÒ²»µ½¼¼ÄÜÄ¿±ê! skillID=%s,mapID=%s,funcLineID=%s" % (skillID, turnFight.mapID, turnFight.funcLineID), turnFight.playerID)
        return
    
    oneActionUseCnt = turnFight.GetOneActionUseSkillCnt(objID)
    if oneActionUseCnt >= 20:
        GameWorld.ErrLog("µ¥´ÎÐж¯ÀÛ¼ÆʹÓü¼ÄÜ´ïµ½ÉÏÏÞ! objID=%s,oneActionUseCnt=%s" % (objID, oneActionUseCnt), turnFight.playerID)
        return
    oneActionUseCnt = turnFight.SetOneActionUseSkillCnt(objID, oneActionUseCnt + 1)
    
    bySkillID = bySkill.GetSkillID() if bySkill else 0
    GameWorld.DebugLog("¡ôʹÓü¼ÄÜ: curID=%s,skillID=%s,tagCnt=%s,batType=%s,bySkillID=%s,HP:%s/%s,oneActionUseCnt=%s" 
                       % (objID, skillID, len(tagObjList), batType, bySkillID, curBatObj.GetHP(), curBatObj.GetMaxHP(), oneActionUseCnt))
    # ÒÔÏÂΪ¼¼ÄÜ¿ÉÒÔʹÓõĴ¦Àí£¬Ö®ºóµÄÂß¼­Ä¬Èϼ¼ÄÜʹÓóɹ¦
    
    poolMgr = ObjPool.GetPoolMgr()
    usePoolSkill = False
    if isinstance(useSkill, IpyGameDataPY.IPY_Skill):
        usePoolSkill = True
        # ͳһʹÓà BattleObj.PySkill
        useSkill = poolMgr.acquire(BattleObj.PySkill, useSkill, objID)
        
    useSkill.ResetUseRec()
    useSkill.SetTagObjList(tagObjList)
    useSkill.SetBatType(batType)
    useSkill.SetBySkill(bySkill)
    useSkill.SetByBuff(byBuff)
    
    isTurnNormalSkill = SkillCommon.isTurnNormalSkill(useSkill)
    if isTurnNormalSkill:
        # ÆÕ¹¥×·»÷ʱǿÖÆÖØпªÊ¼ËãÁ¬»÷
        useSkill.ComboCheckStart(batType == ChConfig.TurnBattleType_Pursue)
        
    curBatObj.ClearSkillTempAttr()
    tagIDList = []
    for tagObj in tagObjList:
        tagIDList.append(tagObj.GetID())
        tagObj.ClearSkillTempAttr()
        
    # Óй¦ÄÜ·ÖÀàµÄ¼¼Äܶ¼ÈÏΪÊÇÖ÷¼¼ÄÜ
    if useSkill.GetFuncType():
        curBatObj.SetMainTagIDList(tagIDList)
        
    useTag = ""
    if IsNeedSyncSkill(useSkill):
        # ÒòΪ¿ÉÄÜ´¥·¢Á¬»÷£¬ËùÒÔ±ê¼ÇÐè´øÉÏÀÛ¼ÆʹÓü¼ÄÜ´ÎÊý£¬È·±£Î¨Ò»
        useTag = "Skill_%s_%s_%s" % (objID, skillID, curBatObj.GetSkillUseCnt(skillID) + 1)
        Sync_TurnFightTag(turnFight, useTag, 0)
        
    #Õâ¸ö¼¼ÄÜÊÇBuff
    if SkillCommon.IsBuff(useSkill):
        __doAddBuff(turnFight, curBatObj, useSkill)
    else:
        __doUseSkill(turnFight, curBatObj, useSkill)
        
    DoAttackResult(turnFight, curBatObj, useSkill)
    
    if useTag:
        Sync_TurnFightTag(turnFight, useTag, 1)
        
    # ´¦Àí·´»÷ »ò Á¬»÷
    if isTurnNormalSkill:
        if comboLimit or not DoCombo(turnFight, curBatObj, useSkill):
            useSkill.ComboInterrupt()
            
    # ×îºóÖØÖᢻØÊÕ¶ÔÏó
    useSkill.ResetUseRec()
    if usePoolSkill:
        poolMgr.release(useSkill)
    return True

def CheckSkillUseCntLimit(batObj, useSkill):
    ## ¼ì²é¼¼ÄÜʹÓôÎÊýÊÇ·ñÊÜÏÞ
    # @return: ÊÇ·ñÊÜÏÞ
    if not hasattr(useSkill, "GetEffectByID"):
        return
    effect = useSkill.GetEffectByID(ChConfig.SkillEff_SkillUseCntLimit)
    if not effect:
        return
    useCntLimit = effect.GetEffectValue(0) # ÿ³¡Õ½¶·×î´ó´ÎÊý£¬0²»ÏÞ
    turnUseCntLimit = effect.GetEffectValue(1) # ÿ´ó»ØºÏ×î´ó´ÎÊý£¬0²»ÏÞ
    
    skillID = useSkill.GetSkillID()
    if useCntLimit:
        useCnt = batObj.GetSkillUseCnt(skillID)
        if useCnt >= useCntLimit:
            GameWorld.DebugLog("¼¼ÄÜÿ³¡Õ½¶·Ê¹ÓôÎÊýÊÜÏÞ! skillID=%s,useCnt=%s >= %s" % (skillID, useCnt, useCntLimit))
            return True
        
    if turnUseCntLimit:
        turnUseCnt = batObj.GetSkillTurnUseCnt(skillID)
        if turnUseCnt >= turnUseCntLimit:
            GameWorld.DebugLog("¼¼ÄÜÿ´ó»ØºÏʹÓôÎÊýÊÜÏÞ! skillID=%s,turnUseCnt=%s >= %s" % (skillID, turnUseCnt, turnUseCntLimit))
            return True
        
    return

def IsNeedSyncSkill(useSkill):
    ## ʹÓÃÐèҪͬ²½B427ʹÓü¼ÄÜ
    if useSkill.GetSkillType() in [ChConfig.Def_SkillType_Atk, ChConfig.Def_SkillType_Cure, ChConfig.Def_SkillType_CleanBuff]:
        return True
    if useSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_TurnNormaSkill, ChConfig.Def_SkillFuncType_AngerSkill]:
        return True
    return False

def GetSkillTags(turnFight, curBatObj, useSkill, atkBackTag=None):
    ## »ñÈ¡¼¼ÄÜÄ¿±ê
    # @return: [Ö÷Ä¿±ê, Ä¿±ê2, ...]
    
    tagAim = useSkill.GetTagAim()
    tagFriendly = useSkill.GetTagFriendly()
    tagAffect = useSkill.GetTagAffect()
    tagCount = useSkill.GetTagCount()
    
    lineupNumSet = None
    changeRet = CheckChangeTagEff(turnFight, curBatObj, useSkill)
    if changeRet:
        lineupNumSet, changeTagSet = changeRet
        GameWorld.DebugLog("Ç¿ÖÆÐ޸ļ¼ÄÜÄ¿±ê: lineupNumSet=%s, changeTagSet=%s" % (lineupNumSet, changeTagSet))
        tagAim, tagFriendly, tagAffect, tagCount = changeTagSet
        
    # ×Ô¼º£¬Ö±½Ó·µ»Ø
    if tagAim == ChConfig.SkillTagAim_Self:
        return [curBatObj]
    
    tagCount += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddSkillTagCnt, useSkill)
    #GameWorld.DebugLog("ËÑË÷¼¼ÄÜÄ¿±ê: skillID=%s,tagAim=%s,tagFriendly=%s,tagAffect=%s,tagCount=%s" % (useSkill.GetSkillID(), tagAim, tagFriendly, tagAffect, tagCount))
    
    # Ä¿±êÑ¡ÔñÓÅÏȼ¶£¬¼¯»ð > changeRet > ÷È»ó > »ìÂÒ > ³°·í > ·´»÷ > ³£¹æ
    # ¼¯»ð£ºÖ±½Óͨ¹ýЧ¹û5015Ö¸¶¨ÁËÄ¿±ê£¬²»»á×ßµ½ÕâÀËùÒÔÕâÀï¿É²»´¦Àí
    # ÷È»ó: µÐÓÑ»¥»»; Ö±½Ó¹¥»÷¼¼Äܲ»°üº¬×Ô¼º£¬Ö»Ê£×Ô¼º»¥»»ºóÊǼº·½Ê±²»Êͷż¼ÄÜ
    # »ìÂÒ: Ëæ»úµÐÓÑ; Ö±½Ó¹¥»÷¼¼Äܲ»°üº¬×Ô¼º£¬Ö»Ê£×Ô¼º»¥»»ºóÊǼº·½Ê±²»Êͷż¼ÄÜ
    # ³°·í: Ä¿±êÊǵз½Ê±Ç¿ÖÆÄ¿±êÒ»¶¨°üº¬Ê©·¨Õß
    # ·´»÷: Ð޸ļ¼ÄÜ×ݺáΪ·´»÷Ä¿±êËùÔÚ×ݺáÇÒΪÖ÷Ä¿±ê£¨ÓÅÏȼ¶µÍÓÚÈí¿Ø¡¢Ö¸¶¨buff״̬Ŀ±ê£¬¸ßÓÚÊôÐÔÌõ¼þÄ¿±ê£©
    
    # È·ÈϵÐÓÑ
    inCharm, inChaos = False, False # ÊÇ·ñ÷È»óÖÐ, ÊÇ·ñ»ìÂÒÖÐ
    if changeRet:
        pass
    elif curBatObj.CheckInState(ChConfig.BatObjState_Charm):
        inCharm = True
        tagFriendly = 0 if tagFriendly else 1 # ÷È»ó: µÐÓÑ»¥»»
    elif curBatObj.CheckInState(ChConfig.BatObjState_Chaos):
        inChaos = True
        tagFriendly = random.randint(0, 1) # »ìÂÒ: Ëæ»úµÐÓÑ
    #GameWorld.DebugLog("inCharm=%s,inChaos=%s,tagFriendly=%s" % (inCharm, inChaos, tagFriendly))
    isNoSelf = False # ÊÇ·ñ²»°üº¬×Ô¼º
    if inCharm or inChaos:
        if SkillCommon.isAttackDirectSkill(useSkill):
            isNoSelf = True
            #GameWorld.DebugLog("ÌØÊâ²»°üº¬×Ô¼º")
            
    # ¸ù¾ÝµÐÓѹØϵȷ¶¨ÕóÓª¼°Ò»Ð©µÐÓѹØϵµÄÌØÊâÂß¼­
    sneerObjFirst = True # ³°·íÄ¿±êÊÇ·ñÓÅÏÈ
    sneerTagObj = None # ³°·íÄ¿±ê
    atkBackTagFrist = True # ·´»÷Ä¿±êÊÇ·ñÓÅÏÈ
    specMainObj = None # ÌØÊâÖ÷Ä¿±ê£¬Ä¿Ç°½öµÐ¶Ô¹ØϵÓÐЧ£¬Èç³°·í¡¢·´»÷µÈÓÅÏÈÉ趨ΪÖ÷Ä¿±ê£¬¿É¼æÈÝ÷Ȼ󡢻ìÂÒ
    specObjID, specObjPosNum, sepcObjLineupNum = 0, 0, 0
    curFaction = curBatObj.GetFaction()
    if tagFriendly:
        tagFaction = curFaction
        sneerTagObj = None
        atkBackTag = None
    else:
        tagFaction = ChConfig.Def_FactionB if curFaction == ChConfig.Def_FactionA else ChConfig.Def_FactionA
        sneerTagObj = curBatObj.GetSneerTagObj() # ±»³°·íµÄÄ¿±ê£¬¶ÔµÐµÄÇ¿ÖÆËø¶¨±»³°·íÄ¿±ê
        if sneerTagObj:
            specMainObj = sneerTagObj
            #GameWorld.DebugLog("³°·íÌØÊâÖ÷Ä¿±ê")
        elif atkBackTag:
            specMainObj = atkBackTag
            #GameWorld.DebugLog("·´»÷ÌØÊâÖ÷Ä¿±ê")
            
    if specMainObj:
        specObjID = specMainObj.GetID()
        specObjPosNum = specMainObj.GetPosNum()
        sepcObjLineupNum = specMainObj.GetLineupNum()
        
    batObjMgr = BattleObj.GetBatObjMgr()
    lineupNum = curBatObj.GetLineupNum()
    posNum = curBatObj.GetPosNum()
    
    # È·ÈÏÕóÈݱàºÅ˳Ðò£¬¶àV¶àʱÓÐÓÃ
    batFaction = turnFight.getBatFaction(tagFaction)
    if lineupNumSet != None and not tagFriendly:
        lineupNumList = [lineupNumSet] # ÒѾ­ÓÐÖ¸¶¨µÐ·½µÄijһÕóÈÝ
    elif tagFaction == curFaction:
        lineupNumList = [lineupNum] # ÓÑ·½ÔÝʱ½öÏÞÖÆ×Ô¼ºÕóÈÝ
    else:
        # µÐ·½ÓÅÏÈ: ÌØÊâÄ¿±êÕóÈÝ > ¶ÔλÕóÈÝ > ÆäËûÕóÈÝ
        if specMainObj:
            lineupNumList = [sepcObjLineupNum]
        else:
            lineupNumList = [lineupNum]
        for tagNum in batFaction.lineupDict.keys():
            if tagNum not in lineupNumList:
                lineupNumList.append(tagNum)
                
    batLineup = None
    aimObjList = [] # ÏÈɸѡ³ö·¶Î§Ä¿±ê
    for num in lineupNumList:
        batLineup = batFaction.getBatlineup(num)
        
        # ¶Ôλ
        if tagAim == ChConfig.SkillTagAim_Relative:
            if specMainObj:
                aimObjList.append(specMainObj)
            else:
                relativeObj = __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup)
                if relativeObj:
                    aimObjList.append(relativeObj)
                    
        # Ç°ÅÅ
        elif tagAim == ChConfig.SkillTagAim_FrontRow:
            aimObjList = __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, False, isNoSelf)
            
        # ºóÅÅ
        elif tagAim == ChConfig.SkillTagAim_BackRow:
            aimObjList = __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, True, isNoSelf)
            
        # ÊúÅÅ/×ÝÅÅ
        elif tagAim == ChConfig.SkillTagAim_Vertical:
            # ÓÅÏÈ×Ô¼ºËùÔÚ×Ý
            inColNum = ChConfig.GetInColNum(posNum)
            colNumList = range(1, 1 + ChConfig.TurnFightCols)
            if inColNum in colNumList:
                colNumList.remove(inColNum)
                colNumList.insert(0, inColNum)
                
            # ÓÅÏÈÌØÊâÄ¿±êËùÔÚ×Ý
            if specMainObj:
                specInColNum = ChConfig.GetInColNum(specObjPosNum)
                if specInColNum in colNumList:
                    colNumList.remove(specInColNum)
                    colNumList.insert(0, specInColNum)
                    
            GameWorld.DebugLog("×ÝÅÅ: colNumList=%s,specObjID-PosNum=%s-%s" % (colNumList, specObjID, specObjPosNum))
            for col in colNumList:
                for row in range(1, 1 + ChConfig.TurnFightRows):
                    pNum = (row - 1) * ChConfig.TurnFightCols + col
                    #GameWorld.DebugLog("    col=%s,row=%s,pNum=%s" % (col, row, pNum))
                    if pNum not in batLineup.posObjIDDict:
                        continue
                    tagObjID = batLineup.posObjIDDict[pNum]
                    tagBatObj = batObjMgr.getBatObj(tagObjID)
                    if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
                        continue
                    aimObjList.append(tagBatObj)
                if aimObjList:
                    break
                
        # ÆäËû£¬Ä¬ÈÏÈ«²¿
        else:
            inColNum = ChConfig.GetInColNum(posNum) # Íæ¼ÒËùÔÚ×ÝÁÐ
            # ÓÅÏÈ×Ô¼ºËùÔÚ×Ý
            colNumList = range(1, 1 + ChConfig.TurnFightCols)
            if inColNum in colNumList:
                colNumList.remove(inColNum)
                colNumList.insert(0, inColNum)
                
            GameWorld.DebugLog("È«²¿: colNumList=%s,specObjID-PosNum=%s-%s" % (colNumList, specObjID, specObjPosNum))
            # °´Ç°ÅÅÓÅÏÈÔ­Ôò
            for row in range(1, 1 + ChConfig.TurnFightRows):
                for col in colNumList:
                    pNum = (row - 1) * ChConfig.TurnFightCols + col
                    #GameWorld.DebugLog("    col=%s,row=%s,pNum=%s" % (col, row, pNum))
                    if pNum not in batLineup.posObjIDDict:
                        continue
                    tagObjID = batLineup.posObjIDDict[pNum]
                    tagBatObj = batObjMgr.getBatObj(tagObjID)
                    if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
                        continue
                    aimObjList.append(tagBatObj)
                    
    # Ä¿±êϸ·Ö
    # ѪÁ¿×îµÍ
    if tagAffect == ChConfig.SkillTagAffect_HPLowest:
        aimObjList.sort(key=lambda o:(o.GetHP()), reverse=False)
        #GameWorld.DebugLog("ѪÁ¿×îµÍÅÅÐò: %s" % [[o.GetID(), o.GetHP(), o.GetMaxHP()] for o in aimObjList])
        
    # ѪÁ¿×î¸ß
    elif tagAffect == ChConfig.SkillTagAffect_HPHighest:
        aimObjList.sort(key=lambda o:(o.GetHP()), reverse=True)
        #GameWorld.DebugLog("ѪÁ¿×î¸ßÅÅÐò: %s" % [[o.GetID(), o.GetHP(), o.GetMaxHP()] for o in aimObjList])
        
    # ¹¥»÷Á¦×î¸ß
    elif tagAffect == ChConfig.SkillTagAffect_AtkHighest:
        aimObjList.sort(key=lambda o:(o.GetAtk()), reverse=True)
        #GameWorld.DebugLog("¹¥»÷Á¦×î¸ßÅÅÐò: %s" % [[o.GetID(), o.GetHP(), o.GetMaxHP()] for o in aimObjList])
        
    # δ±»¿ØÖÆÓÅÏÈ
    elif tagAffect == ChConfig.SkillTagAffect_UncontrolledPriority:
        sneerObjFirst = False
        aimObjList.sort(key=lambda o:(o.IsInControlled()))
        GameWorld.DebugLog("δ±»¿ØÖÆÓÅÏÈ: %s" % [[o.GetID(), o.IsInControlled()] for o in aimObjList])
                
    # ×ÆÉÕ/Ðþ»ðÄ¿±êÓÅÏÈ
    elif tagAffect == ChConfig.SkillTagAffect_Burn:
        atkBackTagFrist = False
        relativeObj = __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup)
        sortObjList = [] # ÓÅÏÈ×ÆÉÕÄ¿±ê£¬ÔÙ¶Ôλ
        for aimObj in aimObjList:
            sortValue = 0
            buffMgr = aimObj.GetBuffManager()
            if buffMgr.FindBuffListByState(ChConfig.BatObjState_Burn) or buffMgr.FindBuffListByState(ChConfig.BatObjState_BurnPlus):
                sortValue = 2
            elif relativeObj and relativeObj.GetID() == aimObj.GetID():
                sortValue = 1
            sortObjList.append([sortValue, aimObj])
        sortObjList.sort(reverse=True)
        aimObjList = [s[1] for s in sortObjList]
        
    # ½ö·ÙѪ£¨¶¾ÄÌ£©Ä¿±ê
    elif tagAffect == ChConfig.SkillTagAffect_PoisonCure:
        atkBackTagFrist = False
        for aimObj in aimObjList[::-1]:
            if not aimObj.CheckInState(ChConfig.BatObjState_PoisonCure):
                aimObjList.remove(aimObj)
    else:
        # ·¶Î§Ä¿±ê³¬¹ý¸öÊý£¬ÔòËæ»úÈ¡
        if tagCount and len(aimObjList) > tagCount:
            random.shuffle(aimObjList)
            
    # ÒÔÏÂÓÅÏȼ¶ÏÈ´¦ÀíµÄÓÅÏȼ¶ÊÓΪ½ÏµÍ
    if atkBackTagFrist and atkBackTag:
        if atkBackTag in aimObjList and aimObjList.index(atkBackTag) != 0:
            aimObjList.remove(atkBackTag)
            aimObjList.insert(0, atkBackTag)
            
    # ³°·íÓÅÏÈ
    if sneerObjFirst and sneerTagObj:
        if sneerTagObj in aimObjList and aimObjList.index(sneerTagObj) != 0:
            aimObjList.remove(sneerTagObj)
            aimObjList.insert(0, sneerTagObj)
            
    # Ò»¶¨°üº¬×Ô¼º
    if tagFriendly == 2 and not isNoSelf:
        if curBatObj not in aimObjList:
            aimObjList.append(curBatObj)
            
    # ×îºóÈ¥³ý¶àÓàµÄÄ¿±ê
    if tagCount and len(aimObjList) > tagCount:
        aimObjList = aimObjList[:tagCount]
        
    return aimObjList

def CheckChangeTagEff(turnFight, curBatObj, useSkill):
    ## ¼¼ÄÜ×ÔÉíÉ趨ǿÖÆÐÞ¸ÄÄ¿±ê£¬Ä¿Ç°Ôݶ¨ÓÅÏȼ¶×î¸ß£¬ÎÞÊÓÈí¿Ø
    # IPY_Skill ûÓÐ  GetEffectByID£¬Ôݲ»×öÖ§³Ö£¬Ä¿Ç°Ð¡ÇÇÅ­¼¼×¨Óã¬ÒÔºóÓÐÓÃÓÚ±ðµÄÔÙ˵
    if not hasattr(useSkill, "GetEffectByID"):
        return
    cureWayExEff = useSkill.GetEffectByID(ChConfig.SkillEff_ChangeTag)
    if not cureWayExEff:
        return
    changeTagSet = cureWayExEff.GetEffectValue(0)
    checkInStates = cureWayExEff.GetEffectValue(1)
    if not checkInStates:
        return None, changeTagSet
    
    curFaction = curBatObj.GetFaction()
    tagFaction = ChConfig.Def_FactionB if curFaction == ChConfig.Def_FactionA else ChConfig.Def_FactionA
    batFaction = turnFight.getBatFaction(tagFaction)
    
    lineupNum = curBatObj.GetLineupNum()
    lineupNumList = [lineupNum] # µÐ·½ÓÅÏȶÔλÕóÈÝ£¬ÔÙÆäËûÕóÈÝ
    for tagNum in batFaction.lineupDict.keys():
        if tagNum not in lineupNumList:
            lineupNumList.append(tagNum)
            
    batObjMgr = BattleObj.GetBatObjMgr()
    for num in lineupNumList:
        batLineup = batFaction.getBatlineup(num)
        for tagID in batLineup.posObjIDDict.values():
            tagObj = batObjMgr.getBatObj(tagID)
            if tagObj.IsAlive() and tagObj.CheckInState(checkInStates):
                return lineupNum, changeTagSet
    return

def __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, rowReverse, isNoSelf=False):
    ## »ñÈ¡ºáÅÅÄ¿±ê¶ÔÏóÁбí
    # @param rowReverse: ÊÇ·ñºóÅÅÓÅÏÈÔ­Ôò
    # @param noSelf: ÊÇ·ñÏÞÖÆ°üº¬×Ô¼º
    
    # Ç°ºóÅÅ˳Ðò
    if rowReverse:
        rowNumList = range(1, 1 + ChConfig.TurnFightRows)[::-1]
    else:
        rowNumList = range(1, 1 + ChConfig.TurnFightRows)
        
    # ÓÅÏÈÌØÊâ¶ÔÏóËùÔÚÐÐ
    specObjID, specObjPosNum = 0, 0
    if specMainObj:
        specObjID = specMainObj.GetID()
        specObjPosNum = specMainObj.GetPosNum()
        sneerInRowNum = ChConfig.GetInRowNum(specObjPosNum) # ËùÔÚÐÐÅÅ
        if sneerInRowNum in rowNumList:
            rowNumList.remove(sneerInRowNum)
            rowNumList.insert(0, sneerInRowNum)
            
    inColNum = ChConfig.GetInColNum(curBatObj.GetPosNum()) # Íæ¼ÒËùÔÚ×ÝÁÐ
    # ÓÅÏÈ×Ô¼ºËùÔÚ×Ý£¬ÎªÖ÷Ä¿±ê
    colNumList = range(1, 1 + ChConfig.TurnFightCols)
    if inColNum in colNumList:
        colNumList.remove(inColNum)
        colNumList.insert(0, inColNum)
        
    GameWorld.DebugLog("Ç°ºóÅÅ: rowNumList=%s,colNumList=%s,specObjID-PosNum=%s-%s" % (rowNumList, colNumList, specObjID, specObjPosNum))
    aimObjList = []
    for row in rowNumList:
        for col in colNumList:
            pNum = (row - 1) * ChConfig.TurnFightCols + col
            #GameWorld.DebugLog("    row=%s,col=%s,pNum=%s" % (row, col, pNum))
            if pNum not in batLineup.posObjIDDict:
                continue
            tagObjID = batLineup.posObjIDDict[pNum]
            tagBatObj = batObjMgr.getBatObj(tagObjID)
            if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
                continue
            aimObjList.append(tagBatObj)
        if aimObjList:
            break
        
    return aimObjList

def GetRelativeObj(turnFight, curBatObj):
    '''»ñÈ¡¶ÔλĿ±ê£¬½öÓÃÓڷǼ¼ÄÜÄ¿±êµÄ¶ÔλÂß¼­£¬ÈçÁ¬»÷¡¢ÈõÁƵÈÏà¶ÔÊôÐÔµÄÅжϣ¬¼¼ÄÜÄ¿±êͳһʹÓà GetSkillTags
    '''
    sneerObj = curBatObj.GetSneerTagObj()
    if sneerObj:
        # Óг°·íÄ¿±êÓÅÏÈÖ±½Ó¶Ôλ
        return sneerObj
    
    curFaction = curBatObj.GetFaction()
    # ĬÈ϶ÔλµÐ¶ÔÕóÓª
    tagFaction = ChConfig.Def_FactionB if curFaction == ChConfig.Def_FactionA else ChConfig.Def_FactionA
    
    batObjMgr = BattleObj.GetBatObjMgr()
    lineupNum = curBatObj.GetLineupNum()
    posNum = curBatObj.GetPosNum()
    
    batFaction = turnFight.getBatFaction(tagFaction)
    lineupNumList = [lineupNum] # µÐ·½ÓÅÏȶÔλÕóÈÝ£¬ÔÙÆäËûÕóÈÝ£¬Ö§³Ö¶àÕóÈݶÔÕ½
    for tagNum in batFaction.lineupDict.keys():
        if tagNum not in lineupNumList:
            lineupNumList.append(tagNum)
            
    for num in lineupNumList:
        batLineup = batFaction.getBatlineup(num)
        relativeObj = __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup)
        if relativeObj:
            return relativeObj
        
    # ÀíÂÛÉÏÖ»ÒªÕ½¶·Ã»ÓнáÊø£¬Ò»¶¨»áÓжÔλĿ±ê£¬ÕâÀïĬÈÏ·µ»Ø×Ô¼º£¬·½±ãÍâ²ãÂß¼­´¦Àí£¬Íâ²ã¿É²»ÐèÒªÅжÏÊÇ·ñ´æÔÚ¶ÔλĿ±ê
    return curBatObj

def __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup):
    ## »ñÈ¡ÔÚijһÕóÈÝÖеÄĬÈ϶ÔλĿ±ê£¬²»°üÀ¨×Ô¼º
    if not batLineup:
        return
    tagAffect = ChConfig.SkillTagAffect_None # ĬÈ϶ÔλĿ±ê²»ÐèҪϸ·ÖÄ¿±ê£¬Ä¬ÈϹæÔò¼´¿É
    inColNum = ChConfig.GetInColNum(posNum) # Íæ¼ÒËùÔÚ×ÝÁÐ
    # ÓÅÏÈ×Ô¼ºËùÔÚ×Ý
    colNumList = range(1, 1 + ChConfig.TurnFightCols)
    if inColNum in colNumList:
        colNumList.remove(inColNum)
        colNumList.insert(0, inColNum)
        
    # °´Ç°ÅÅÓÅÏÈÔ­Ôò
    for row in range(ChConfig.TurnFightRows):
        for col in colNumList:
            pNum = row * ChConfig.TurnFightCols + col
            if pNum not in batLineup.posObjIDDict:
                continue
            tagObjID = batLineup.posObjIDDict[pNum]
            tagBatObj = batObjMgr.getBatObj(tagObjID)
            if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf=True):
                continue
            return tagBatObj
        
    return

def __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf=False):
    ## ¼¼ÄÜÄ¿±ê¹ýÂËÆ÷
    # @return: ÊÇ·ñÔÊÐíÌí¼Ó¸Ãµ¥Î»
    if not tagBatObj:
        return False
    if tagAffect != ChConfig.SkillTagAffect_Death and not tagBatObj.IsAlive():
        return False
    if tagAffect == ChConfig.SkillTagAffect_Death and tagBatObj.IsAlive():
        return False
    if isNoSelf:
        if tagBatObj.GetID() == curBatObj.GetID():
            #GameWorld.DebugLog("²»°üº¬×Ô¼º")
            return False
    #if not tagBatObj.GetCanAttack(): ²ß»®ÒªÇ󲻿ɹ¥»÷µÄ¶ÔÏóÒ²Òª¿ÉÑ¡ÖÐ
    #    return False
    return True

def __doAddBuff(turnFight, curBatObj, useSkill):
    #Ö´ÐÐÌí¼Óbuff
    
    #¹â»·¼¼ÄÜ£¬ÐèÏÈÌí¼ÓÊ©·¨Õß
    if useSkill.GetSkillType() == ChConfig.Def_SkillType_Halo:
        curID = curBatObj.GetID()
        skillID = useSkill.GetSkillID()
        GameWorld.DebugLog("¹â»·¼¼ÄÜÏȸøÊ©·¨ÕßÌí¼Ó¹âÔ´buff! skillID=%s,ownerID=%s" % (skillID, curID))
        if TurnBuff.OnAddBuff(turnFight, curBatObj, useSkill, buffOwner=curBatObj):
            for tagBatObj in useSkill.GetTagObjList():
                if tagBatObj.GetID() == curBatObj.GetID():
                    continue
                TurnBuff.OnAddBuff(turnFight, tagBatObj, useSkill, buffOwner=curBatObj)
    else:
        for tagBatObj in useSkill.GetTagObjList():
            TurnBuff.OnAddBuff(turnFight, tagBatObj, useSkill, buffOwner=curBatObj)
        
    return

def __doUseSkill(turnFight, curBatObj, useSkill):
    
    atkType = useSkill.GetAtkType()
    GameWorld.DebugLog("__doUseSkill: curID=%s,skillID=%s,atkType=%s" % (curBatObj.GetID(), useSkill.GetSkillID(), atkType))
    
    __doHarmSelf(turnFight, curBatObj, useSkill)
    
    # ͨÓù¥»÷
    if atkType == 1:
        SkillModule_1(turnFight, curBatObj, useSkill)
    # ÖÎÁÆ
    if atkType == 2:
        SkillModule_2(turnFight, curBatObj, useSkill)
    # ¸´»î
    elif atkType == 3:
        pass
    # ¶à´Î¹¥»÷£¨ËøÄ¿±ê¶à´ÎÉ˺¦£¬·ÇÇ°¶ËµÄ¶à¶ÎƮѪ£©
    elif atkType == 4:
        pass
    # µ¯Éä¹¥»÷
    elif atkType == 5:
        SkillModule_5(turnFight, curBatObj, useSkill)
    # Å­ÆøÔö
    elif atkType == 6:
        SkillModule_6(turnFight, curBatObj, useSkill, "Increase")
    # Å­Æø¼õ
    elif atkType == 7:
        SkillModule_6(turnFight, curBatObj, useSkill, "Reduce")
    # Å­Æø͵
    elif atkType == 8:
        SkillModule_6(turnFight, curBatObj, useSkill, "Steal")
    # µ¯ÉäÖÎÁÆ
    elif atkType == 9:
        SkillModule_9(turnFight, curBatObj, useSkill)
        
    return

def __doHarmSelf(turnFight, curBatObj, useSkill):
    ## Ê©·¨Ç°×Ô²Ð
    harmEff = useSkill.GetEffectByID(ChConfig.SkillEff_UseSkillHarmSelf)
    if not harmEff:
        return
    harmPer = harmEff.GetEffectValue(0) # ×ԲаٷֱÈ
    noEnoughDo = harmEff.GetEffectValue(1) # ²»×ãʱ¿Û³ý·½Ê½ 0-²»¿Û£»1-×Ôɱ£»2-¿ÛÊ£1µã
    curHP = curBatObj.GetHP()
    maxHP = curBatObj.GetMaxHP()
    harmHP = int(maxHP * harmPer / 100.0)
    lostHP = harmHP
    if curHP <= harmHP:
        if noEnoughDo == 0:
            lostHP = 0
        elif noEnoughDo == 2:
            lostHP -= 1
            
    updHP = max(curHP - lostHP, 0)
    curBatObj.SetHP(updHP, False)
    GameWorld.DebugLog("ʹÓü¼ÄÜʱ×Ô²Ð: curHP=%s/%s,harmPer=%s,harmHP=%s,lostHP=%s,updHP=%s,noEnoughDo=%s" 
                       % (curHP, maxHP, harmPer, harmHP, lostHP, updHP, noEnoughDo))
    
    curBatObj.SetHarmSelfHP(harmHP) # ÎÞÊÓʵ¼Ê¿ÛѪÁ¿£¬Ö±½Ó¸üÐÂ
    
    # µ¥¶À֪ͨǰ¶Ë±íÏÖ
    hurtTypes = pow(2, ChConfig.HurtType_HarmSelf)
    diffType, diffValue = 0, lostHP
    skillID = relatedSkillID = useSkill.GetSkillID()
    Sync_PropertyRefreshView(turnFight, curBatObj, ChConfig.AttrID_HP, updHP, diffValue, diffType, skillID, relatedSkillID, hurtTypes)
    return

def SkillModule_1(turnFight, curBatObj, useSkill):
    ## ͨÓù¥»÷£¬µ¥¹¥¡¢Èº¹¥
    
    # ¼ÆËãÉ˺¦
    calcHurtResults = []
    for tagBatObj in useSkill.GetTagObjList():
        hurtValue, hurtTypes, immuneHurt = __calcSkillHurt(turnFight, curBatObj, tagBatObj, useSkill)
        calcHurtResults.append([tagBatObj, hurtValue, hurtTypes, immuneHurt])
        
    DoSkillHurtHP(turnFight, curBatObj, useSkill, calcHurtResults)        
    return

def __calcSkillHurt(turnFight, atkObj, defObj, curSkill):
    ## ¼ÆËã¼¼ÄÜÉ˺¦£¬Ö»¼ÆËãÖµ£¬²»×öʵ¼Ê´¦Àí
    # @return: hurtValue, hurtTypes, immuneHurt
    atkSkillPer = curSkill.GetSkillPer()
    atkSkillValue = curSkill.GetSkillValue()
    hurtValue, hurtTypes = CalcFormatHurt(turnFight, atkObj, defObj, curSkill, atkSkillValue, atkSkillPer)
    hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes)
    return hurtValue, hurtTypes, immuneHurt

def SkillModule_5(turnFight, curBatObj, useSkill):
    ## µ¯É䣨¶à´Î¹¥»÷£¬Çл»Ä¿±ê£¬µ¥Ä¿±ê¿É¶à´Î£©
    
    ricochetObjList = GetRicochetObjRankList(turnFight, curBatObj, useSkill)
    
    # µ¯Éä¼¼ÄÜÐèÏÈ´Óµ¯ÉäÄ¿±êÀïԤѡºÃ²ÜÈÊÒª·À»¤µÄ¶ÔÏó
    caorenProtectObj = None # ²ÜÈʱ£»¤µÄÄ¿±ê£¬ÑªÁ¿×îµÍµÄ£¬²ÜÈÊרÓ㬲»µ²×Ô¼º£¬²»µ²Î޵У¬Ë³ÑÓÖ±µ½Ò»¸ö¿ÉÒÔµ²µÄ×îµÍѪÁ¿Ä¿±ê£¬Èç¹ûûÓоͲ»µ²
    for tagObj in ricochetObjList:
        tagID = tagObj.GetID()
        if tagID == ChConfig.HeroID_Caoren:
            continue
        if tagObj.CheckInState(ChConfig.BatObjState_Wudi):
            continue
        if not caorenProtectObj or tagObj.GetHP() < caorenProtectObj.GetHP():
            caorenProtectObj = tagObj
    if caorenProtectObj == None:
        caorenProtectObj = 0 # ±ê¼ÇΪÒÑɸѡ¹ý
        
    # °´Ë³ÐòÒ»¸ö¸öµ¯É˺¦
    for tagBatObj in ricochetObjList:
        hurtValue, hurtTypes, immuneHurt = __calcSkillHurt(turnFight, curBatObj, tagBatObj, useSkill)
        
        calcHurtResults = [[tagBatObj, hurtValue, hurtTypes, immuneHurt]]
        DoSkillHurtHP(turnFight, curBatObj, useSkill, calcHurtResults, "RicochetHurt", caorenProtectObj, isManyTimes=True)
        
    return

def GetRicochetObjRankList(turnFight, curBatObj, useSkill):
    ## »ñÈ¡µ¯ÉäÄ¿±ê¶ÓÁÐ
    ricochetCnt = useSkill.GetTagCount() # µ¯Éä´ÎÊý£¬Ä¬ÈÏÈ¡¼¼ÄÜÄ¿±êÊý
    randEffect = useSkill.GetEffectByID(ChConfig.SkillEff_RandRicochetCnt)
    if randEffect:
        valueA = randEffect.GetEffectValue(0)
        valueB = max(randEffect.GetEffectValue(1), valueA)
        ricochetCnt = random.randint(valueA, valueB)
        GameWorld.DebugLog("Ëæ»úµ¯Éä´ÎÊý: %s,valueA=%s,valueB=%s" % (ricochetCnt, valueA, valueB))
    ricochetCnt += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddRicochetCnt, useSkill)
    
    # µ¯É䣺ÓÅÏȵ¯Éä´ÎÊýÉÙµÄÄ¿±ê£¬ÏàͬĿ±ê¿Éµ¯Éä¶à´Î
    tagObjList = useSkill.GetTagObjList()
    random.shuffle(tagObjList)
    objCnt = len(tagObjList)
    ricochetObjList = []
    ricochetObjIDList = []
    for index in range(ricochetCnt):
        tagObj = tagObjList[index % objCnt]
        ricochetObjList.append(tagObj)
        ricochetObjIDList.append(tagObj.GetID())
        
    GameWorld.DebugLog("µ¯Éä´ÎÊý: %s, ricochetObjIDList=%s" % (ricochetCnt, ricochetObjIDList)) 
    return ricochetObjList

def SkillModule_2(turnFight, curBatObj, useSkill):
    ## ÖÎÁÆ
    
    calcCureResults = []
    relativeObj = GetRelativeObj(turnFight, curBatObj)
    for tagBatObj in useSkill.GetTagObjList():
        cureHP = CalcCureHP(turnFight, curBatObj, tagBatObj, useSkill, relativeObj=relativeObj)
        poisonCureOwner = GetPoisonCureOwner(tagBatObj)
        calcCureResults.append([tagBatObj, cureHP, poisonCureOwner])
        
    DoSkillCureHP(turnFight, curBatObj, useSkill, calcCureResults)
    return

def SkillModule_9(turnFight, curBatObj, useSkill):
    ## µ¯ÉäÖÎÁÆ£¨¶à´ÎÖÎÁÆ£¬Çл»Ä¿±ê£¬µ¥Ä¿±ê¿É¶à´Î£©
    
    relativeObj = GetRelativeObj(turnFight, curBatObj)
    ricochetObjList = GetRicochetObjRankList(turnFight, curBatObj, useSkill)
    
    # µ¯Éä¼¼ÄÜÐèÏÈ´Óµ¯ÉäÄ¿±êÀïԤѡºÃ²ÜÈÊÒª·À»¤µÄ¶ÔÏó£¬Óж¾Ä̵ÄÇé¿ö
    poisonCureOwnerDict = {}
    caorenProtectObj = None # ²ÜÈʱ£»¤µÄÄ¿±ê£¬ÑªÁ¿×îµÍµÄ£¬²ÜÈÊרÓ㬲»µ²×Ô¼º£¬²»µ²Î޵У¬Ë³ÑÓÖ±µ½Ò»¸ö¿ÉÒÔµ²µÄ×îµÍѪÁ¿Ä¿±ê£¬Èç¹ûûÓоͲ»µ²
    for tagObj in ricochetObjList:
        tagID = tagObj.GetID()
        if tagID not in poisonCureOwnerDict:
            poisonCureOwner = GetPoisonCureOwner(tagObj)
            poisonCureOwnerDict[tagID] = poisonCureOwner
        poisonCureOwner = poisonCureOwnerDict[tagID]
        if not poisonCureOwner:
            continue
        if tagID == ChConfig.HeroID_Caoren:
            continue
        if tagObj.CheckInState(ChConfig.BatObjState_Wudi):
            continue
        if not caorenProtectObj or tagObj.GetHP() < caorenProtectObj.GetHP():
            caorenProtectObj = tagObj
    if caorenProtectObj == None:
        caorenProtectObj = 0 # ±ê¼ÇΪÒÑɸѡ¹ý
        
    for tagBatObj in ricochetObjList:
        cureHP = CalcCureHP(turnFight, curBatObj, tagBatObj, useSkill, relativeObj=relativeObj)
        poisonCureOwner = poisonCureOwnerDict.get(tagBatObj.GetID())
        calcCureResults = [[tagBatObj, cureHP, poisonCureOwner]]
        
        DoSkillCureHP(turnFight, curBatObj, useSkill, calcCureResults, "RicochetCure", caorenProtectObj, isManyTimes=True)
        
    return

def DoSkillCureHP(turnFight, atkObj, curSkill, calcCureResults, lostType="", caorenProtectObj=None, isManyTimes=False):
    '''½áËã¼¼ÄÜÖÎÁÆ
    @param calcCureResults: ¼¼Äܹ«Ê½¼ÆËãºóµÄÉ˺¦½á¹û [[tagBatObj, cureHP, poisonCureOwner], ...]
    @param caorenProtectObj: ²ÜÈÊרÓã¬Òª·À»¤µÄ¶ÔÏó
    @param isManyTimes: ÊÇ·ñÊǺó¶Ë¶à´Î¼ÆËãµÄ
    '''
    
    skillID = curSkill.GetSkillID()
    calcHurtResults = []
    for tagBatObj, cureHP, poisonCureOwner in calcCureResults:
        # »ã×ܶ¾ÄÌ
        if poisonCureOwner:
            hurtTypes = pow(2, ChConfig.HurtTYpe_Cure)
            hurtTypes |= pow(2, ChConfig.HurtType_PoisonCureHurt)
            hurtValue = cureHP
            hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, tagBatObj, hurtValue, hurtTypes)
            calcHurtResults.append([tagBatObj, hurtValue, hurtTypes, immuneHurt])
            continue
        
        # ·Ç¶¾Ä̵ÄÖ´ÐÐÖÎÁÆ
        dID = tagBatObj.GetID()
        dHP = tagBatObj.GetHP()
        dMapHP = tagBatObj.GetMaxHP()
        
        remainHP = min(dHP + cureHP, dMapHP)
        realCureHP = max(remainHP - dHP, 0)
        tagBatObj.SetHP(remainHP)
        
        hurtObj = curSkill.AddHurtObj(dID)
        hurtObj.AddHurtType(ChConfig.HurtTYpe_Cure)
        hurtObj.SetHurtHP(cureHP)
        hurtObj.SetLostHP(realCureHP)
        hurtObj.SetCurHP(tagBatObj.GetHP())
        GameWorld.DebugLog("    ÖÎÁÆ: dID=%s,cureHP=%s,realCureHP=%s,%s/%s" % (dID, cureHP, realCureHP, tagBatObj.GetHP(), dMapHP))
        
        TurnAttack.AddTurnObjCureHP(tagBatObj, atkObj, cureHP, realCureHP, skillID)
        
    # ÔÙ½áË㶾ÄÌÉ˺¦
    DoSkillHurtHP(turnFight, atkObj, curSkill, calcHurtResults, "PoisonCure", caorenProtectObj, isManyTimes)
    return

def GetPoisonCureOwner(defObj):
    ## »ñÈ¡Íæ¼ÒÉíÉϵĶ¾ÄÌbuff¹éÊôÕß
    # @return: buffOwner or None-ÎÞ¶¾ÄÌbuff
    buffMgr = defObj.GetBuffManager()
    poisonCureBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_PoisonCure) # ¶¾ÄÌÔݶ¨Î¨Ò»
    if not poisonCureBuff:
        return
    ownerID = poisonCureBuff.GetOwnerID()
    buffOwner = BattleObj.GetBatObjMgr().getBatObj(ownerID) # ¹¥»÷·½
    return buffOwner

def DoCureOfTime(turnFight, batObj, curBuff, cureHP, **kwargs):
    ## Ö´ÐгÖÐøÖÎÁƵ¥´ÎÂß¼­
    skillID = curBuff.GetSkillID()
    skillIpyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
    if not skillIpyData:
        return
    buffID = curBuff.GetBuffID()
    ownerID = curBuff.GetOwnerID()
    buffOwner = BattleObj.GetBatObjMgr().getBatObj(ownerID) # ÖÎÁÆ·½
    if not buffOwner:
        return
    
    defObj = batObj
    poisonCureOwner = GetPoisonCureOwner(defObj)
    atkObj = poisonCureOwner if poisonCureOwner else buffOwner
    
    atkID = atkObj.GetID()
    defID = defObj.GetID()
    
    # ½áËãÐèҪͬ²½±êÇ©
    useTag = "Skill_%s_%s_Cot" % (atkID, skillID)
    Sync_TurnFightTag(turnFight, useTag, 0)
    
    dHP = defObj.GetHP()
    dMaxHP = defObj.GetMaxHP()
    GameWorld.DebugLog("½áËã³ÖÐøÖÎÁÆ: atkID=%s,defID=%s,buffID=%s,skillID=%s,ownerID=%s,cureHP=%s,dHP=%s/%s" 
                       % (atkID, defID, buffID, skillID, ownerID, cureHP, dHP, dMaxHP))
    layer = curBuff.GetLayer()
    if layer > 0:
        cureHP *= layer
        GameWorld.DebugLog("    ¶à²ãbuff: cureHP=%s,layer=%s" % (cureHP, layer))
    #if "FinalDamPer" in kwargs:
    #    FinalDamPer = kwargs["FinalDamPer"]
    #    hurtValue *= (10000 + FinalDamPer) / 10000.0
    #    GameWorld.DebugLog("    ÔöÉË: hurtValue=%s,FinalDamPer=%s" % (hurtValue, FinalDamPer))
    
    poolMgr = ObjPool.GetPoolMgr()
    useSkill = poolMgr.acquire(BattleObj.PySkill, skillIpyData, atkID)
    useSkill.SetTagObjList([defObj])
    useSkill.SetBatType(ChConfig.TurnBattleType_Cot)
    
    poisonCureOwner = GetPoisonCureOwner(defObj)
    if poisonCureOwner:
        GameWorld.DebugLog("±¾´ÎÖÎÁÆΪ¶¾ÄÌ: cureHP=%s" % cureHP)
        hurtValue = cureHP
        hurtTypes = pow(2, ChConfig.HurtTYpe_Cure)
        hurtTypes |= pow(2, ChConfig.HurtType_PoisonCureHurt)
        hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, poisonCureOwner, defObj, hurtValue, hurtTypes)
        calcHurtResults = [[defObj, hurtValue, hurtTypes, immuneHurt]]
        DoSkillHurtHP(turnFight, poisonCureOwner, useSkill, calcHurtResults, "PoisonCOT")
    else:
        remainHP = min(dHP + cureHP, dMaxHP)
        realCureHP = max(remainHP - dHP, 0)
        defObj.SetHP(remainHP)
        
        hurtObj = useSkill.AddHurtObj(defID)
        hurtObj.AddHurtType(ChConfig.HurtTYpe_Cure)
        hurtObj.SetHurtHP(cureHP)
        hurtObj.SetLostHP(realCureHP)
        hurtObj.SetCurHP(defObj.GetHP())
        GameWorld.DebugLog("    ÖÎÁÆ: dID=%s,cureHP=%s,realCureHP=%s,%s/%s" % (defID, cureHP, realCureHP, defObj.GetHP(), dMaxHP))
        
        TurnAttack.AddTurnObjCureHP(defObj, atkObj, cureHP, realCureHP, skillID)
        
    Sync_UseSkill(turnFight, atkObj, useSkill)
    
    DoBeAttackResult(turnFight, atkObj, useSkill)
    
    # ֪ͨ½áÊø±êÇ©
    Sync_TurnFightTag(turnFight, useTag, 1)
    
    useSkill.ResetUseRec()
    poolMgr.release(useSkill)
    return

def SkillModule_6(turnFight, curBatObj, useSkill, opType):
    ## Å­ÆøÔö¼õ͵
    
    curID = curBatObj.GetID()
    skillID = useSkill.GetSkillID()
    bySkill = useSkill.GetBySkill()
    relatedSkillID = bySkill.GetSkillID() if bySkill else 0
    
    #cureType = useSkill.GetCalcType()
    skillPer = useSkill.GetSkillPer()
    skillValue = useSkill.GetSkillValue()
    
    xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2)
    calcValue = int(xpMax * skillPer / 10000.0 + skillValue)
    attrID = ChConfig.AttrID_XP
    
    GameWorld.DebugLog("Å­Æø%s: curID=%s,calcValue=%s,skillID=%s,skillPer=%s,skillValue=%s,relatedSkillID=%s" 
                       % (opType, curID, calcValue, skillID, skillPer, skillValue, relatedSkillID))
    curStealTotal = 0
    for tagBatObj in useSkill.GetTagObjList():
        
        tagID = tagBatObj.GetID()
        # ¼õ
        if opType == "Reduce":
            diffType = 0
            tagXP = tagBatObj.GetXP()
            diffValue = min(tagXP, calcValue) # È¡½ÏСֵ£¬²»×ãʱʣ¶àÉÙ¼õ¶àÉÙ
            updValue = tagXP - diffValue
            tagBatObj.SetXP(updValue, False)
            GameWorld.DebugLog("    ¼õÅ­Æø: tagID=%s,diffValue=%s,tagXP=%s,updXP=%s" % (tagID, diffValue, tagXP, updValue))
            Sync_PropertyRefreshView(turnFight, tagBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
            
        # ͵
        elif opType == "Steal":
            diffType = 0
            tagXP = tagBatObj.GetXP()
            diffValue = min(tagXP, calcValue) # È¡½ÏСֵ£¬²»×ãʱʣ¶àÉÙ¼õ¶àÉÙ
            updValue = tagXP - diffValue
            tagBatObj.SetXP(updValue, False)
            GameWorld.DebugLog("    ͵ŭÆø: tagID=%s,diffValue=%s,tagXP=%s,updXP=%s" % (tagID, diffValue, tagXP, updValue))
            Sync_PropertyRefreshView(turnFight, tagBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
            
            curStealTotal += diffValue
            
        # ÆäËûĬÈϼÓ
        else:
            diffType = 1
            tagXP = tagBatObj.GetXP()
            diffValue = GetEnhanceXP(tagBatObj, calcValue)
            updValue = tagXP + diffValue
            tagBatObj.SetXP(updValue, False)
            GameWorld.DebugLog("    ¼ÓÅ­Æø: tagID=%s,diffValue=%s,tagXP=%s,updXP=%s" % (tagID, diffValue, tagXP, updValue))
            Sync_PropertyRefreshView(turnFight, tagBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
            
    if curStealTotal > 0:
        diffType = 1
        curXP = curBatObj.GetXP()
        diffValue = GetEnhanceXP(tagBatObj, curStealTotal)
        updValue = curXP + diffValue
        curBatObj.SetXP(updValue, False)
        GameWorld.DebugLog("    ¼Ó×ÜÅ­Æø: curID=%s,curStealTotal=%s,curXP=%s,diffValue=%s,updXP=%s" % (curID, curStealTotal, curXP, diffValue, updValue))
        Sync_PropertyRefreshView(turnFight, curBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
        
    return

def DoAttackResult(turnFight, curBatObj, useSkill):
    '''Ö´Ðй¥»÷½á¹û
    @param curBatObj: Ê©·¨·½»òbuff¹éÊô·½
    '''
    
    if curBatObj:
        # ·´µ¯¡¢ÎüѪ¡¢Æ½Ì¯É˺¦×ԲРµÄÔ­Òò£¬ÐèҪͳһ´¦Àíºó½áË㣬¿ÉÄܵ¼ÖÂHPΪ¸ºÖµ£¬ÐÞÕýΪ0
        if curBatObj.GetHP() < 0:
            curBatObj.SetHP(0)
            
    if useSkill.GetBatType() == ChConfig.TurnBattleType_AtkBack:
        curBatObj.AddBigTurnAtkbackCnt()
    skillID = useSkill.GetSkillID()
    curBatObj.AddSkillUseCnt(skillID)
    if useSkill.GetCoolDownTime():
        useSkill.SetRemainTime(useSkill.GetCoolDownTime())
        
    # ÐèÏȼ¼ÄÜʹÓà - Ç°¶Ë°´Ë³ÐòÓÅÏȱíÏÖ¼¼ÄÜÊÍ·ÅÄÚÈÝ£¬Ç°¶ËÐèÒª¶¯×÷»òÓÐÉËѪÔò֪ͨ
    if IsNeedSyncSkill(useSkill):
        Sync_UseSkill(turnFight, curBatObj, useSkill)
        
    __doCostZhanchui(turnFight, curBatObj, useSkill)
    __doSkillUserAnger(turnFight, curBatObj, useSkill)
    
    DoBeAttackResult(turnFight, curBatObj, useSkill, True)
    return

def DoCombo(turnFight, atkObj, useSkill):
    '''
        ¸ñµ²¡¢·´»÷¡¢Á¬»÷¹æÔò
        1. ËùÓÐÎ佫»ò¹ÖÎï¾ù¿ÉÄܲúÉú¸ñµ²£¬Èº¹¥Ê±¸ñµ²Ò»¶ÔÒ»Åжϣ¬¾ù¿ÉÄܲúÉú¸ñµ²
        2. ½öÆÕ¹¥Ê±¿É±»·´»÷£¬·´Åжϱ¾´Î¼¼ÄÜÄ¿±êÖеÄÖ÷Ä¿±ê£¨¼´¶ÔλĿ±ê£©ÊÇ·ñ²úÉú¸ñµ²£¬ÇÒÊǽüÕ½Î佫£¬ÊǵĻ°¿É·´»÷
        
        Á¬»÷£º
        1. ½öÆÕ¹¥¿ÉÁ¬»÷£¬·´»÷´ò¶ÏÁ¬»÷
        2. ·Ç¶ÔµÐ¼¼ÄÜ£¬ÈçÄÌÂè»ØѪÆÕ¹¥£¬Åж϶ÔλĿ±ê¿¹Á¬ÊôÐÔÊÇ·ñ¿ÉÁ¬»÷
        3. ¶ÔµÐ¼¼ÄÜ£¬Åжϱ¾´Î¼¼ÄÜÄ¿±êÖеÄÖ÷Ä¿±ê£¨¼´¶ÔλĿ±ê£©¿¹Á¬ÊôÐÔÊÇ·ñ¿ÉÁ¬»÷
        
        ¶ÔµÐ¼¼ÄÜÖ÷Ä¿±ê£º
                µ¥Ì壺 ĬÈϸÃÄ¿±ê
                ³°·í£º ÓÅÏȱ»³°·íµÄÄ¿±ê
                ºáÅÅ£º ÓÅÏȸÃÅÅÖÐÓë×Ô¼ºÍ¬Áеģ¬·ñÔò°´Ë³Ðò
                ×ÝÅÅ£º ÓÅÏÈÇ°ÃæµÄµ¥Î»
    '''
    
    if turnFight.winFaction:
        return
    
    if not useSkill.ComboEnable():
        return
    
    if not atkObj.IsAlive():
        return
    
    tagFriendly = useSkill.GetTagFriendly()
    if tagFriendly:
        tagObj = GetRelativeObj(turnFight, atkObj)
    else:
        tagObjList = useSkill.GetTagObjList()
        if not tagObjList:
            return
        tagObj = tagObjList[0] # µÚÒ»¸öĬÈÏΪÖ÷Ä¿±ê£¬¼¼ÄܶÔÏóÑ¡ÔñÂß¼­Ê±¾ö¶¨Ö÷Ä¿±ê
        atkBackSkill = __getCanAtkBackSkill(atkObj, tagObj, useSkill)
        if atkBackSkill:
            # ¿ÉÒÔ·´»÷£¬´ò¶ÏÁ¬»÷
            GameWorld.DebugLog("¡ñ %s ¡¾·´»÷¡¿" % TurnAttack.GetObjName(tagObj))
            OnUseSkill(turnFight, tagObj, atkBackSkill, batType=ChConfig.TurnBattleType_AtkBack, atkBackTag=atkObj)
            return
        
    if not tagObj:
        return
    
    comboNum = useSkill.GetComboNum()
    aComboRate = atkObj.GetBatAttrValue(ChConfig.AttrID_ComboRate)
    aComboRate += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, tagObj, ChConfig.AttrID_ComboRate, useSkill)
    
    dComboRateDef = tagObj.GetBatAttrValue(ChConfig.AttrID_ComboRateDef)
    happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("ComboCfg", 1))
    if not GameWorld.CanHappen(happenRate):
        GameWorld.DebugLog("ÎÞ·¨Á¬»÷! atkID=%s,happenRate=%s,aComboRate=%s,dComboRateDef=%s,comboNum=%s" 
                           % (atkObj.GetID(), happenRate, aComboRate, dComboRateDef, comboNum))
        return
    GameWorld.DebugLog("¡ñ %s ¡¾Á¬»÷¡¿ happenRate=%s,aComboRate=%s,dComboRateDef=%s,comboNum=%s" 
                       % (TurnAttack.GetObjName(atkObj), happenRate, aComboRate, dComboRateDef, comboNum))
    useSkill.SetComboNum(comboNum + 1)
    
    # Á¬»÷Ìس¤
    DoHeroSpecialty(turnFight, atkObj, ChConfig.HeroSpecialty_Combo, useSkill.GetSkillID())
    
    # Á¬»÷¸ù¾Ý¼¼ÄÜÄ¿±êÅäÖÃÂß¼­ÖØÐÂÑ¡ÔñÄ¿±ê
    OnUseSkill(turnFight, atkObj, useSkill, batType=ChConfig.TurnBattleType_Combo)
    return True

def __getCanAtkBackSkill(atkObj, tagObj, useSkill):
    '''»ñÈ¡ÊÇ·ñ¿É·´»÷¼°·´»÷¼¼ÄÜ
    B½ø¹¥A1 A2 A3£¬Ö÷Ä¿±ê£¨´ÓA1 A2 A3Ñ¡£©
    Ö÷Ä¿±ê´¥·¢¸ñµ²Ê±£¬ÈôBΪ½üÕ½£¬·¢¶¯·´»÷£¬·Ç½üÕ½£¬²»·¢¶¯·´»÷£¬·´»÷ÒÔÆÕ¹¥½øÐз´»÷
    ÈôΪ·Ç¹¥»÷À࣬Ôò°´¼¼ÄÜÔ­À´µÄÄ¿±ê
    ÈôÆÕ¹¥Êǹ¥»÷À༼ÄÜÔòÐ޸ļ¼ÄÜ×ݺáΪBËùÔÚ×ݺáÇÒBΪÖ÷Ä¿±ê£¨ÓÅÏȼ¶µÍÓÚÈí¿Ø¡¢Ö¸¶¨buff״̬Ŀ±ê£¬¸ßÓÚÊôÐÔÌõ¼þÄ¿±ê£©
    '''
    if not tagObj:
        return
    
    atkID = atkObj.GetID()
    tagID = tagObj.GetID()
    if not tagObj.CanAction():
        GameWorld.DebugLog("µ±Ç°×´Ì¬ÎÞ·¨·´»÷! tagID=%s" % (tagID))
        return
    
    if atkObj.GetFaction() == tagObj.GetFaction():
        #GameWorld.DebugLog("ͬÕóÓª²»´¥·¢·´»÷!") # ÷È»ó¿ÉÄܵ¼Ö´ò×Ô¼ºÈË
        return
    
    canAtkbackDictTypeList = IpyGameDataPY.GetFuncEvalCfg("ParryCfg", 2)
    if atkObj.GetAtkDistType() not in canAtkbackDictTypeList:
        heroID = atkObj.GetHeroID()
        GameWorld.DebugLog("¹¥»÷·½Ô¶½üÀàÐÍÎ佫²»¿É·´»÷! atkID=%s,heroID=%s,AtkDistType=%s not in %s" % (atkID, heroID, atkObj.GetAtkDistType(), canAtkbackDictTypeList))
        return
    
    canAtkBack = False
    for hurtObj in useSkill.GetHurtObjListAll():
        if hurtObj.GetObjID() != tagID:
            continue
        if hurtObj.HaveHurtType(ChConfig.HurtType_Parry): # ¸ñµ²Ê±¿É·´»÷
            canAtkBack = True
            break
        
    if not canAtkBack:
        GameWorld.DebugLog("ûÓиñµ²²»¿É·´»÷! tagID=%s" % tagID)
        return
    
    # ´ó»ØºÏµ¥Î佫·´»÷´ÎÊýÏÞÖÆ
    bigTurnAtkbackCntMax = IpyGameDataPY.GetFuncCfg("ParryCfg", 4)
    if bigTurnAtkbackCntMax:
        atkbackCnt = tagObj.GetBigTurnAtkbackCnt()
        if atkbackCnt >= bigTurnAtkbackCntMax:
            GameWorld.DebugLog("±¾´ó»ØºÏÀۼƷ´»÷´ÎÊý´ïÉÏÏÞ! atkbackCnt=%s >= %s" % (atkbackCnt, bigTurnAtkbackCntMax))
            return
        
    skillManager = tagObj.GetSkillManager()
    for index in range(0, skillManager.GetSkillCount()):
        useSkill = skillManager.GetSkillByIndex(index)
        if not useSkill:
            continue
        if useSkill.GetFuncType() == ChConfig.Def_SkillFuncType_TurnNormaSkill: # ʹÓÃÆÕ¹¥·´»÷
            GameWorld.DebugLog("¿ÉÒÔ·´»÷! tagID=%s" % tagID)
            return useSkill
    return

def DoBeAttackResult(turnFight, curObj, useSkill, isUseSkill=False):
    '''±»¹¥»÷½á¹û
    @param curObj: Ê©·¨·½»òbuff¹éÊô·½
    @param isUseSkill: ÊÇ·ñÊÇÖ±½ÓʹÓü¼ÄܵĹ¥»÷½á¹û£¬·ñÔòÊÓΪ³ÖÐøÐÔµÄ
    '''
    
    #curID = curObj.GetID()
    isTurnNormalSkill = SkillCommon.isTurnNormalSkill(useSkill)
    isAngerSkill = SkillCommon.isAngerSkill(useSkill)
    
    batObjMgr = BattleObj.GetBatObjMgr()
    
    # ÓÅÏÈ´¦ÀíafterLogic£¬¿ÉÔÙÔ¤ÏÈ»ã×ÜһЩ»á´¥·¢±»¶¯µÄÐÅÏ¢
    relatedSkillID = useSkill.GetSkillID()
    shieldBrokenList = [] # ¼Ç¼¶ÜÆÆ
    afterLogicList = useSkill.GetAfterLogicList()
    for logicType, logicData in afterLogicList:
        if logicType == ChConfig.AfterLogic_DelBuff:
            buffObjID, buff, tagObjID = logicData
            buffSkillData = buff.GetSkillData()
            buffSkillTypeID = buffSkillData.GetSkillTypeID()
            TurnBuff.DoBuffDelAfterLogicOver(turnFight, buffObjID, buff, useSkill)
            if SkillCommon.isDamageShieldSkill(buffSkillData):
                shieldBrokenList.append([buffObjID, tagObjID, buffSkillTypeID])
                
        elif logicType == ChConfig.AfterLogic_AddBuff:
            batObj = logicData[0]
            buff = logicData[1]
            TurnBuff.SyncBuffRefresh(turnFight, batObj, buff, relatedSkillID, isNewAdd=True)
            
        elif logicType == ChConfig.AfterLogic_SyncBuff:
            buffObj = logicData[0]
            buff = logicData[1]
            TurnBuff.SyncBuffRefresh(turnFight, buffObj, buff, relatedSkillID)
            
    # ͳ¼Æ»÷ɱ
    killObjList = [] # »÷ɱÆäËûÕóӪĿ±êÁбí
    dieObjList = [] # ËÀÍöµÄµ¥Î»ÁÐ±í£¬°üº¬ÓÑ·½µ¥Î»»ò×Ô¼º
    tagObjList = useSkill.GetTagObjList() # Ö÷ҪĿ±êÁбí
    tagObjListEx = useSkill.GetTagObjListEx() # ¶îÍâÄ¿±êÁбí
    tagObjListAll = tagObjList + tagObjListEx
    for tagObj in tagObjListAll:
        tagID = tagObj.GetID()
        if tagObj.IsAlive() and tagObj.GetHP() <= 0:
            dieObjList.append(tagObj)
            if tagObj.GetFaction() != curObj.GetFaction():
                killObjList.append(tagObj)
            TurnAttack.SetObjKilled(turnFight, tagObj, curObj, useSkill)
    useSkill.SetKillObjList(killObjList)
    # ÅжÏ×Ô¼º£¬ÒòΪ·´µ¯¡¢Æ½Ì¯É˺¦µÄÔ­Òò£¬ÓпÉÄÜ×Ô¼º¸ÉËÀ×Ô¼º
    selfAlive = curObj.IsAlive()
    if selfAlive and curObj.GetHP() <= 0:
        selfAlive = False
        dieObjList.append(curObj)
        TurnAttack.SetObjKilled(turnFight, curObj)
        
    # ͳ¼ÆÉËѪ£¬¿ÉÄܵ¥¸ö¼¼ÄܶÔͬһĿ±êÔì³É¶à´ÎÉ˺¦
    totalHurtValue = 0
    isSuperHit, isStun, isSuckHP = False, False, False
    missObjIDList, immuneObjIDList = [], [] # ÉÁ±Ü¡¢ÃâÒ߶ÔÏóIDÁбí
    beHurtObjIDList = [] # ÊÜÉ˵ĶÔÏóIDÁбí
    for hurtObj in useSkill.GetHurtObjListAll():
        hurtObjID = hurtObj.GetObjID()
        tagObj = batObjMgr.getBatObj(hurtObjID)
        if not tagObj:
            continue
        if not hurtObj.HaveHurtType(ChConfig.HurtTYpe_Cure) and not hurtObj.HaveHurtType(ChConfig.HurtType_Immune) \
            and (isTurnNormalSkill or isAngerSkill) and tagObj.IsAlive():
            __doSkillHurtAnger(tagObj, hurtObj.GetLostHP(), useSkill)
            
        if hurtObj.HaveHurtType(ChConfig.HurtType_Normal):
            totalHurtValue += hurtObj.GetHurtHP()
            if hurtObj.GetLostHP() > 0: # ÓеôѪµÄ
                if hurtObjID not in beHurtObjIDList:
                    beHurtObjIDList.append(hurtObjID)
                    
        if hurtObj.HaveHurtType(ChConfig.HurtType_Miss):
            if hurtObjID not in missObjIDList:
                missObjIDList.append(hurtObjID)
            DoHeroSpecialty(turnFight, tagObj, ChConfig.HeroSpecialty_Miss, relatedSkillID)
            
        if hurtObj.HaveHurtType(ChConfig.HurtType_Immune):
            if hurtObjID not in immuneObjIDList:
                immuneObjIDList.append(hurtObjID)
                
        if hurtObj.HaveHurtType(ChConfig.HurtType_Parry):
            DoHeroSpecialty(turnFight, tagObj, ChConfig.HeroSpecialty_Parry, relatedSkillID)
            
        if hurtObj.HaveHurtType(ChConfig.HurtType_SuperHit):
            isSuperHit = True
            
        if hurtObj.HaveHurtType(ChConfig.HurtType_Stun):
            isStun = True
            
        if hurtObj.GetSuckHP() > 0:
            isSuckHP = True
            
    # ¼Ç¼×îºóÒ»´Î×ÜÉ˺¦£¬ÓÐÉ˺¦Ä¿±ê²Å¼Ç¼
    if totalHurtValue:
        curObj.SetLastHurtValue(totalHurtValue)
        
    # Ⱥ¹¥Ö»´¥·¢Ò»´ÎÌس¤
    if isSuperHit:
        DoHeroSpecialty(turnFight, curObj, ChConfig.HeroSpecialty_SuperHit, relatedSkillID)
    if isStun:
        DoHeroSpecialty(turnFight, curObj, ChConfig.HeroSpecialty_Stun, relatedSkillID)
    if isSuckHP:
        DoHeroSpecialty(turnFight, curObj, ChConfig.HeroSpecialty_SuckHP, relatedSkillID)
        
    # ½áË㸱±¾Ïà¹ØµÄ¹¥»÷½á¹û£¬½öÖ÷¶¯·¢ÆðÍæ¼ÒÕóÈÝÎ佫´¥·¢
    curPlayer = turnFight.curPlayer
    if curPlayer and curObj and curObj.GetOwnerID() == curPlayer.GetPlayerID():
        FBLogic.OnPlayerLineupAttackResult(curPlayer, curObj, killObjList, useSkill, turnFight.mapID, turnFight.funcLineID)
        
    effIgnoreObjIDList = missObjIDList + immuneObjIDList
    useSkill.SetEffIgnoreObjIDList(effIgnoreObjIDList)
    # ÓÅÏÈ´¥·¢±¾¼¼ÄܶîÍâЧ¹û£¬×¢£º½ö¸Ã¼¼ÄÜÊͷźó¸Ã¼¼ÄܵĶîÍâЧ¹ûÊÓΪÖ÷¼¼ÄܵÄЧ¹û£¬ÓÅÏȼ¶×î¸ß
    if selfAlive:
        __DoCurSkillEff(turnFight, curObj, useSkill, effIgnoreObjIDList, isUseSkill)
    
    # ========== ÒÔÏ´¥·¢±»¶¯ ==========
    
    # ÆƶÜʱ
    for buffObjID, tagObjID, buffSkillTypeID in shieldBrokenList:
        buffObj = batObjMgr.getBatObj(buffObjID)
        tagObj = batObjMgr.getBatObj(tagObjID)
        TurnPassive.OnTriggerPassiveEffect(turnFight, buffObj, ChConfig.TriggerWay_ShieldBroken, tagObj, connSkillTypeID=buffSkillTypeID)
        
    # Óл÷ɱʱ
    for index, tagObj in enumerate(killObjList):
        if index == 0:
            TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_KillOneObj, tagObj, connSkill=useSkill)
        TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_KillTagObj, tagObj, connSkill=useSkill)
        
    if dieObjList:
        for faction in [ChConfig.Def_FactionA, ChConfig.Def_FactionB]:
            batFaction = turnFight.getBatFaction(faction)
            for lineupNum in batFaction.lineupDict.keys():
                batLineup = batFaction.getBatlineup(lineupNum)
                for lineupObjID in batLineup.posObjIDDict.values():
                    lineupObj = batObjMgr.getBatObj(lineupObjID)
                    if not lineupObj.IsAlive():
                        continue
                    for dieObj in dieObjList:
                        # µÐ·½µ¥Î»ËÀÍöʱ
                        if lineupObj.GetFaction() != dieObj.GetFaction():
                            TurnPassive.OnTriggerPassiveEffect(turnFight, lineupObj, ChConfig.TriggerWay_EnemyDie, dieObj, connSkill=useSkill)
                        # ¼º·½µ¥Î»ËÀÍöʱ
                        else:
                            TurnPassive.OnTriggerPassiveEffect(turnFight, lineupObj, ChConfig.TriggerWay_FriendDie, dieObj, connSkill=useSkill)
                            
    triggerOne = False
    batType = useSkill.GetBatType()
    isAttackDirect = (isUseSkill and SkillCommon.isAttackDirectSkill(useSkill)) # ÊÇ·ñÖ±½Ó¹¥»÷
    for tagObj in tagObjListAll:
        tagID = tagObj.GetID()
        if tagID in effIgnoreObjIDList:
            continue
        
        isExObj = tagObj in tagObjListEx # ÊÇ·ñ¶îÍâÄ¿±ê
        
        # µôѪʱ
        if tagID in beHurtObjIDList:
            TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeHurt, curObj, connSkill=useSkill)
            
        # Ö±½Ó¹¥»÷
        if isAttackDirect and not isExObj:
            if not triggerOne:
                TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_AttackOverDirectOne, tagObj, connSkill=useSkill)
            TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_AttackOverDirect, tagObj, connSkill=useSkill)
            TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeAttackedDirect, curObj, connSkill=useSkill)
        # ³ÖÐøÉ˺¦
        elif not isAttackDirect:
            TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeAnyEffect, curObj, connSkill=useSkill)
            # Êܵ½³ÖÐøÉ˺¦
            if tagID in beHurtObjIDList and not isExObj:
                TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeDOTHurt, curObj, connSkill=useSkill)
                
        # ʹÓü¼Äܺó
        if isUseSkill and not isExObj:
            if not triggerOne:
                TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_UseSkillOverOne, tagObj, connSkill=useSkill)
            TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_UseSkillOver, tagObj, connSkill=useSkill)
            
        # Á¬»÷
        if batType == ChConfig.TurnBattleType_Combo and not isExObj:
            TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeCombo, curObj, connSkill=useSkill)
        # ×·»÷
        elif batType == ChConfig.TurnBattleType_Pursue and not isExObj:
            TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BePursue, curObj, connSkill=useSkill)
            
        triggerOne = True # ÉèÖÃÒѾ­´¥·¢¹ýÒ»´Î
        
    # ÑéÖ¤ÊÇ·ñ½áË㣬×îºó´¦Àí
    if dieObjList:
        turnFight.checkOverByKilled()
        
    return

def __doCostZhanchui(turnFight, curBatObj, useSkill):

    turnFight.mapID
    if turnFight.mapID != ChConfig.Def_FBMapID_Main:
        ## ½öÖ÷ÏßÕ½¶·ÐèÒª
        return
    
    curPlayer = turnFight.curPlayer
    if not curPlayer:
        return
    # ½öÖ÷¶¯·¢ÆðÍæ¼ÒÕóÈÝÎ佫Êͷż¼ÄÜÐèÒªÏûºÄ
    if curBatObj.GetOwnerID() != curPlayer.GetPlayerID():
        return
    
    costZhanchui = 0
    batType = useSkill.GetBatType()
    if batType != ChConfig.TurnBattleType_Normal:
        # Ôݶ¨½ö³£¹æÖ÷¶¯µã»÷ÐÐΪµÄÐèÒª¿Û³ýÕ½´¸£¨ÓëÇ°¶ËÊÖ¶¯Õ½¶·µã»÷µÄ´¥·¢µãͬ²½£©£¬±»¶¯´¥·¢µÄÔݶ¨²»¿Û
        return
    
    if SkillCommon.isAngerSkill(useSkill):
        costZhanchui = IpyGameDataPY.GetFuncCfg("ZhanchuiCost", 2)
    elif SkillCommon.isTurnNormalSkill(useSkill):
        costZhanchui = IpyGameDataPY.GetFuncCfg("ZhanchuiCost", 1)
        
    if costZhanchui <= 0:
        return
    
    fightPoint = max(curPlayer.GetFightPoint(), 1) # Ö÷ÏßÕ½¶·ÏûºÄ±¶Öµ£¬Ä¬ÈÏ1
    costZhanchuiTotal = costZhanchui * fightPoint
    if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, costZhanchuiTotal, isNotify=False):
        # ²»×ãʱ£¬ÓжàÉÙ¿Û¶àÉÙ
        nowMoney = PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao)
        PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, min(nowMoney, costZhanchuiTotal), isNotify=False)
        
    return

def __doSkillUserAnger(turnFight, curBatObj, useSkill):
    ## ¼¼ÄÜÊÍ·ÅÕßÅ­ÆøÏà¹Ø
    if SkillCommon.isAngerSkill(useSkill):
        curBatObj.SetXP(0)
    elif SkillCommon.isTurnNormalSkill(useSkill) and useSkill.GetBatType() == ChConfig.TurnBattleType_Normal:
        addXP = IpyGameDataPY.GetFuncCfg("AngerXP", 3)
        AddTurnFightXP(curBatObj, addXP, "skillID:%s" % useSkill.GetSkillID())
    return

def __doSkillHurtAnger(batObj, lostHP, useSkill):
    ## ½áËãÊÜÉËÕßÅ­Æø
    if lostHP <= 0:
        return
    addXP = IpyGameDataPY.GetFuncCfg("AngerXP", 4)
    if addXP <= 0:
        return
    AddTurnFightXP(batObj, addXP, "skillID:%s" % useSkill.GetSkillID())
    return

def AddTurnFightXP(gameObj, addXP, reason=""):
    ## »ØºÏÕ½¶·Ôö¼ÓXP
    if addXP <= 0 or not addXP:
        #GameWorld.DebugLog("        ûÓÐÔö¼ÓXP! curID=%s" % (gameObj.GetID()))
        return
    posNum = gameObj.GetPosNum()
    if posNum <= 0:
        #·ÇÖ÷Õ½µ¥Î»²»¼Ó
        return
    addXP = GetEnhanceXP(gameObj, addXP)
    curXP = gameObj.GetXP()
    updXP = curXP + addXP
    gameObj.SetXP(updXP)
    GameWorld.DebugLog("        ¸üÐÂXP: curID=%s,curXP=%s,addXP=%s,updXP=%s,reason=%s" % (gameObj.GetID(), curXP, addXP, updXP, reason))
    return

def DoHeroSpecialty(turnFight, gameObj, specialty, relatedSkillID=0):
    ## Ö´ÐÐÎ佫Ìس¤
    if gameObj.GetSpecialty() != specialty:
        return
    specialtyAddXPDict = IpyGameDataPY.GetFuncEvalCfg("AngerXP", 5, {})
    if str(specialty) not in specialtyAddXPDict:
        return
    if not gameObj.IsAlive():
        return
    addXP = specialtyAddXPDict[str(specialty)]
    addXP = GetEnhanceXP(gameObj, addXP)
    curXP = gameObj.GetXP()
    updXP = curXP + addXP
    gameObj.SetXP(updXP, False)
    GameWorld.DebugLog("        Ìس¤¼ÓXP: curID=%s,curXP=%s,addXP=%s,updXP=%s,ÌØÐÔ=%s" % (gameObj.GetID(), curXP, addXP, updXP, specialty))
    Sync_PropertyRefreshView(turnFight, gameObj, ChConfig.AttrID_XP, updXP, addXP, diffType=1, relatedSkillID=relatedSkillID)
    return

def GetEnhanceXP(gameObj, addXP):
    ## »ñÈ¡ÌáÉýºóµÄxpÖµ
    addPer = gameObj.GetBatAttrValue(ChConfig.AttrID_XPRecoverPer)
    # ÆäËûÇ¿»¯¡¢Èõ»¯
    if addPer == 0:
        return addXP
    objID = gameObj.GetID()
    updAddXP = int(addXP * max(10000 + addPer, 0) / 10000.0)
    GameWorld.DebugLog("Å­Æø»Ö¸´ÌáÉý: objID=%s,addXP=%s,addPer=%s,updAddXP=%s" % (objID, addXP, addPer, updAddXP))
    return updAddXP

def __DoCurSkillEff(turnFight, curObj, useSkill, effIgnoreObjIDList, isUseSkill):
    ## Ö´Ðб¾¼¼ÄÜ/buffÊͷźó¶îÍâЧ¹û
    for index in xrange(useSkill.GetEffectCount()):
        curEffect = useSkill.GetEffect(index)
        triggerWay = curEffect.GetTriggerWay()
        if isUseSkill:
            if triggerWay != ChConfig.TriggerWay_CurSkillEff:
                continue
        else:
            if triggerWay != ChConfig.TriggerWay_CurSkillEffLst:
                continue
            
        effID = curEffect.GetEffectID()
        GameWorld.DebugLog("¡ñÖ´ÐжîÍâ¼¼ÄÜЧ¹û: skillID=%s,effID=%s, triggerWay=%s,effIgnoreObjIDList=%s" % (useSkill.GetSkillID(), effID, triggerWay, effIgnoreObjIDList))
        if effID == 5010:
            # ¶îÍâ¼¼ÄÜЧ¹û
            __doUseEnhanceSkill(turnFight, curObj, useSkill, curEffect, effIgnoreObjIDList)
            continue
        
        for tagObj in useSkill.GetTagObjList():
            tagID = tagObj.GetID()
            if tagID in effIgnoreObjIDList:
                # ÉÁ±ÜÁ˲»´¥·¢
                continue
            
            TurnPassive.DoSkillEffectLogic(turnFight, curObj, tagObj, useSkill, curEffect, useSkill)
            
    return

def __doUseEnhanceSkill(turnFight, curBatObj, useSkill, curEffect, effIgnoreObjIDList):
    ## Ö´ÐÐÖ÷¼¼ÄܵĶîÍâ¼¼ÄÜЧ¹û
    #if useSkill.GetBatType() == ChConfig.TurnBattleType_Enhance:
    #    #GameWorld.DebugLog("×ÔÉíΪ¶îÍâ´¥·¢µÄ¼¼Äܲ»ÔÙ´¥·¢¶îÍâ¼¼ÄÜ! skillID=%s" % useSkill.GetSkillID())
    #    return
    enhanceSkillID = curEffect.GetEffectValue(0)
    checkInStateList = curEffect.GetEffectValue(1)
    checkHeroJob = curEffect.GetEffectValue(2)
    GameWorld.DebugLog("¶îÍâ´¥·¢µÄ¼¼ÄÜ: enhanceSkillID=%s,checkInStateList=%s£¬checkHeroJob=%s" % (enhanceSkillID, checkInStateList, checkHeroJob))
    tagObjList = useSkill.GetTagObjList()
    
    enhanceSkillData = IpyGameDataPY.GetIpyGameData("Skill", enhanceSkillID)
    if not enhanceSkillData:
        return
    
    killObjList = useSkill.GetKillObjList()
    if killObjList:
        invalidSkillID = TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_SkillInvalid, useSkill,
                                                           triggerWay=ChConfig.TriggerWay_KillOneObj)
        if invalidSkillID and invalidSkillID == enhanceSkillID:
            GameWorld.DebugLog("Óл÷ɱĿ±êʱ¸Ã¼¼ÄÜÎÞЧ! enhanceSkillID=%s" % enhanceSkillID)
            return
        
    # ¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê
    if enhanceSkillData.GetTagAim() == ChConfig.SkillTagAim_MainSkill:
        GameWorld.DebugLog("¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê! enhanceSkillID=%s" % enhanceSkillID)
        # ¶îÍâ´¥·¢µÄ¼¼ÄÜÖ±½ÓÔÚÍâ²ã¼ì²é¸ÅÂÊ£¬Èç¹û¶¼Ã»Óд¥·¢Ôò²»ÐèÒªÔÙ´¦Àí
        enhanceRate = enhanceSkillData.GetHappenRate()
        enhanceRate += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddSkillRate, connSkillTypeID=enhanceSkillData.GetSkillTypeID())
        enchanceTagObjList = []
        for tagObj in tagObjList:
            tagID = tagObj.GetID()
            if not tagObj.IsAlive():
                GameWorld.DebugLog("    Òѱ»»÷ɱ²»´¥·¢: tagID=%s" % (tagID))
                continue
            if tagID in effIgnoreObjIDList:
                GameWorld.DebugLog("    ÉÁ±Ü»òÃâÒߵIJ»´¥·¢: tagID=%s" % (tagID))
                continue
            if checkInStateList:
                if not tagObj.CheckInState(checkInStateList):
                    GameWorld.DebugLog("    ²»ÔÚ״̬ϲ»´¥·¢: tagID=%s not in state:%s" % (tagID, checkInStateList))
                    continue
            if checkHeroJob and checkHeroJob != tagObj.GetJob():
                GameWorld.DebugLog("    ·ÇÄ¿±êÖ°Òµ²»´¥·¢: tagID=%s,job=%s != %s" % (tagID, tagObj.GetJob(), checkHeroJob))
                continue
            if enhanceRate and enhanceRate != ChConfig.Def_MaxRateValue and not GameWorld.CanHappen(enhanceRate, ChConfig.Def_MaxRateValue):
                GameWorld.DebugLog("    ¸ÅÂʲ»´¥·¢: tagID=%s,enhanceRate=%s" % (tagID, enhanceRate))
                continue
            
            enchanceTagObjList.append(tagObj)
            
        if enchanceTagObjList:
            OnUseSkill(turnFight, curBatObj, enhanceSkillData, enchanceTagObjList, batType=ChConfig.TurnBattleType_Enhance, bySkill=useSkill)
            
        return
    
    # Ö»Ö´ÐÐÒ»´Î£¬·ÀֹȺ¹¥Ê±¶îÍâ´¥·¢¶à´Î
    GameWorld.DebugLog("ÖØÐÂËø¶¨Ä¿±ê! enhanceSkillID=%s" % enhanceSkillID)
    if checkInStateList or checkHeroJob:
        inState, haveJob = False, False
        for tagObj in tagObjList:
            tagID = tagObj.GetID()
            if tagID in effIgnoreObjIDList:
                continue
            if not inState and tagObj.CheckInState(checkInStateList):
                inState = True
            if not haveJob and checkHeroJob and checkHeroJob == tagObj.GetJob():
                haveJob = True
        if checkInStateList and not inState:
            GameWorld.DebugLog("    ûÓÐÃüÖÐÄ¿±êÔÚ״̬ϲ»´¥·¢: tagObj not in state:%s" % str(checkInStateList))
            return
        if checkHeroJob and not haveJob:
            GameWorld.DebugLog("    ûÓÐÃüÖÐÄ¿±êΪĿ±êÖ°Òµ²»´¥·¢: checkHeroJob=%s" % checkHeroJob)
            return
    OnUseSkill(turnFight, curBatObj, enhanceSkillData, batType=ChConfig.TurnBattleType_Enhance, bySkill=useSkill)
    return

def OnUsePassiveSkill(turnFight, batObj, tagObj, passiveSkill, connSkill=None, effSkillID=0, effectID=0, connBuff=None):
    '''±»¶¯´¥·¢Ê¹Óü¼ÄÜ
    @param passiveSkill: Êͷŵı»¶¯¼¼ÄÜ
    @param connSkill: ÓÉʲô¼¼ÄÜÒýÆðµÄ
    @param effSkillID: ±»¶¯Ð§¹ûËùÊôµÄ¼¼ÄÜID
    @param effectID: ±»¶¯Ð§¹ûID
    ×¢£º¿ÉÄÜÓÉAÒýÆð´¥·¢B¼¼ÄܵÄЧ¹ûÊͷż¼ÄÜC
    '''
    if not passiveSkill:
        return
    bySkillID = 0
    if connSkill:
        bySkillID = connSkill.GetSkillID()
    elif connBuff:
        bySkillID = connBuff.GetSkillID()
    passiveSkillID = passiveSkill.GetSkillID()
    if passiveSkillID == bySkillID:
        #GameWorld.DebugLog("###±»¶¯´¥·¢¼¼Äܲ»´¥·¢×ÔÉí£¬·ÀÖ¹ËÀÑ­»·! effSkillID=%s,effectID=%s,passiveSkillID=%s" % (effSkillID, effectID, passiveSkillID))
        return
    
    if hasattr(passiveSkill, "GetRemainTime") and passiveSkill.GetRemainTime() > 0:
        #GameWorld.DebugLog("±»¶¯´¥·¢¼¼ÄÜCDÖÐ! skillID=%s,RemainTime=%s" % (passiveSkillID, passiveSkill.GetRemainTime()))
        return
    
    isOK = False
    # ¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê
    if passiveSkill.GetTagAim() == ChConfig.SkillTagAim_MainSkill:
        happenRate = passiveSkill.GetHappenRate()
        happenRate += TurnPassive.GetTriggerEffectValue(turnFight, batObj, None, ChConfig.PassiveEff_AddSkillRate, passiveSkill)
        GameWorld.DebugLog("±»¶¯´¥·¢¼¼ÄÜ£¬¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê! effSkillID=%s,effectID=%s,passiveSkillID=%s,happenRate=%s,bySkillID=%s" % (effSkillID, effectID, passiveSkillID, happenRate, bySkillID))
        if not tagObj:
            return
        tagID = tagObj.GetID()
        if not tagObj.IsAlive():
            GameWorld.DebugLog("    Òѱ»»÷ɱ²»´¥·¢: tagID=%s" % (tagID))
            return
        if happenRate and not GameWorld.CanHappen(happenRate, ChConfig.Def_MaxRateValue):
            GameWorld.DebugLog("    ¸ÅÂʲ»´¥·¢: tagID=%s,happenRate=%s" % (tagID, happenRate))
            return
        passiveTagObjList = [tagObj]
        isOK = OnUseSkill(turnFight, batObj, passiveSkill, passiveTagObjList, batType=ChConfig.TurnBattleType_Passive, bySkill=connSkill, byBuff=connBuff)
    else:
        GameWorld.DebugLog("±»¶¯´¥·¢¼¼ÄÜ£¬ÖØÐÂËø¶¨Ä¿±ê! effSkillID=%s,effectID=%s,passiveSkillID=%s,bySkillID=%s" % (effSkillID, effectID, passiveSkillID, bySkillID))
        isOK = OnUseSkill(turnFight, batObj, passiveSkill, batType=ChConfig.TurnBattleType_Passive, bySkill=connSkill, byBuff=connBuff)
        
    return isOK

def CalcFormatHurt(turnFight, atkObj, defObj, curSkill, atkSkillValue, atkSkillPer, **kwargs):
    '''°´¹«Ê½¼ÆËãÉ˺¦£¬Ä¬ÈÏ°´¹¥»÷¼ÆËã
    '''
    
    mapID = turnFight.mapID
    skillID = curSkill.GetSkillID()
    pmType = GetPMType(atkObj, curSkill)
    ignoreDef = IsIgnoreDef(curSkill)
    batType = curSkill.GetBatType()
    
    changeHurtType = TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_ChangeHurtType, curSkill)
    if changeHurtType == 1:
        ignoreDef = True
        GameWorld.DebugLog("Ç¿ÖƱä¸ü±¾´ÎÉ˺¦ÎªÎÞÊÓ·ÀÓù! skillID=%s" % skillID)
        
    atkID = atkObj.GetID()
    defID = defObj.GetID()
    
    calcType = curSkill.GetCalcType() # É˺¦¼ÆË㷽ʽ 0-°´¹¥»÷
    isTurnNormalSkill = SkillCommon.isTurnNormalSkill(curSkill)
    isAngerSkill = SkillCommon.isAngerSkill(curSkill)
    isDot = ("damageoftime" in kwargs)
    angerOverflow = 0 # Å­ÆøÒç³öÖµ
    
    mustHit = False # ÊÇ·ñ±ØÃüÖÐ
    if not isTurnNormalSkill: # ½öÆÕ¹¥ÅжÏÊÇ·ñÉÁ±Ü
        mustHit = True
        
    if isAngerSkill:
        curXP = atkObj.GetXP()
        angerOverflow = max(atkObj.GetXP() - IpyGameDataPY.GetFuncCfg("AngerXP", 2), 0)
        GameWorld.DebugLog("Å­¼¼¹¥»÷! curXP=%s,angerOverflow=%s" % (curXP, angerOverflow))
        
    #ÃüÖй«Ê½ ¹¥»÷·½ÀàÐͲ»Í¬£¬¹«Ê½²»Í¬
    if not mustHit and not curSkill.GetEffectByID(ChConfig.SkillEff_MustHit) and not defObj.IsInControlledHard():
        aMissRateDef = atkObj.GetBatAttrValue(ChConfig.AttrID_MissRateDef) #atkObj.GetHit() # ¿¹ÉÁ±ÜÂÊ - ÃüÖÐ
        dMissRate = defObj.GetBatAttrValue(ChConfig.AttrID_MissRate) # ÉÁ±ÜÂÊ
        missNum = curSkill.GetTagMissNum(defID)
        missRate = eval(IpyGameDataPY.GetFuncCompileCfg("MissCfg", 1))
        if GameWorld.CanHappen(missRate):
            GameWorld.DebugLog("ÉÁ±ÜÁË! missRate=%s,dMissRate=%s,aMissRateDef=%s,missNum=%s" % (missRate, dMissRate, aMissRateDef, missNum))
            curSkill.SetTagMissNum(defID, missRate + 1)
            return 0, pow(2, ChConfig.HurtType_Miss)
        
    hurtTypes = pow(2, ChConfig.HurtType_Normal)
    
    isSuperHit, isParry, isStun = False, False, False
    aSuperDamPer, dSuperDamPerDef = 0, 0
    # ±©»÷£¨dot³ýÍ⣩
    if not isDot:
        isSuperHit = CanSuperHit(turnFight, atkObj, defObj, curSkill) # ÊÇ·ñ±©»÷
        
    # ÉÁ±Ü¡¢»÷ÔΡ¢¸ñµ²
    if isTurnNormalSkill:
        isParry = CanParry(turnFight, atkObj, defObj, curSkill) # ÊÇ·ñ¸ñµ²
        isStun = CanStun(turnFight, atkObj, defObj, curSkill) # ÊÇ·ñ»÷ÔÎ
        
    if isSuperHit:
        hurtTypes |= pow(2, ChConfig.HurtType_SuperHit)
        aSuperDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_SuperDamPer)
        aSuperDamPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_SuperDamPer, curSkill)
        
        dSuperDamPerDef = atkObj.GetBatAttrValue(ChConfig.AttrID_SuperDamPerDef)
        
    if isParry:
        hurtTypes |= pow(2, ChConfig.HurtType_Parry)
        
    if ignoreDef:
        GameWorld.DebugLog("ÎÞÊÓ·ÀÓù/ÕæʵÉ˺¦!")
        hurtTypes |= pow(2, ChConfig.HurtType_IgnoreDef)
        
    if isStun:
        hurtTypes |= pow(2, ChConfig.HurtType_Stun)
        
    #²ÎÓëÔËËãµÄÊýÖµ
    #rand = random.random()                #ÖÖ×ÓÊý 0~1
    
    aAtk = atkObj.GetAtk() # ¹¥»÷·½×î´ó¹¥»÷
    
    dHP, dMaxHP = defObj.GetHP(), defObj.GetMaxHP()
    dDef = 0 if ignoreDef else defObj.GetDef() # ·ÀÊØ·½·ÀÓùÁ¦
    
    atkSkillPer += GetAddSkillPer(turnFight, atkObj, defObj, curSkill)
    
    aFinalDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_FinalDamPer) # ×îÖÕ¼Ó³É
    dFinalDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_FinalDamPerDef) # ×îÖÕ¼õÉË
    
    aFinalDamPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddFinalDamPer, curSkill)
    
    aNormalSkillPer, dNormalSkillPerDef = 0, 0
    if isTurnNormalSkill:
        aNormalSkillPer = atkObj.GetBatAttrValue(ChConfig.AttrID_NormalSkillPer) # ÆÕ¼¼ÔöÉË
        dNormalSkillPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_NormalSkillPerDef) # ÆÕ¼¼¼õÉË
        
    aAngerSkillPer, dAngerSkillPerDef = 0, 0
    if isAngerSkill:
        aAngerSkillPer = atkObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPer) # Å­¼¼ÔöÉË
        aAngerSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddAngerSkillPerByXP, curSkill)
        
        dAngerSkillPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPerDef) # Å­¼¼¼õÉË
        
    aAddSkillPer = 0 # ¼¼ÄÜÔöÉË
    aAddSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_SkillPer, curSkill)
    
    # Îï·¨Ôö¼õÉË
    if pmType == IPY_GameWorld.ghtMag: # ·¨ÉË
        aPMDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_MagDamPer)
        dPMDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_MagDamPerDef)
    else: # ÎïÉË
        aPMDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_PhyDamPer) 
        dPMDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_PhyDamPerDef)
        
    aComboDamPer = 0 # Á¬»÷ÔöÉË
    if batType == ChConfig.TurnBattleType_Combo:
        aComboDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_ComboDamPer)
        
    aPursueDamPer = 0 # ×·»÷ÔöÉË
    if batType == ChConfig.TurnBattleType_Pursue:
        aPursueDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_PursueDamPer)
        
    aArenaDamPer, dArenaDamPerDef = 0, 0 # ¾º¼¼ÔöÉË¡¢¾º¼¼¼õÉË
    if mapID == ChConfig.Def_FBMapID_ArenaBattle:
        aArenaDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_ArenaDamPer)
        dArenaDamPerDef = atkObj.GetBatAttrValue(ChConfig.AttrID_ArenaDamPerDef)
        
    # ËùÓÐÍò·ÖÂʲÎÊýͳһ³ý10000.0
    atkSkillPer /= 10000.0
    aNormalSkillPer /= 10000.0
    dNormalSkillPerDef /= 10000.0
    aAngerSkillPer /= 10000.0
    dAngerSkillPerDef /= 10000.0
    aAddSkillPer /= 10000.0
    aPMDamPer /= 10000.0
    dPMDamPerDef /= 10000.0
    aSuperDamPer /= 10000.0
    dSuperDamPerDef /= 10000.0
    aFinalDamPer /= 10000.0
    dFinalDamPerDef /= 10000.0
    aComboDamPer /= 10000.0
    aPursueDamPer /= 10000.0
    aArenaDamPer /= 10000.0
    dArenaDamPerDef /= 10000.0
    
    if calcType != ChConfig.Def_Calc_Attack:
        aAtk = GetCalcBaseValue(calcType, atkObj, defObj, curSkill)
    GameWorld.DebugLog("ÉËѪ¼ÆËã: atkID=%s,defID=%s,skillID=%s,atkSkillPer=%s,calcType=%s,aAtk=%s,dDef=%s,dHP=%s/%s,hurtTypes=%s,aAddSkillPer=%s,aFinalDamPer=%s" 
                       % (atkID, defID, skillID, atkSkillPer, calcType, aAtk, dDef, dHP, dMaxHP, hurtTypes, aAddSkillPer, aFinalDamPer))
    
    if isTurnNormalSkill:
        hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 1))
        GameWorld.DebugLog("    ÆÕ¹¥¼¼ÄÜÉ˺¦=%s,aNormalSkillPer=%s,dNormalSkillPerDef=%s" % (hurtValue, aNormalSkillPer, dNormalSkillPerDef))
    elif isAngerSkill:
        hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 2))
        GameWorld.DebugLog("    Å­Æø¼¼ÄÜÉ˺¦=%s,aAngerSkillPer=%s,dAngerSkillPerDef=%s" % (hurtValue, aAngerSkillPer, dAngerSkillPerDef))
    elif isDot:
        hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("DOTFormula", 1))
        GameWorld.DebugLog("    ³ÖÐø¼¼ÄÜÉ˺¦=%s" % (hurtValue))
    elif calcType == ChConfig.Def_Calc_ByBuffValue:
        hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("CalcTypeFormula", 2))
        GameWorld.DebugLog("    °´×îºóÒ»´ÎbuffÖµ¼ÆËãÉ˺¦=%s,calcType=%s,LastHurt=%s" % (hurtValue, calcType, aAtk))
    elif calcType != ChConfig.Def_Calc_Attack:
        hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("CalcTypeFormula", 1))
        GameWorld.DebugLog("    ·Ç°´¹¥»÷Á¦É˺¦=%s,calcType=%s,aAtk=%s" % (hurtValue, calcType, aAtk))
    else:
        hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 4))
        GameWorld.DebugLog("    ÆäËûÉ˺¦=%s" % (hurtValue))
        
    if isParry:
        parryReduceRatio = IpyGameDataPY.GetFuncCfg("ParryCfg", 3)
        hurtValue = hurtValue * (1 - parryReduceRatio)
        GameWorld.DebugLog("    ¸ñµ²ºóÉ˺¦=%s,parryReduceRatio=%s" % (hurtValue, parryReduceRatio))
        
    multiValue = TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_ChangeHurtMulti, curSkill)
    if multiValue and multiValue != 1:
        hurtValue = int(hurtValue * multiValue)
        GameWorld.DebugLog("    É˺¦±¶Öµ: hurtValue=%s,multiValue=%s" % (hurtValue, multiValue))
        
    hurtAtkPerMax = curSkill.GetHurtAtkPerMax() # ×î´óÍò·Ö±È£¬ÏÞÖÆ×îÖÕÉ˺¦²»³¬¹ý¹¥»÷Á¦Íò·ÖÂÊ
    if hurtAtkPerMax:
        aAtk = atkObj.GetAtk()
        hurtValueMax = aAtk * hurtAtkPerMax / 10000.0
        hurtValue = min(hurtValue, hurtValueMax)
        GameWorld.DebugLog("    É˺¦×î¸ßÏÞÖÆ: hurtValue=%s,hurtAtkPerMax=%s,aAtk=%s" % (hurtValue, hurtAtkPerMax, aAtk))
        
    # ¾ù̯
    hurtShareEff = curSkill.GetEffectByID(ChConfig.SkillEff_HurtShare)
    if hurtShareEff:
        tagCnt = max(1, len(curSkill.GetTagObjList()))
        hurtValue = hurtValue / tagCnt
        GameWorld.DebugLog("    Ä¿±ê¾ù̯É˺¦: hurtValue=%s,tagCnt=%s" % (hurtValue, tagCnt))
        
    hurtValue = max(1, int(hurtValue)) # ¸ºÖµ¡¢±£µ×·À·¶£¬·Å×îºó
    return hurtValue, hurtTypes

def GetAddSkillPer(turnFight, atkObj, defObj, curSkill):
    ## »ñÈ¡¶îÍâÔö¼ÓµÄ¼¼ÄÜÍò·Ö±È
    atkSkillPer = 0
    atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPer, curSkill)
    atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByHP, curSkill)
    atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByJob, curSkill)
    atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByBuffLayer, curSkill)
    atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByDeadTeammate, curSkill)
    return atkSkillPer

def CanSuperHit(turnFight, atkObj, defObj, curSkill):
    if TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_MustSuperHit, curSkill):
        GameWorld.DebugLog("Ä¿±êѪÁ¿µÍÓÚ°Ù·Öxʱ±Ø¶¨±©»÷: defID=%s,hp:%s/%s" % (defObj.GetID(), defObj.GetHP(), defObj.GetMaxHP()))
        return True
    
    aSuperHitRate = atkObj.GetBatAttrValue(ChConfig.AttrID_SuperHitRate)
    aSuperHitRate += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_SuperHitRate, curSkill)
    dSuperHitRateDef = defObj.GetBatAttrValue(ChConfig.AttrID_SuperHitRateDef)
    happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("SuperHitCfg", 1))
    if GameWorld.CanHappen(happenRate):
        GameWorld.DebugLog("±©»÷ÁË: happenRate=%s,aSuperHitRate=%s,dSuperHitRateDef=%s" % (happenRate, aSuperHitRate, dSuperHitRateDef))
        return True
    return False

def CanStun(turnFight, atkObj, defObj, curSkill):
    aStunRate = atkObj.GetBatAttrValue(ChConfig.AttrID_StunRate)
    aStunRate += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_StunRate, curSkill)
    dStunRateDef = defObj.GetBatAttrValue(ChConfig.AttrID_StunRateDef)
    happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("StunCfg", 1))
    if not GameWorld.CanHappen(happenRate):
        return False
    stunSkillID = IpyGameDataPY.GetFuncCfg("StunCfg", 2)
    if TurnBuff.DoAddBuffBySkillID(turnFight, defObj, stunSkillID, atkObj, curSkill, afterLogic=True):
        GameWorld.DebugLog("»÷ÔÎÁË: happenRate=%s,aStunRate=%s,dStunRateDef=%s" % (happenRate, aStunRate, dStunRateDef))
        return True
    return False

def CanParry(turnFight, atkObj, defObj, curSkill):
    if defObj.IsInControlledHard():
        #±»Ó²¿ØÎÞ·¨¸ñµ²
        return False
    
    defID = defObj.GetID()
    # ¸ñµ²Ó¡¼Ç
    buffMgr = defObj.GetBuffManager()
    parryYJBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_ParryYJ)
    if parryYJBuff and parryYJBuff.GetLayer():
        GameWorld.DebugLog("¸ñµ²Ó¡¼Ç¸ñµ²ÁË: buffID=%s,buffLayer=%s" % (parryYJBuff.GetBuffID(), parryYJBuff.GetLayer()))
        TurnBuff.DoBuffLayerChange(turnFight, defObj, parryYJBuff, parryYJBuff.GetLayer() - 1, curSkill)
        return True
    
    aParryRateDef = atkObj.GetBatAttrValue(ChConfig.AttrID_ParryRateDef)
    dParryRate = defObj.GetBatAttrValue(ChConfig.AttrID_ParryRate)
    parryNum = curSkill.GetTagParryNum(defID)
    happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("ParryCfg", 1))
    if GameWorld.CanHappen(happenRate):
        GameWorld.DebugLog("¸ñµ²ÁË: happenRate=%s,aParryRateDef=%s,dParryRate=%s,parryNum=%s" % (happenRate, aParryRateDef, dParryRate, parryNum))
        curSkill.SetTagParryNum(defID, parryNum + 1)
        return True
    return False

def CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes=0):
    '''¼ÆËãbuffÓ°ÏìµÃµ½×îÖÕÉ˺¦: ÈçÎ޵С¢Ôö¼õÉ˶ܵÈ
    @param hurtValue: ¹«Ê½¼ÆËãµÄÉ˺¦Öµ
    @return: hurtValue, hurtTypes, immuneHurt
    '''
    
    immuneHurt = 0 # ÃâÒßÉ˺¦Öµ
    if hurtValue <= 0:
        hurtValue = 0
        return hurtValue, hurtTypes, immuneHurt
    
    hurtValue = int(hurtValue)
    if defObj.CheckInState(ChConfig.BatObjState_Wudi):
        hurtTypes |= pow(2, ChConfig.HurtType_Immune) # Ìí¼ÓÃâÒß
        immuneHurt = hurtValue
        hurtValue = 0
        return hurtValue, hurtTypes, immuneHurt
    
    # Ôö¼õÉ˶ܣ¬ »á¸Ä±ä hurtValue£¬Çø±ðÓë¼ÆË㹫ʽÖеÄÔö¼õÉË£¬ÕâÀï´¦ÀíµÄÊǶԹ«Ê½¼ÆËã½á¹ûµÄÔÙ´ÎÔö¼õ
    
    hurtValue = max(0, hurtValue)
    return hurtValue, hurtTypes, immuneHurt

def DoSkillHurtHP(turnFight, atkObj, curSkill, calcHurtResults, lostType="", caorenProtectObj=None, isManyTimes=False):
    '''½áËã¼ÆËãºÃµÄ¼¼ÄÜÉ˺¦
    @param calcHurtResults: ¼¼Äܹ«Ê½¼ÆËãºóµÄÉ˺¦½á¹û [[tagBatObj, hurtValue, hurtTypes, immuneHurt], ...]
    @param caorenProtectObj: ²ÜÈÊרÓã¬Òª·À»¤µÄ¶ÔÏó
    @param isManyTimes: ÊÇ·ñÊǺó¶Ë¶à´Î¼ÆËãÉ˺¦µÄ
    '''
    if not calcHurtResults:
        return
    
    isAttackDirect = SkillCommon.isAttackDirectSkill(curSkill) # ÊÇ·ñÖ±½Ó¹¥»÷
    # ¼ÆËãƽ̯
    finalHurtResults = __calcAverageHurt(turnFight, atkObj, curSkill, calcHurtResults, caorenProtectObj, isAttackDirect)
    
    # Ö´ÐÐ×îÖÕÉ˺¦½áËã
    mainHurtObj = None
    for hurtInfo in finalHurtResults:
        defObj, hurtValue, hurtTypes, immuneHurt = hurtInfo[:4]
        isEx = hurtInfo[4] if len(hurtInfo) > 4 else 0 # ÊÇ·ñÊǶîÍâÄ¿±ê
        
        lostHP = DoLostHP(turnFight, atkObj, defObj, hurtValue, curSkill, lostType, hpCanNegative=True, immuneHurt=immuneHurt)
        
        #É˺¦½á¹¹Ìå
        defID = defObj.GetID()
        if isEx:
            if isManyTimes and mainHurtObj:
                hurtObj = mainHurtObj.AddHurtObjEx(defID)
            else:
                hurtObj = curSkill.AddHurtObj(defID, isEx=True)
            curSkill.AddTagObjEx(defObj)
        else:
            hurtObj = curSkill.AddHurtObj(defID)
            if not mainHurtObj:
                mainHurtObj = hurtObj
                
        hurtObj.SetHurtTypes(hurtTypes)
        hurtObj.SetHurtHP(hurtValue)
        hurtObj.SetLostHP(lostHP)
        hurtObj.SetCurHP(max(defObj.GetHP(), 0))
        
        #·´µ¯É˺¦£º½ö·ÇdotµÄ¼¼ÄÜÔì³ÉµÄÉ˺¦¼¼Äܱ¾ÉíÄ¿±ê²Å·´µ¯£¬¸½ÊôÄ¿±ê²»·´µ¯£¨Æ½Ì¯¡¢½¦Éä  ¸½ÊôÄ¿±ê£©£¬·´µ¯É˺¦²»Æ½Ì¯
        if isAttackDirect:
            CalcBounceHP(turnFight, atkObj, defObj, hurtObj, curSkill)
        #ÎüѪ£º³ý·´µ¯ÍâµÄÈÎÒâÉ˺¦¶¼Îü
        CalcSuckBlood(turnFight, atkObj, defObj, hurtObj, curSkill)
        
    return mainHurtObj

def __calcAverageHurt(turnFight, curBatObj, useSkill, calcHurtResults, caorenProtectObj=None, isAttackDirect=False):
    '''¼ÆËãÉ˺¦¾ù̯³ÐÉË
    @return: finalHurtResults  [[tagBatObj, hurtValue, hurtTypes, immuneHurt, <isEx>], ...]
    '''
    if not calcHurtResults:
        return calcHurtResults
    
    # ÊÇ·ñÔÚÄÚ²ãɸѡ²ÜÈÊ·À»¤Ä¿±ê£¬Íâ²ãÈç¹û´¦Àí¹ýÁ˵«ÊÇΪNoneʱ»áÉèÖÃΪ0
    checkCaoren = True if (caorenProtectObj == None and isAttackDirect) else False
    if not isAttackDirect or caorenProtectObj == 0:
        caorenProtectObj = None
        
    srcHurtTotal = 0 # Ô´×ÜÉ˺¦
    hurtValueDict = {} # ×îÖÕÉ˺¦ {objID:hurtValue, ...}
    immuneHurtDict = {} # ×îÖÕÃâÒßÉ˺¦ {objID:immuneHurt, ...} # ÎÞµÐÄ¿±ê¿É̯É˺¦£¬µ«ÃâÒ߸ÃÉ˺¦
    tagFaction, tagLineupNum = 0, 0
    for calcInfo in calcHurtResults:
        tagObj, hurtValue, _, immuneHurt = calcInfo
        srcHurtTotal = srcHurtTotal + hurtValue + immuneHurt
        tagID = tagObj.GetID()
        hurtValueDict[tagID] = hurtValue
        if immuneHurt > 0:
            immuneHurtDict[tagID] = immuneHurt
            
        if not tagFaction:
            tagFaction = tagObj.GetFaction()
            tagLineupNum = tagObj.GetLineupNum()
            
        # ²»µ²×Ô¼º£¬²»µ²Î޵У¬Ë³ÑÓÖ±µ½Ò»¸ö¿ÉÒÔµ²µÄ×îµÍѪÁ¿Ä¿±ê£¬Èç¹ûûÓоͲ»µ²
        if checkCaoren and tagID != ChConfig.HeroID_Caoren and not immuneHurt and (not caorenProtectObj or tagObj.GetHP() < caorenProtectObj.GetHP()):
            caorenProtectObj = tagObj
            
    isAve, caorenProtectID, otherFactionHurtDict = __calcFactionAverageHurt(turnFight, tagFaction, tagLineupNum, hurtValueDict, immuneHurtDict, caorenProtectObj)
    if not isAve:
        #GameWorld.DebugLog("ûÓзÖ̯É˺¦Ô­Öµ·µ»Ø")
        return calcHurtResults
    GameWorld.DebugLog("±¾ÕóÓª·Ö̯É˺¦½á¹û: %s,ÃâÒßÉ˺¦=%s,¸øµÐÕóÓª=%s,caorenProtectID=%s" 
                       % (hurtValueDict, immuneHurtDict, otherFactionHurtDict, caorenProtectID))
    
    # ¾ù̯¸øÆäËûÕóÓªµÄËã·ÇÖ±½ÓÉ˺¦£¬¼´²ÜÈÊÎÞЧ
    for key, otherHurtDict in otherFactionHurtDict.items():
        aveFaction, aveLineupNum = key
        isAveEx, _, otherFactionHurtDictEx = __calcFactionAverageHurt(turnFight, aveFaction, aveLineupNum, otherHurtDict, immuneHurtDict)
        
        # ÆäËûÕóÓª·Ö̯ºóµÄ×îÖÕÉ˺¦ÀÛ¼Óµ½Êµ¼Ê×îÖÕÉ˺¦
        for objID, aveHurt in otherHurtDict.items():
            hurtValueDict[objID] = hurtValueDict.get(objID, 0) + aveHurt
        GameWorld.DebugLog("ÆäËûÕóÓª·Ö̯ºóµÄ×îÖÕÉ˺¦: isAveEx=%s,%s,ÃâÒßÉ˺¦=%s,¸øµÐÕóÓª=%s" 
                           % (isAveEx, hurtValueDict, immuneHurtDict, otherFactionHurtDictEx))
        
        # ÆäËûÕóÓªÔٴηÖ̯¸øÆäËûÕóÓªµÄ£¬¶­°×Ч¹ûÒýÆð
        # ¶­°×ÔÝʱֻÄÜÔÙ´Î̯¸øÔ´Í·Ò»´ÎÉ˺¦£¬ÔÚ¶àV¶à³¡¾°ÏÂÔݲ»×öÖ§³Ö A¶­°× ̯ B¶­°× ̯ C¶­°×£¬Ä¿Ç°Ö»×ö A->B->A
        for keyEx, otherHurtDictEx in otherFactionHurtDictEx.items():
            factionEx, lineupNumEx = keyEx
            if factionEx != tagFaction or lineupNumEx != tagLineupNum:
                continue
            
            for objID, aveHurt in otherHurtDictEx.items():
                hurtValueDict[objID] = hurtValueDict.get(objID, 0) + aveHurt
            GameWorld.DebugLog("ÆäËûÕóÓªÔÙ·Ö̯¸øÔ´ÕóÓªµÄÉ˺¦: %s,×îÖÕÉ˺¦=%s,ÃâÒßÉ˺¦=%s" 
                               % (otherHurtDictEx, hurtValueDict, immuneHurtDict))
            
    finalHurtTotal = 0
    finalHurtResults = []
    # Ö÷ҪĿ±êÉ˺¦¸üÐÂ
    for calcInfo in calcHurtResults:
        tagObj, _, hurtTypes, _ = calcInfo
        tagID = tagObj.GetID()
        finalHurt = int(hurtValueDict.pop(tagID, 0))
        immuneHurt = max(int(immuneHurtDict.pop(tagID, 0)), 0) # ÒòΪÓбê¼Ç-1Öµ£¬ËùÒÔ¼Ómax
        # Ö÷ҪĿ±êµÄÃâÒß±ê¼ÇÍâ²ãÒѾ­´¦Àí£¬½ö¶îÍâ´¦Àí±ê¼Ç²ÜÈÊ·À»¤
        if caorenProtectID == tagID:
            hurtTypes |= pow(2, ChConfig.HurtType_CaorenProtect) # ±ê¼ÇÊܵ½²ÜÈÊ·À»¤£¬Ç°¶Ë±íÏÖÐèÒª
        finalHurtResults.append([tagObj, finalHurt, hurtTypes, immuneHurt])
        finalHurtTotal = finalHurtTotal + finalHurt + immuneHurt
        GameWorld.DebugLog("µÃ³öÖ÷ҪĿ±ê·Ö̯ºóµÄ×îÖÕÉ˺¦: tagID=%s,finalHurt=%s,hurtTypes=%s,immuneHurt=%s,finalHurtTotal=%s" % (tagID, finalHurt, hurtTypes, immuneHurt, finalHurtTotal))
        
    # Ê£ÏÂÉ˺¦ÔòĬÈÏΪ¶îÍâÄ¿±êÉ˺¦£¬·ÅÖ÷ҪĿ±êºóÃæ
    isEx = 1
    batObjMgr = BattleObj.GetBatObjMgr()
    for tagID in set(hurtValueDict.keys() + immuneHurtDict.keys()):
        tagObj = batObjMgr.getBatObj(tagID)
        if not tagObj:
            continue
        hurtTypes = pow(2, ChConfig.HurtType_Normal)
        finalHurt = int(hurtValueDict.pop(tagID, 0))
        immuneHurt = max(int(immuneHurtDict.pop(tagID, 0)), 0)
        if immuneHurt > 0:
            hurtTypes |= pow(2, ChConfig.HurtType_Immune) # Ìí¼ÓÃâÒß
        finalHurtTotal = finalHurtTotal + finalHurt + immuneHurt
        GameWorld.DebugLog("µÃ³ö¶îÍâÄ¿±ê·Ö̯ºóµÄ×îÖÕÉ˺¦: tagID=%s,finalHurt=%s,hurtTypes=%s,immuneHurt=%s,finalHurtTotal=%s" % (tagID, finalHurt, hurtTypes, immuneHurt, finalHurtTotal))
        if finalHurt > 0 or immuneHurt > 0: # ¶îÍâÄ¿±êÓÐÊÜÉË»òÃâÒß²ÅËã
            finalHurtResults.append([tagObj, finalHurt, hurtTypes, immuneHurt, isEx])
            
    if finalHurtTotal != srcHurtTotal:
        GameWorld.DebugLog("[·Ö̯É˺¦ºóÎó²îÖµ]=%s,srcHurtTotal=%s,finalHurtTotal=%s" % (srcHurtTotal - finalHurtTotal, srcHurtTotal, finalHurtTotal))
    return finalHurtResults

def __calcFactionAverageHurt(turnFight, faction, lineupNum, hurtValueDict, immuneHurtDict, caorenProtectObj=None):
    '''¼ÆËãij¸öÕóÓªµÄÉ˺¦Æ½Ì¯£¬Ã¿¸öÕóÓª¶ÀÁ¢¼ÆËã¼´¿É£¬¼õÉÙ¸´ÔÓ¶È
        ÓÅÏȼ¶: Õçåµ > ²ÜÈÊ > ¶­°×£»
        ¼õÉÙ¸´ÔӶȣ¬¹Ì¶¨°Ñ¶­°××îºóË㣬ÕâÑùÿ¸öÕóÓªµÄÉ˺¦µ¥¶À¼ÆËã¾ù̯¼´¿É
        @param hurtValueDict: Ä¿±êÉ˺¦×Öµä
        @param immuneHurtDict: Ä¿Ç°×îÖÕÃâÒßÉ˺¦×Öµä
        @param caorenProtectObj: ²ÜÈÊ·À»¤¶ÔÏ󣬿ÉÄÜΪ None »ò 0 »ò ijһ¸ö¶ÔÏó
    '''
    
    # Õçåµ    DZÄÜ1    Ö¯Ãü    Õ½¶·¿ªÊ¼£¬ÕçåµÁ´½ÓÈ«Ìå¶ÓÓÑ£¬Ê¹ÈÎÒâ¶ÓÓÑÊܵ½µÄÉ˺¦ÓÉÈ«Ìå¾ù̯£¬³ÖÐø2»ØºÏ
    # ²ÜÈʵķֵ£´¥·¢Ìõ¼þÔÝʱ³ÌÐòÄڹ̶¨£¬ÓÐÐÞ¸Äʱ³ÌÐòͬ²½ÐÞ¸Ä
    # ²ÜÈÊ: ÎÒ·½Ó¢ÐÛÊܵ½Ö±½Ó¹¥»÷ʱ£¨Êܵ½Èº¹¥Ê±Ñ¡ÔñѪÁ¿×îµÍµÄÓÑ·½½øÐзÀ»¤£©£¬²ÜÈÊÓÐ30%¸ÅÂÊΪÆä·Öµ£Ò»°ëËùÊÜÉ˺¦£¬Ã¿³É¹¦·Öµ£Ò»´Î£¬²ÜÈÊ»ñµÃ1²ã¼áÈÍ£¬Ê¹ÎÒ·½È«Ìå¼õÉËÌáÉý5%£¬×î¶à6²ã£¬²ÜÈÊËÀÍöЧ¹ûÏûʧ
    # ¶­°×Å­Æø    ͬÃüËø    ¶ÔµÐ·½¹¥»÷×î¸ßµÄ1¸öÄ¿±êÔì³É¹¥»÷Á¦450%ÎïÀíÉ˺¦£¬²¢ÓëÆäÁ¬½Ó£¬Ê¹Á½ÈËÊܵ½µÄÈÎÒâÉ˺¦Æ½Ì¯£¨Æ½Ì¯É˺¦²»»á±»ÔÙ´Îƽ̯£©£¬³ÖÐø2»ØºÏ
    caorenSkillID = 1015070
    effHeroIDList = [ChConfig.HeroID_Zhenfu, ChConfig.HeroID_Caoren, ChConfig.HeroID_Dongbai] # Ôݹ̶¨£¬ÓÐÔö¼ÓÎ佫ÔÙͬ²½ÐÞ¸Ä
    
    isAve = False
    caorenProtectID = 0 # ²ÜÈʳɹ¦·À»¤µÄ¶ÔÏóID£¬ÓÐÖµ´ú±íÓзÀ»¤
    otherFactionHurtDict = {} # ·Ö̯¸øÆäËûÕóÓªµÄÉ˺¦ {(faction, lineupNum):{objID:aveHurt, ...}, ...}
    batFaction = turnFight.getBatFaction(faction)
    batLineup = batFaction.getBatlineup(lineupNum)
    batObjMgr = BattleObj.GetBatObjMgr()
    GameWorld.DebugLog("----¿ªÊ¼¼ÆËãÕóÓª·Ö̯É˺¦: faction=%s,lineupNum=%s,hurtValueDict=%s,ÃâÒßÉ˺¦=%s" 
                       % (faction, lineupNum, hurtValueDict, immuneHurtDict))
    # °´ÓÅÏȼ¶Ë³Ðò´¦ÀíÓµÓзÖ̯Ч¹ûµÄÎ佫
    for effHeroID in effHeroIDList:
        if effHeroID not in batLineup.heroObjIDDict:
            continue
        objID = batLineup.heroObjIDDict[effHeroID]
        batObj = batObjMgr.getBatObj(objID)
        if not batObj or not batObj.IsAlive():
            continue
        buffMgr = batObj.GetBuffManager()
        
        inHurt = objID in hurtValueDict # ¹â»·ÀïµÄÈËÔ±ÊÇ·ñÓÐÊÜÉË
        aveBuff = None
        aveObjList = [] # ¿É¾ù̯É˺¦µÄ¶ÔÏóÁбí
        if effHeroID == ChConfig.HeroID_Caoren:
            if not caorenProtectObj:
                GameWorld.DebugLog("ûÓвÜÈÊ¿É·À»¤µÄ¶ÔÏó")
                continue
            hpLowestID = caorenProtectObj.GetID()
            if hpLowestID == objID:
                GameWorld.DebugLog("²ÜÈʲ»·À»¤×Ô¼º")
                continue
            if not inHurt and hpLowestID not in hurtValueDict:
                GameWorld.DebugLog("²ÜÈʼ°·À»¤¶ÔÏ󶼲»ÔÚÊÜÉËÁбíÀï²»´¦Àí! hpLowestID=%s" % hpLowestID)
                continue
            if batObj.IsInControlledHard():
                GameWorld.DebugLog("²ÜÈʱ»Ó²¿ØÖв»·À»¤")
                continue
            caoRenSkill = batObj.GetSkillManager().FindSkillByID(caorenSkillID)
            if not caoRenSkill:
                GameWorld.DebugLog("²ÜÈÊ»¹Î´Ñ§Ï°·Öµ£É˺¦¼¼ÄÜ! caorenSkillID=%s" % caorenSkillID)
                continue
            if not GameWorld.CanHappen(caoRenSkill.GetHappenRate()):
                GameWorld.DebugLog("²ÜÈʸÅÂÊδ´¥·¢·À»¤")
                continue
            inHurt = True
            aveObjList = [batObj, caorenProtectObj]
            GameWorld.DebugLog("²ÜÈÊ´¥·¢·À»¤! hpLowestID=%s" % hpLowestID)
            
        elif effHeroID == ChConfig.HeroID_Zhenfu:
            aveBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_Zhiming)
            
        elif effHeroID == ChConfig.HeroID_Dongbai:
            aveBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_Link)
            
        else:
            continue
        
        if not aveObjList: # ûÓÐÖ¸¶¨¾ù̯É˺¦µÄ£¬¸ù¾Ý¾ù̯¹â»·buffÕÒ
            if not aveBuff:
                GameWorld.DebugLog("ûÓзÖ̯É˺¦¹â»·! effHeroID=%s" % (effHeroID))
                continue
            haloObjIDList = aveBuff.GetHaloObjIDList()
            GameWorld.DebugLog("[·Ö̯¹â»·buff] effHeroID=%s,skillID=%s,objID=%s,haloObjIDList=%s" % (effHeroID, aveBuff.GetSkillID(), objID, haloObjIDList))
            for haloObjID in haloObjIDList:
                haloObj = batObjMgr.getBatObj(haloObjID)
                if not haloObj or not haloObj.IsAlive():
                    continue
                aveObjList.append(haloObj)
                if not inHurt and haloObjID in hurtValueDict:
                    inHurt = True
                    
        if not inHurt:
            GameWorld.DebugLog("Ïà¹ØÈËԱûÓÐÊÜÉË£¬²»´¦Àí·Ö̯É˺¦! effHeroID=%s" % effHeroID)
            continue
        
        aveObjCnt = len(aveObjList)
        if aveObjCnt < 2:
            GameWorld.DebugLog("Ïà¹ØÈËÔ±ÉÙÓÚ2¸öʱ×ÔÐге£ËùÓÐÉ˺¦! effHeroID=%s,aveObjCnt=%s" % (effHeroID, aveObjCnt))
            continue
        
        if not isAve:
            isAve = True
            
        if effHeroID == ChConfig.HeroID_Caoren and caorenProtectObj:
            caorenProtectID = caorenProtectObj.GetID()
            GameWorld.DebugLog("[²ÜÈÊ·À»¤Ä¿±ê] caorenProtectID=%s,caorenObjID=%s" % (caorenProtectID, objID))
            
        aveHurtTotal = 0
        for aveObj in aveObjList:
            aveObjID = aveObj.GetID()
            if effHeroID == ChConfig.HeroID_Caoren and aveObjID == objID:
                GameWorld.DebugLog("    ²ÜÈʵÄЧ¹û²»Æ½Ì¯²ÜÈÊ×ÔÉíµÄÉ˺¦£¬Ö»ÊDzÜÈÊ°ï±ðÈË̯! aveObjID=%s" % aveObjID)
                continue
            if aveObjID not in hurtValueDict:
                continue
            hurtValue = hurtValueDict.pop(aveObjID, 0) # ±»·Ö̯µÄÉ˺¦ÒªÒƳý
            if hurtValue <= 0:
                GameWorld.DebugLog("    ÎÞÉ˺¦µÄ²»´¦Àí£º¿ÉÄÜÊÇ·ÇÖ÷ҪĿ±ê»ò×ÔÉíÒѾ­ÎÞµÐÃâÒßÁËÉ˺¦! aveObjID=%s" % aveObjID)
                continue
            aveHurtTotal += hurtValue
            GameWorld.DebugLog("    Àۼƴý·Ö̯É˺¦! effHeroID=%s,aveObjID=%s,hurtValue=%s,aveHurtTotal=%s" % (effHeroID, aveObjID, hurtValue, aveHurtTotal))
            
        # ´ó¼Ò·Ö̯
        aveHurtDict = {} # ±¾ÕóÓª¸Ã·Ö̯Ч¹û·Ö̯É˺¦¼Ç¼
        aveHurt = round(aveHurtTotal / float(aveObjCnt), 2)
        GameWorld.DebugLog("¼ÆËã·Ö̯É˺¦! effHeroID=%s,aveHurtTotal=%s,aveObjCnt=%s,aveHurt=%s" % (effHeroID, aveHurtTotal, aveObjCnt, aveHurt))
        for aveObj in aveObjList:
            aveObjID = aveObj.GetID()
            aveFaction = aveObj.GetFaction()
            
            immuneHurt = immuneHurtDict.get(aveObjID)
            if immuneHurt == None:
                if aveObj.CheckInState(ChConfig.BatObjState_Wudi):
                    immuneHurt = 0
                else:
                    immuneHurt = -1 # ±ê¼ÇûÓÐÎÞµÐ
                immuneHurtDict[aveObjID] = immuneHurt
                
            if immuneHurt >= 0:
                immuneHurtDict[aveObjID] = immuneHurt + aveHurt
                GameWorld.DebugLog("    ÀÛ¼ÓÃâÒß·Ö̯É˺¦! aveObjID=%s,ÃâÒßÉ˺¦=%s" % (aveObjID, immuneHurtDict))
                continue
            
            if aveFaction == faction:
                aveHurtDict[aveObjID] = aveHurtDict.get(aveObjID, 0) + aveHurt
                GameWorld.DebugLog("    ÀÛ¼Ó±¾Ð§¹û±¾ÕóÓª·Ö̯É˺¦! aveObjID=%s,aveHurtDict=%s" % (aveObjID, aveHurtDict))
            else:
                aveLineupNum = aveObj.GetLineupNum()
                key = (aveFaction, aveLineupNum)
                if key not in otherFactionHurtDict:
                    otherFactionHurtDict[key] = {}
                otherHurtDict = otherFactionHurtDict[key]
                otherHurtDict[aveObjID] = otherHurtDict.get(aveObjID, 0) + aveHurt
                GameWorld.DebugLog("    ÀÛ¼Ó±¾Ð§¹ûµÐÕóÓª·Ö̯É˺¦! aveObjID=%s,factionKey=%s,otherHurtDict=%s" % (aveObjID, key, otherHurtDict))
                
        # »ã×Ü×îÐÂÉ˺¦
        for aveObjID, aveHurt in aveHurtDict.items():
            hurtValueDict[aveObjID] = hurtValueDict.get(aveObjID, 0) + aveHurt
        GameWorld.DebugLog("    ¸üб¾Ð§¹û·Ö̯ºóµÄÉ˺¦! %s,ÃâÒßÉ˺¦=%s,¸øµÐÕóÓª=%s" % (hurtValueDict, immuneHurtDict, otherFactionHurtDict))
        
    return isAve, caorenProtectID, otherFactionHurtDict

def DoLostHP(turnFight, atkObj, defObj, hurtValue, curSkill, lostType="", hpCanNegative=False, immuneHurt=0):
    '''½öÖ´ÐеôѪÂß¼­: ³ÐÉË¶ÜµÖ¿Û  + Ê£Óà¿ÛѪ
    @param hurtValue: µôѪÉ˺¦Öµ£¬Ò»°ãÊǸ÷ÖÖ¼ÆËãºóµÄ×îÖÕÉ˺¦Öµ
    @param hpCanNegative: ¿Û³ýºóµÄÉúÃüÊÇ·ñÔÊÐí¸ºÖµ
    @param immuneHurt: ÃâÒßµÄÉ˺¦Öµ
    @param isSkillSelfTag: ÊÇ·ñ¼¼ÄÜ×ÔÉíµÄÖ±½ÓÄ¿±ê£¬Èçƽ̯É˺¦Ä¿±ê¡¢½¦ÉäÉ˺¦Ä¿±êÕâÖ־Ͳ»ËãÖ±½ÓÄ¿±ê
    @return: lostHP
    '''
    
    if immuneHurt > 0:
        buffMgr = defObj.GetBuffManager()
        wudiBuffList = buffMgr.FindBuffListByState(ChConfig.BatObjState_Wudi)
        for buff in wudiBuffList:
            buffSkillID = buff.GetSkillID()
            # ¼Ç¼ÃâÒß»ýÔܵÄÉ˺¦
            buffValue = buff.GetValue1() + buff.GetValue2() * ChConfig.Def_PerPointValue
            updBuffValue = buffValue + immuneHurt
            buff.SetValue1(updBuffValue % ChConfig.Def_PerPointValue)
            buff.SetValue2(updBuffValue / ChConfig.Def_PerPointValue)
            GameWorld.DebugLog("    Î޵жÜÀÛ¼ÆÃâÒßÉ˺¦: defID=%s,buffID=%s,buffSkillID=%s,buffValue=%s,immuneHurt=%s,updBuffValue=%s,lostType=%s" 
                               % (defObj.GetID(), buff.GetBuffID(), buffSkillID, buffValue, immuneHurt, updBuffValue, lostType))
            
    if hurtValue <= 0:
        return 0
    
    atkID = atkObj.GetID()
    defID = defObj.GetID()
    skillID = curSkill.GetSkillID()
    
    # ³ÐÉ˶ܳÐÉË£¬Ê£Óàʱ¼ä¶ÌµÄÓÅÏȳÐÉË£¬³ÐÉ˲»Ó°ÏìÊä³ö£¬Ï൱ÓÚ¶îÍâµÄHP£¬½öÓÃÓÚµÖ¿ÛµôѪ£¬½ö ¸Ä±ä lostHP
    lostHP = hurtValue
    shieldBuffList = []
    buffMgr = defObj.GetBuffManager()
    for buff in buffMgr.FindBuffListByState(ChConfig.BatObjState_DamShield):
        skillData = buff.GetSkillData()
        remainTime = buff.GetRemainTime() # Ê£Óà»ØºÏ
        if not skillData.GetLastTime():
            remainTime = 999 # ÓÀ¾Ã¶Ü
        buffValue = buff.GetValue1() + buff.GetValue2() * ChConfig.Def_PerPointValue # Ê£Óà¶ÜÖµ
        shieldBuffList.append([remainTime, buffValue, buff])
        
    if shieldBuffList:
        #¿ÉÄÜÐèҪͬ²½¶ÜÉ˸úʵ¼Ê¿ÛѪֵ¸øÇ°¶Ë£¬¾ßÌå¿´Ç°¶Ë»¤¶ÜÔõô´¦ÀíÔÙÓÅ»¯
        shieldHurtPer = 10000 # ¶Ô»¤¶ÜÉ˺¦±È
        shieldHurtPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddShieldHurtPer, curSkill)
        shieldHurtPer /= 10000.0
        shieldHurtValue = int(hurtValue * shieldHurtPer)  # ¶Ô»¤¶ÜÉ˺¦
        GameWorld.DebugLog("    ¶Ô»¤¶Ü×ÜÉ˺¦: shieldHurtValue=%s,shieldHurtPer=%s,hurtValue=%s" % (shieldHurtValue, shieldHurtPer, hurtValue))
        shieldBuffList.sort()
        for _, buffValue, buff in shieldBuffList:
            if shieldHurtValue <= 0:
                break
            buffID = buff.GetBuffID()
            buffSkillID = buff.GetSkillID()
            if shieldHurtValue < buffValue:
                decShieldValue = shieldHurtValue
            else:
                decShieldValue = buffValue
            GameWorld.DebugLog("    ³ÐÉ˶ֿܵÛ: buffID=%s,skillID=%s,buffValue=%s,Ê£Óà¶ÜÉË=%s,¿Û³ý¶ÜÖµ=%s" % (buffID, buffSkillID, buffValue, shieldHurtValue, decShieldValue))
            shieldHurtValue -= decShieldValue # ³ÐÉËÖµ
            if decShieldValue >= buffValue:
                GameWorld.DebugLog("        ɾ³ý¶Ü: buffID=%s,Ê£Óà¶ÜÉË=%s" % (buffID, shieldHurtValue))
                TurnBuff.DoBuffDel(turnFight, defObj, buff, relatedSkill=curSkill, afterLogic=True, tagObj=atkObj)
            else:
                updShieldValue = buffValue - decShieldValue
                GameWorld.DebugLog("        ¸üжÜ: updShieldValue=%s,Ê£Óà¶ÜÉË=%s" % (updShieldValue, shieldHurtValue))
                buff.SetValue1(updShieldValue % ChConfig.Def_PerPointValue)
                buff.SetValue2(updShieldValue / ChConfig.Def_PerPointValue)
                curSkill.AddAfterLogic(ChConfig.AfterLogic_SyncBuff, [defObj, buff, atkObj, "ReduceShieldValue"])
                
        lostHP = int(shieldHurtValue / shieldHurtPer)
        GameWorld.DebugLog("        ³ÐÉ˺óÊ£ÓàÉËѪ: lostHP=%s" % (lostHP))
        
    dHP = defObj.GetHP()
    remainHP = dHP - lostHP # Ê£ÓàѪÁ¿
    if not hpCanNegative and remainHP < 0:
        remainHP = 0
    lostHP = dHP - remainHP # ʵ¼ÊµôѪÁ¿
    defObj.SetHP(remainHP)
    
    GameWorld.DebugLog("    ¿ÛѪ: atkID=%s,defID=%s,hurtValue=%s,lostType=%s,lostHP=%s,dHP=%s,updHP=%s/%s" 
                       % (atkID, defID, hurtValue, lostType, lostHP, dHP, defObj.GetHP(), defObj.GetMaxHP()))
    TurnAttack.AddTurnObjHurtValue(atkObj, defObj, hurtValue, lostHP, skillID, lostType)
    return lostHP

def CalcBounceHP(turnFight, atkObj, defObj, hurtObj, curSkill):
    '''¼ÆËã·´µ¯·´µ¯É˺¦
    ×¢£º·´ÉË/¾£¼¬Ôݲ»×öÊôÐÔÖ§³Ö£¬½ö×öbuffЧ¹ûÖ§³Ö
    '''
    if not atkObj.GetCanAttack():
        return
    
    damBackPer = 0
    buffMgr = defObj.GetBuffManager()
    for buff in buffMgr.FindBuffListByState(ChConfig.BatObjState_DamBackShield):
        damBackPer += buff.GetValue1()
        
    if damBackPer <= 0:
        return
    
    bounceHP = int(hurtObj.GetHurtHP() * damBackPer / 10000.0)
    if bounceHP <= 0:
        return
    
    GameWorld.DebugLog("    ·´µ¯É˺¦=%s,%s/%s, damBackPer=%s" % (bounceHP, atkObj.GetHP(), atkObj.GetMaxHP(), damBackPer))
    bounceHP, _, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, bounceHP)
    if bounceHP <= 0:
        GameWorld.DebugLog("        bounceHP=%s" % (bounceHP))
        return
    hurtObj.SetBounceHP(bounceHP)
    DoLostHP(turnFight, atkObj, defObj, bounceHP, curSkill, "Bounce", hpCanNegative=True, immuneHurt=immuneHurt) # ·´µ¯ºóÉúÃüÔÊÐí¸ºÖµ
    return

def CalcSuckBlood(turnFight, atkObj, defObj, hurtObj, curSkill):
    '''¼ÆËãÎüѪ
    '''
    
    hurtHP = hurtObj.GetHurtHP()
    if hurtHP <= 1:
        return
    
    aSuckHPPer = atkObj.GetBatAttrValue(ChConfig.AttrID_SuckHPPer)
    dSuckHPPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_SuckHPPerDef)
    suckHP = int(eval(IpyGameDataPY.GetFuncCompileCfg("SuckHPCfg", 1)))
    if suckHP <= 0:
        return
    
    # ÎüѪ¶¾ÄÌ
    poisonCureOwner = GetPoisonCureOwner(atkObj)
    if poisonCureOwner:
        atkObj, defObj = poisonCureOwner, atkObj
        hurtValue = suckHP
        hurtValue, _, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue)
        GameWorld.DebugLog("    ±¾´ÎÎüѪΪ¶¾ÄÌ: suckHP=%s,hurtValue=%s" % (suckHP, hurtValue))
        DoLostHP(turnFight, atkObj, defObj, hurtValue, curSkill, "PoisonSuckBlood", hpCanNegative=True, immuneHurt=immuneHurt) # ÎüѪ¶¾ÄÌÉúÃüÔÊÐí¸ºÖµ
        
        hurtObj.AddHurtType(ChConfig.HurtType_PoisonCureSuck)
        hurtObj.SetSuckHP(hurtValue) # Èç¹ûÇ°¶ËÓÐÐèÒª±íÏÖÃâÒßÎüѪ¶¾ÄÌ£¬¿ÉÒÔÅжÏÎüѪ¶¾ÄÌϸÃֵΪ0´ú±íÃâÒß
        return
    
    curHP = atkObj.GetHP()
    maxHP = atkObj.GetMaxHP()
    remainHP = min(curHP + suckHP, maxHP)
    cureHP = remainHP - curHP # ʵ¼ÊÖÎÁÆÁ¿
    
    hurtObj.SetSuckHP(suckHP)
    atkObj.SetHP(remainHP)
    GameWorld.DebugLog("    ÎüѪ=%s,remainHP=%s/%s,aSuckHPPer=%s,dSuckHPPerDef=%s" % (suckHP, remainHP, maxHP, aSuckHPPer, dSuckHPPerDef))
    
    # ÎüѪÔݶ¨ËãÖÎÁÆ
    TurnAttack.AddTurnObjCureHP(atkObj, atkObj, suckHP, cureHP)
    return

def CalcCureHP(turnFight, userObj, tagObj, curSkill, relativeObj=None):
    ''' ¼ÆËãÖÎÁÆÖµ
    '''
    
    # ¶ÔλĿ±ê
    if not relativeObj:
        relativeObj = GetRelativeObj(turnFight, userObj)
        
    skillID = curSkill.GetSkillID()
    cureType = curSkill.GetCalcType()
    skillPer = curSkill.GetSkillPer()
    #skillValue = curSkill.GetSkillValue()
    
    skillPer += GetAddSkillPer(turnFight, userObj, tagObj, curSkill)
    
    curePer = userObj.GetBatAttrValue(ChConfig.AttrID_CurePer) # ÖÎÁƼӳÉ
    cureDefPer = relativeObj.GetBatAttrValue(ChConfig.AttrID_CurePerDef) # ¶ÔλµÄÈõ»¯ÖÎÁÆ
    angerOverflow = 0 # Å­ÆøÒç³öÖµ
    if SkillCommon.isAngerSkill(curSkill):
        angerOverflow = max(userObj.GetXP() - IpyGameDataPY.GetFuncCfg("AngerXP", 2), 0)
        
    skillPer /= float(ChConfig.Def_MaxRateValue)
    curePer /= float(ChConfig.Def_MaxRateValue)
    cureDefPer /= float(ChConfig.Def_MaxRateValue)
    
    baseValue = GetCalcBaseValue(cureType, userObj, tagObj, curSkill)
    
    cureHP = eval(IpyGameDataPY.GetFuncCompileCfg("CureFormula", 1))
    GameWorld.DebugLog("¼ÆËãÖÎÁÆÖµ(%s)£ºskillID=%s,cureType=%s,baseValue=%s,skillPer=%s,curePer=%s,cureDefPer=%s,angerOverflow=%s" 
                       % (cureHP, skillID, cureType, baseValue, skillPer, curePer, cureDefPer, angerOverflow))
    
    # ¶îÍâÖÎÁÆÖµ
    cureWayExEff = curSkill.GetEffectByID(ChConfig.SkillEff_CureWayEx)
    if cureWayExEff:
        cureType = cureWayExEff.GetEffectValue(0)
        skillPer = cureWayExEff.GetEffectValue(1)
        skillPer /= float(ChConfig.Def_MaxRateValue)
        baseValue = GetCalcBaseValue(cureType, userObj, tagObj, curSkill)
        cureHPEx = eval(IpyGameDataPY.GetFuncCompileCfg("CureFormula", 1))
        cureHP += cureHPEx
        GameWorld.DebugLog("    ¶îÍâÖÎÁÆÖµ(%s): cureType=%s,baseValue=%s,skillPer=%s,cureHP=%s" % (cureHPEx, cureType, baseValue, skillPer, cureHP))
        
    hurtShareEff = curSkill.GetEffectByID(ChConfig.SkillEff_HurtShare)
    if hurtShareEff:
        tagCnt = max(1, len(curSkill.GetTagObjList()))
        cureHP = cureHP / tagCnt
        GameWorld.DebugLog("    Ä¿±ê¾ù̯ÖÎÁÆ: cureHP=%s,tagCnt=%s" % (cureHP, tagCnt))
        
    if cureHP < 1:
        cureHP = 1
        GameWorld.DebugLog("    ±£µ×ÖÎÁÆÖµ: cureHP=%s" % (cureHP))
    return cureHP

def GetCalcBaseValue(calcType, curObj, tagObj, curSkill):
    ##»ñµÃ»ù´¡¼ÆËãÖµ
    baseValue = 0
    if calcType == ChConfig.Def_Calc_Attack:
        baseValue = curObj.GetAtk()
    elif calcType == ChConfig.Def_Calc_MaxHP:
        baseValue = curObj.GetMaxHP()
    elif calcType == ChConfig.Def_Calc_LastHurt:
        baseValue = curObj.GetLastHurtValue()
    elif calcType == ChConfig.Def_Calc_TagMaxHP:
        baseValue = 0 if not tagObj else tagObj.GetMaxHP()
    elif calcType == ChConfig.Def_Calc_TagLostHP:
        baseValue = 0 if not tagObj else max(0, tagObj.GetMaxHP() - tagObj.GetHP())
    elif calcType == ChConfig.Def_Calc_ByBuffValue:
        byBuff = curSkill.GetByBuff()
        if byBuff:
            baseValue = byBuff.GetValue1() + byBuff.GetValue2() * ChConfig.Def_PerPointValue
            GameWorld.DebugLog("¸ù¾ÝbuffÖµ: %s" % baseValue)
    elif calcType == ChConfig.Def_Calc_HarmSelfHP:
        baseValue = curObj.GetHarmSelfHP()
        GameWorld.DebugLog("¸ù¾Ý×Ô²ÐÖµ: %s" % baseValue)
    elif calcType == ChConfig.Def_Calc_AtkedSkillHurtHP:
        bySkill = curSkill.GetBySkill()
        bySkillID = 0
        if bySkill:
            bySkillID = bySkill.GetSkillID()
            curID = curObj.GetID()
            for hurtObj in bySkill.GetHurtObjListAll():
                if curID == hurtObj.GetObjID():
                    baseValue += hurtObj.GetHurtHP()
        GameWorld.DebugLog("¸ù¾Ý×îºóÊÜ»÷¼¼ÄÜÉ˺¦: %s,bySkillID=%s" % (baseValue, bySkillID))
        
    return max(0, baseValue)

def DoDOTAttack(turnFight, batObj, curBuff, hurtValue, hurtTypes, **kwargs):
    ## Ö´Ðе¥´ÎdotÂß¼­
    skillID = curBuff.GetSkillID()
    skillIpyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
    if not skillIpyData:
        return
    buffID = curBuff.GetBuffID()
    ownerID = curBuff.GetOwnerID()
    buffOwner = BattleObj.GetBatObjMgr().getBatObj(ownerID) # ¹¥»÷·½
    if not buffOwner:
        return
    
    atkObj = buffOwner
    defObj = batObj
    
    atkID = ownerID
    defID = defObj.GetID()
    
    # ½áËãÐèҪͬ²½±êÇ©
    useTag = "Skill_%s_%s_Dot" % (atkID, skillID)
    Sync_TurnFightTag(turnFight, useTag, 0)
    
    dHP = defObj.GetHP()
    dMaxHP = defObj.GetMaxHP()
    GameWorld.DebugLog("½áËãdot: atkID=%s,defID=%s,buffID=%s,skillID=%s,ownerID=%s,hurtValue=%s,hurtTypes=%s,dHP=%s/%s" 
                       % (atkID, defID, buffID, skillID, ownerID, hurtValue, hurtTypes, dHP, dMaxHP))
    layer = curBuff.GetLayer()
    if layer > 0:
        hurtValue *= layer
        GameWorld.DebugLog("    ¶à²ãbuffÉ˺¦: hurtValue=%s,layer=%s" % (hurtValue, layer))
    if "FinalDamPer" in kwargs:
        FinalDamPer = kwargs["FinalDamPer"]
        hurtValue *= (10000 + FinalDamPer) / 10000.0
        GameWorld.DebugLog("    ÔöÉË: hurtValue=%s,FinalDamPer=%s" % (hurtValue, FinalDamPer))
        
    poolMgr = ObjPool.GetPoolMgr()
    useSkill = poolMgr.acquire(BattleObj.PySkill, skillIpyData, atkID)
    useSkill.SetTagObjList([defObj])
    useSkill.SetBatType(ChConfig.TurnBattleType_Dot)
    
    hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes)
    calcHurtResults = [[defObj, hurtValue, hurtTypes, immuneHurt]]
    DoSkillHurtHP(turnFight, atkObj, useSkill, calcHurtResults, "DOT")
    
    Sync_UseSkill(turnFight, atkObj, useSkill)
    
    DoBeAttackResult(turnFight, atkObj, useSkill)
    
    # ֪ͨ½áÊø±êÇ©
    Sync_TurnFightTag(turnFight, useTag, 1)
    
    useSkill.ResetUseRec()
    poolMgr.release(useSkill)
    return

def Sync_TurnFightTag(turnFight, useTag, sign):
    ## ֪ͨ¼¼ÄܱêÇ©
    clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagSCTurnFightTag)
    clientPack.Tag = useTag
    clientPack.Len = len(clientPack.Tag)
    clientPack.Sign = sign
    turnFight.addBatPack(clientPack)
    return

def Sync_UseSkill(turnFight, curBatObj, useSkill):
    ## ֪ͨÊͷż¼ÄÜ
    bySkill = useSkill.GetBySkill()
    relatedSkillID = bySkill.GetSkillID() if bySkill else 0
    poolMgr = ObjPool.GetPoolMgr()
    clientPack = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkill)
    clientPack.ObjID = curBatObj.GetID()
    clientPack.PMType = GetPMType(curBatObj, useSkill)
    clientPack.BattleType = useSkill.GetBatType()
    clientPack.CurHP = curBatObj.GetHP() % ChConfig.Def_PerPointValue
    clientPack.CurHPEx = curBatObj.GetHP() / ChConfig.Def_PerPointValue
    clientPack.SkillID = useSkill.GetSkillID()
    clientPack.RelatedSkillID = relatedSkillID
    # ¼¼ÄܵÄÖ÷ÒªÉ˺¦
    clientPack.HurtList = []
    for hurtObj in useSkill.GetHurtObjList():
        hurt = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurt)
        hurt.ObjID = hurtObj.GetObjID()
        hurt.AttackTypes = hurtObj.GetHurtTypes()
        hurt.HurtHP = hurtObj.GetHurtHP() % ChConfig.Def_PerPointValue
        hurt.HurtHPEx = hurtObj.GetHurtHP() / ChConfig.Def_PerPointValue
        hurt.CurHP = hurtObj.GetCurHP() % ChConfig.Def_PerPointValue
        hurt.CurHPEx = hurtObj.GetCurHP() / ChConfig.Def_PerPointValue
        hurt.SuckHP = min(hurtObj.GetSuckHP(), ChConfig.Def_UpperLimit_DWord)
        hurt.BounceHP = min(hurtObj.GetBounceHP(), ChConfig.Def_UpperLimit_DWord)
        hurt.HurtListEx = []
        # µ¥¸öÉ˺¦µÄ¶îÍâÉ˺¦£¬È絯Éä+ƽ̯É˺¦
        for hurtObjEx in hurtObj.GetHurtObjListEx():
            hurtEx = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurtEx)
            hurtEx.ObjID = hurtObjEx.GetObjID()
            hurtEx.AttackTypes = hurtObjEx.GetHurtTypes()
            hurtEx.HurtHP = hurtObjEx.GetHurtHP() % ChConfig.Def_PerPointValue
            hurtEx.HurtHPEx = hurtObjEx.GetHurtHP() / ChConfig.Def_PerPointValue
            hurtEx.CurHP = hurtObjEx.GetCurHP() % ChConfig.Def_PerPointValue
            hurtEx.CurHPEx = hurtObjEx.GetCurHP() / ChConfig.Def_PerPointValue
            hurtEx.SuckHP = min(hurtObjEx.GetSuckHP(), ChConfig.Def_UpperLimit_DWord)
            hurt.HurtListEx.append(hurtEx)
        hurt.HurtCountEx = len(hurt.HurtListEx)
        clientPack.HurtList.append(hurt)
    
    # ¼¼ÄܵĶîÍâÉ˺¦£¬Èç³£¹æ¼¼ÄܵÄƽ̯É˺¦
    clientPack.HurtListEx = []
    for hurtObjEx in useSkill.GetHurtObjListEx():
        hurtEx = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurtEx)
        hurtEx.ObjID = hurtObjEx.GetObjID()
        hurtEx.AttackTypes = hurtObjEx.GetHurtTypes()
        hurtEx.HurtHP = hurtObjEx.GetHurtHP() % ChConfig.Def_PerPointValue
        hurtEx.HurtHPEx = hurtObjEx.GetHurtHP() / ChConfig.Def_PerPointValue
        hurtEx.CurHP = hurtObjEx.GetCurHP() % ChConfig.Def_PerPointValue
        hurtEx.CurHPEx = hurtObjEx.GetCurHP() / ChConfig.Def_PerPointValue
        hurtEx.SuckHP = min(hurtObjEx.GetSuckHP(), ChConfig.Def_UpperLimit_DWord)
        clientPack.HurtListEx.append(hurtEx)
    clientPack.HurtCountEx = len(clientPack.HurtListEx)
    
    # ûÓÐÖ÷ÒªÉ˺¦Ê±ÊÓΪûÓÐÉ˺¦£¬Èç´¿buffµÄ¼¼ÄÜ£¬ÐèҪ֪ͨĿ±ê¸øÇ°¶Ë
    if not clientPack.HurtList:
        for tagObj in useSkill.GetTagObjList():
            tagID = tagObj.GetID()
            hurt = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurt)
            hurt.ObjID = tagID
            hurt.CurHP = tagObj.GetHP() % ChConfig.Def_PerPointValue
            hurt.CurHPEx = tagObj.GetHP() / ChConfig.Def_PerPointValue
            clientPack.HurtList.append(hurt)
            
    clientPack.HurtCount = len(clientPack.HurtList)
    turnFight.addBatPack(clientPack)
    return

def Sync_PropertyRefreshView(turnFight, curBatObj, attrID, value, diffValue, diffType=0, skillID=0, relatedSkillID=0, hurtTypes=0):
    '''֪ͨ¶ÔÏóÊôÐÔË¢ÐÂչʾB418
    @param attrID: ֪ͨ±ä»¯µÄÊôÐÔID
    @param diffValue: ±ä»¯Öµ
    @param diffType: ±ä»¯ÀàÐÍ£¬0-¼õÉÙ£»1-Ôö¼Ó
    @param skillID: ʹÓõļ¼ÄܱíID£¬¼´Äĸö¼¼ÄܵÄЧ¹û
    @param relatedSkillID: ¹ØÁªµÄ¼¼ÄÜID£¬Ò»°ãÊÇÖ÷¼¼ÄÜID£¬·ÇÖ÷¼¼ÄܶîÍâ´¥·¢µÄΪ0
    @param hurtTypes: Æ®×ÖÀàÐÍ»ã×Ü£¬Ö§³Ö¶àÖÖÀàÐͲ¢´æ£¬ÈçÎÞÊÓ·ÀÓùÇÒ±©»÷ͬʱ±»¸ñµ²£¬¶þ½øÖÆ»òÔËËã×îÖÕÖµ£»0-ʧ°Ü£»1-ÆÕͨ£»2-»ØѪ£»5-¸ñµ²£»6-ÎÞÊÓ·ÀÓù£»7-±©»÷£»9-ÉÁ±Ü
    '''
    if attrID not in ChConfig.CDBRefresh_AttrIDDict:
        return
    refreshType, isBig = ChConfig.CDBRefresh_AttrIDDict[attrID]
    poolMgr = ObjPool.GetPoolMgr()
    clientPack = poolMgr.acquire(ChPyNetSendPack.tagSCObjPropertyRefreshView)
    clientPack.ObjID = curBatObj.GetID()
    clientPack.RefreshType = refreshType
    clientPack.AttackTypes = hurtTypes    
    if isBig:
        clientPack.Value = value % ShareDefine.Def_PerPointValue
        clientPack.ValueEx = value / ShareDefine.Def_PerPointValue
        clientPack.DiffValue = diffValue % ShareDefine.Def_PerPointValue
        clientPack.DiffValueEx = diffValue / ShareDefine.Def_PerPointValue
    else:
        clientPack.Value = value
        clientPack.ValueEx = 0
        clientPack.DiffValue = diffValue
        clientPack.DiffValueEx = 0
    clientPack.DiffType = diffType
    clientPack.SkillID = skillID
    clientPack.RelatedSkillID = relatedSkillID
    turnFight.addBatPack(clientPack)
    return

def Sync_HPRefresh(turnFight, curBatObj):
    hp, maxHP = curBatObj.GetHP(), curBatObj.GetMaxHP()
    clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagSCObjHPRefresh)
    clientPack.ObjID = curBatObj.GetID()
    clientPack.HP = hp % ShareDefine.Def_PerPointValue
    clientPack.HPEx = hp / ShareDefine.Def_PerPointValue
    clientPack.MaxHP = maxHP % ShareDefine.Def_PerPointValue
    clientPack.MaxHPEx = maxHP / ShareDefine.Def_PerPointValue
    turnFight.addBatPack(clientPack)
    return