Project_SG_ServerCode.git

			@@ -45,11 +45,12 @@
			## 是否无视防御
			return useSkill.GetHurtType() / 10 == 1 # 2为真伤，待扩展

			def OnUseSkill(turnFight, curBatObj, useSkill, tagObjList=None, batType=ChConfig.TurnBattleType_Normal, bySkill=None):
			def OnUseSkill(turnFight, curBatObj, useSkill, tagObjList=None, batType=ChConfig.TurnBattleType_Normal, bySkill=None, byBuff=None, comboLimit=False, atkBackTag=None):
			'''使用技能通用入口
			@param useSkill: 使用的技能，注意并不一定是身上的技能，可能只是 SkillData 表数据
			@param bySkill: 由哪个技能额外触发的，比如附加触发的技能或被动技能均可能由某个技能触发
			@param isEnhanceSkill: 是否附加触发的技能，即主技能拆分成多个技能，额外释放的
			@param comboLimit: 是否强制限制连击
			@param atkBackTag: 反击目标
			@return: 是否成功
			'''
			if not useSkill:
			@@ -59,33 +60,61 @@
			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:
			tagAim = useSkill.GetTagAim()
			tagFriendly = useSkill.GetTagFriendly()
			tagAffect = useSkill.GetTagAffect()
			tagCount = useSkill.GetTagCount()
			tagObjList = GetSkillTags(turnFight, curBatObj, tagAim, tagFriendly, tagAffect, tagCount)
			tagObjList = GetSkillTags(turnFight, curBatObj, useSkill, atkBackTag)
			rate = useSkill.GetHappenRate()
			if rate and rate != ChConfig.Def_MaxRateValue:
			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

			objID = curBatObj.GetID()
			oneActionUseCnt = turnFight.GetOneActionUseSkillCnt(objID)
			if oneActionUseCnt >= 20:
			GameWorld.ErrLog("单次行动累计使用技能达到上限! objID=%s,oneActionUseCnt=%s" % (objID, oneActionUseCnt), turnFight.playerID)
			return
			oneActionUseCnt = turnFight.SetOneActionUseSkillCnt(objID, oneActionUseCnt + 1)

			# 子技能怒气溢出值也有效，所以子技能不处理
			curXP = curBatObj.GetXP()
			if batType == ChConfig.TurnBattleType_Enhance:
			pass
			elif SkillCommon.isAngerSkill(useSkill):
			maxXP = IpyGameDataPY.GetFuncCfg("AngerXP", 2)
			angerOverflow = max(curXP - maxXP, 0)
			curBatObj.SetAngerOverflow(angerOverflow)
			else:
			curBatObj.SetAngerOverflow(0)
			angerOverflow = curBatObj.GetAngerOverflow()

			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))
			GameWorld.DebugLog("◆使用技能: curID=%s,skillID=%s,tagCnt=%s,batType=%s,bySkillID=%s,HP:%s/%s,angerOverflow=%s,curXP=%s,oneActionUseCnt=%s"
			% (objID, skillID, len(tagObjList), batType, bySkillID, curBatObj.GetHP(), curBatObj.GetMaxHP(), angerOverflow, curXP, oneActionUseCnt))
			# 以下为技能可以使用的处理，之后的逻辑默认技能使用成功

			poolMgr = ObjPool.GetPoolMgr()
			@@ -99,6 +128,7 @@
			useSkill.SetTagObjList(tagObjList)
			useSkill.SetBatType(batType)
			useSkill.SetBySkill(bySkill)
			useSkill.SetByBuff(byBuff)

			isTurnNormalSkill = SkillCommon.isTurnNormalSkill(useSkill)
			if isTurnNormalSkill:
			@@ -116,35 +146,25 @@
			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:
			# 主技能额外触发的技能可不下发，前端视为仅释放一个主技能
			if batType != ChConfig.TurnBattleType_Enhance:
			# 因为可能触发连击，所以标记需带上累计使用技能次数，确保唯一
			useTag = "Skill_%s_%s_%s" % (objID, skillID, curBatObj.GetSkillUseCnt(skillID) + 1)
			clientPack = poolMgr.acquire(ChPyNetSendPack.tagSCTurnFightTag)
			clientPack.Tag = useTag
			clientPack.Len = len(clientPack.Tag)
			clientPack.Sign = 0
			turnFight.addBatPack(clientPack)

			__doUseSkill(turnFight, curBatObj, useSkill)

			DoAttackResult(turnFight, curBatObj, useSkill)

			if useTag:
			clientPack = poolMgr.acquire(ChPyNetSendPack.tagSCTurnFightTag)
			clientPack.Tag = useTag
			clientPack.Len = len(clientPack.Tag)
			clientPack.Sign = 1
			turnFight.addBatPack(clientPack)
			Sync_TurnFightTag(turnFight, useTag, 1)

			# 处理反击或连击
			if isTurnNormalSkill:
			if not DoCombo(turnFight, curBatObj, useSkill):
			if comboLimit or not DoCombo(turnFight, curBatObj, useSkill):
			useSkill.ComboInterrupt()

			# 最后重置、回收对象
			@@ -153,50 +173,142 @@
			poolMgr.release(useSkill)
			return True

			def GetSkillTags(turnFight, curBatObj, tagAim, tagFriendly, tagAffect, tagCount):
			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, ...]

			curFaction = curBatObj.GetFaction()
			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]

			sneerObj = None # 嘲讽目标
			sneerObjID, sneerObjPosNum = 0, 0
			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
			sneerObj = curBatObj.GetSneerTagObj() # 被嘲讽的目标，对敌的强制锁定被嘲讽目标

			sneerObjFirst = True # 嘲讽目标优先
			if sneerObj:
			sneerObjID = sneerObj.GetID()
			sneerObjPosNum = sneerObj.GetPosNum()

			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 tagFaction == curFaction:
			if lineupNumSet != None and not tagFriendly:
			lineupNumList = [lineupNumSet] # 已经有指定敌方的某一阵容
			elif tagFaction == curFaction:
			lineupNumList = [lineupNum] # 友方暂时仅限制自己阵容
			else:
			lineupNumList = [lineupNum] # 敌方优先对位阵容，再其他阵容
			# 敌方优先: 特殊目标阵容 > 对位阵容 > 其他阵容
			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 sneerObj:
			aimObjList.append(sneerObj)
			if specMainObj:
			aimObjList.append(specMainObj)
			else:
			relativeObj = __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup)
			if relativeObj:
			@@ -204,11 +316,11 @@

			# 前排
			elif tagAim == ChConfig.SkillTagAim_FrontRow:
			aimObjList = __getRowAimObjList(batObjMgr, posNum, sneerObj, batLineup, tagAffect, False)
			aimObjList = __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, False, isNoSelf)

			# 后排
			elif tagAim == ChConfig.SkillTagAim_BackRow:
			aimObjList = __getRowAimObjList(batObjMgr, posNum, sneerObj, batLineup, tagAffect, True)
			aimObjList = __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, True, isNoSelf)

			# 竖排/纵排
			elif tagAim == ChConfig.SkillTagAim_Vertical:
			@@ -219,14 +331,14 @@
			colNumList.remove(inColNum)
			colNumList.insert(0, inColNum)

			# 优先嘲讽所在纵
			if sneerObj:
			sneerInColNum = ChConfig.GetInColNum(sneerObjPosNum)
			if sneerInColNum in colNumList:
			colNumList.remove(sneerInColNum)
			colNumList.insert(0, sneerInColNum)
			# 优先特殊目标所在纵
			if specMainObj:
			specInColNum = ChConfig.GetInColNum(specObjPosNum)
			if specInColNum in colNumList:
			colNumList.remove(specInColNum)
			colNumList.insert(0, specInColNum)

			GameWorld.DebugLog("纵排: colNumList=%s,sneerObjID-PosNum=%s-%s" % (colNumList, sneerObjID, sneerObjPosNum))
			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
			@@ -235,7 +347,7 @@
			continue
			tagObjID = batLineup.posObjIDDict[pNum]
			tagBatObj = batObjMgr.getBatObj(tagObjID)
			if not __skillTagFilter(tagBatObj, tagAffect):
			if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
			continue
			aimObjList.append(tagBatObj)
			if aimObjList:
			@@ -250,7 +362,7 @@
			colNumList.remove(inColNum)
			colNumList.insert(0, inColNum)

			GameWorld.DebugLog("全部: colNumList=%s,sneerObjID-PosNum=%s-%s" % (colNumList, sneerObjID, sneerObjPosNum))
			GameWorld.DebugLog("全部: colNumList=%s,specObjID-PosNum=%s-%s" % (colNumList, specObjID, specObjPosNum))
			# 按前排优先原则
			for row in range(1, 1 + ChConfig.TurnFightRows):
			for col in colNumList:
			@@ -260,7 +372,7 @@
			continue
			tagObjID = batLineup.posObjIDDict[pNum]
			tagBatObj = batObjMgr.getBatObj(tagObjID)
			if not __skillTagFilter(tagBatObj, tagAffect):
			if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
			continue
			aimObjList.append(tagBatObj)

			@@ -275,31 +387,103 @@
			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 sneerObjFirst and sneerObj:
			if sneerObj in aimObjList and aimObjList.index(sneerObj) != 0:
			aimObjList.remove(sneerObj)
			aimObjList.insert(0, sneerObj)
			# 以下优先级先处理的优先级视为较低
			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 __getRowAimObjList(batObjMgr, posNum, sneerObj, batLineup, tagAffect, rowReverse):
			## 获取行排目标对象列表
			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:
			@@ -307,24 +491,24 @@
			else:
			rowNumList = range(1, 1 + ChConfig.TurnFightRows)

			# 优先嘲讽对象所在行
			sneerObjID, sneerObjPosNum = 0, 0
			if sneerObj:
			sneerObjID = sneerObj.GetID()
			sneerObjPosNum = sneerObj.GetPosNum()
			sneerInRowNum = ChConfig.GetInRowNum(sneerObjPosNum) # 所在行排
			# 优先特殊对象所在行
			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(posNum) # 玩家所在纵列
			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,sneerObjID-PosNum=%s-%s" % (rowNumList, colNumList, sneerObjID, sneerObjPosNum))
			GameWorld.DebugLog("前后排: rowNumList=%s,colNumList=%s,specObjID-PosNum=%s-%s" % (rowNumList, colNumList, specObjID, specObjPosNum))
			aimObjList = []
			for row in rowNumList:
			for col in colNumList:
			@@ -334,7 +518,7 @@
			continue
			tagObjID = batLineup.posObjIDDict[pNum]
			tagBatObj = batObjMgr.getBatObj(tagObjID)
			if not __skillTagFilter(tagBatObj, tagAffect):
			if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
			continue
			aimObjList.append(tagBatObj)
			if aimObjList:
			@@ -343,11 +527,7 @@
			return aimObjList

			def GetRelativeObj(turnFight, curBatObj):
			'''获取对位目标，嘲讽时优先对位嘲讽目标
			对位目标用途：
			1. 对位目标并不代表仅攻击该目标
			2. 攻击时根据技能攻击目标范围优先攻击对位目标所在的横排或纵排
			3. 对位目标可用于判断连击、弱疗
			'''获取对位目标，仅用于非技能目标的对位逻辑，如连击、弱疗等相对属性的判断，技能目标统一使用 GetSkillTags
			'''
			sneerObj = curBatObj.GetSneerTagObj()
			if sneerObj:
			@@ -374,12 +554,13 @@
			if relativeObj:
			return relativeObj

			# 理论上只要战斗没有结束，一定会有对位目标，这里默认返回自己，外层可不需要判断是否存在对位目标
			# 理论上只要战斗没有结束，一定会有对位目标，这里默认返回自己，方便外层逻辑处理，外层可不需要判断是否存在对位目标
			return curBatObj

			def __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup):
			## 获取在某一阵营中的默认对位目标

			## 获取在某一阵容中的默认对位目标，不包括自己
			if not batLineup:
			return
			tagAffect = ChConfig.SkillTagAffect_None # 默认对位目标不需要细分目标，默认规则即可
			inColNum = ChConfig.GetInColNum(posNum) # 玩家所在纵列
			# 优先自己所在纵
			@@ -396,13 +577,13 @@
			continue
			tagObjID = batLineup.posObjIDDict[pNum]
			tagBatObj = batObjMgr.getBatObj(tagObjID)
			if not __skillTagFilter(tagBatObj, tagAffect):
			if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf=True):
			continue
			return tagBatObj

			return

			def __skillTagFilter(tagBatObj, tagAffect):
			def __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf=False):
			## 技能目标过滤器
			# @return: 是否允许添加该单位
			if not tagBatObj:
			@@ -411,6 +592,10 @@
			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
			@@ -418,8 +603,19 @@
			def __doAddBuff(turnFight, curBatObj, useSkill):
			#执行添加buff

			for tagBatObj in useSkill.GetTagObjList():
			TurnBuff.OnAddBuff(turnFight, tagBatObj, useSkill, buffOwner=curBatObj)
			#光环技能，需先添加施法者
			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

			@@ -427,6 +623,9 @@

			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)
			@@ -439,9 +638,9 @@
			# 多次攻击（锁目标多次伤害，非前端的多段飘血）
			elif atkType == 4:
			pass
			# 弹射（多次攻击，切换目标）
			# 弹射攻击
			elif atkType == 5:
			pass
			SkillModule_5(turnFight, curBatObj, useSkill)
			# 怒气增
			elif atkType == 6:
			SkillModule_6(turnFight, curBatObj, useSkill, "Increase")
			@@ -451,26 +650,185 @@
			# 怒气偷
			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():
			__doSkillHurtHP(turnFight, curBatObj, tagBatObj, useSkill)
			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):
			## 治疗

			skillID = useSkill.GetSkillID()
			calcCureResults = []
			relativeObj = GetRelativeObj(turnFight, curBatObj)
			for tagBatObj in useSkill.GetTagObjList():
			cureHP = CalcCureHP(turnFight, curBatObj, tagBatObj, useSkill, largeNum=True)
			if cureHP <= 0:
			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()

			@@ -478,16 +836,103 @@
			realCureHP = max(remainHP - dHP, 0)
			tagBatObj.SetHP(remainHP)

			dID = tagBatObj.GetID()
			hurtObj = useSkill.AddHurtObj(dID)
			hurtObj.AddHurtType(ChConfig.HurtTYpe_Recovery)
			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, curBatObj, cureHP, realCureHP, skillID)
			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):
			@@ -538,7 +983,7 @@
			else:
			diffType = 1
			tagXP = tagBatObj.GetXP()
			diffValue = calcValue
			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))
			@@ -547,10 +992,10 @@
			if curStealTotal > 0:
			diffType = 1
			curXP = curBatObj.GetXP()
			diffValue = curStealTotal
			diffValue = GetEnhanceXP(tagBatObj, curStealTotal)
			updValue = curXP + diffValue
			curBatObj.SetXP(updValue, False)
			GameWorld.DebugLog(" 加总怒气: curID=%s,curStealTotal=%s,curXP=%s,updXP=%s" % (curID, curStealTotal, curXP, updValue))
			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
			@@ -561,18 +1006,19 @@
			'''

			if curBatObj:
			# 反弹、吸血的原因，需要统一处理后结算，可能导致HP为负值，修正为0
			# 反弹、吸血、平摊伤害自残的原因，需要统一处理后结算，可能导致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.SetCalcTime(turnFight.getTimeline())
			useSkill.SetRemainTime(useSkill.GetCoolDownTime())

			# 需先技能使用 - 前端按顺序优先表现技能释放内容，前端需要动作或有伤血则通知
			if useSkill.GetSkillMotionName() or len(useSkill.GetHurtObjList()):
			if IsNeedSyncSkill(useSkill):
			Sync_UseSkill(turnFight, curBatObj, useSkill)

			__doCostZhanchui(turnFight, curBatObj, useSkill)
			@@ -599,7 +1045,13 @@
			纵排：优先前面的单位
			'''

			if turnFight.winFaction:
			return

			if not useSkill.ComboEnable():
			return

			if not atkObj.IsAlive():
			return

			tagFriendly = useSkill.GetTagFriendly()
			@@ -610,11 +1062,11 @@
			if not tagObjList:
			return
			tagObj = tagObjList[0] # 第一个默认为主目标，技能对象选择逻辑时决定主目标
			atkBackSkill = __getCanAtkBackSkill(useSkill, tagObj)
			atkBackSkill = __getCanAtkBackSkill(atkObj, tagObj, useSkill)
			if atkBackSkill:
			# 可以反击，打断连击
			GameWorld.DebugLog("● %s 【反击】" % TurnAttack.GetObjName(tagObj))
			OnUseSkill(turnFight, tagObj, atkBackSkill, [atkObj], ChConfig.TurnBattleType_AtkBack)
			OnUseSkill(turnFight, tagObj, atkBackSkill, batType=ChConfig.TurnBattleType_AtkBack, atkBackTag=atkObj)
			return

			if not tagObj:
			@@ -641,19 +1093,34 @@
			OnUseSkill(turnFight, atkObj, useSkill, batType=ChConfig.TurnBattleType_Combo)
			return True

			def __getCanAtkBackSkill(useSkill, tagObj):
			## 获取是否可反击及反击技能
			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 tagObj.GetAtkDistType() not in canAtkbackDictTypeList:
			GameWorld.DebugLog("该远近类型武将不可反击! tagID=%s,AtkDistType=%s not in %s" % (tagID, tagObj.GetAtkDistType(), canAtkbackDictTypeList))
			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.GetHurtObjList():
			for hurtObj in useSkill.GetHurtObjListAll():
			if hurtObj.GetObjID() != tagID:
			continue
			if hurtObj.HaveHurtType(ChConfig.HurtType_Parry): # 格挡时可反击
			@@ -664,6 +1131,14 @@
			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)
			@@ -680,7 +1155,7 @@
			@param isUseSkill: 是否是直接使用技能的攻击结果，否则视为持续性的
			'''

			curID = curObj.GetID()
			#curID = curObj.GetID()
			isTurnNormalSkill = SkillCommon.isTurnNormalSkill(useSkill)
			isAngerSkill = SkillCommon.isAngerSkill(useSkill)

			@@ -711,35 +1186,70 @@

			# 统计击杀
			killObjList = [] # 击杀其他阵营目标列表
			for tagObj in useSkill.GetTagObjList():
			dieObjList = [] # 死亡的单位列表，包含友方单位或自己
			tagObjList = useSkill.GetTagObjList() # 主要目标列表
			tagObjListEx = useSkill.GetTagObjListEx() # 额外目标列表
			tagObjListAll = tagObjList + tagObjListEx
			for tagObj in tagObjListAll:
			tagID = tagObj.GetID()
			if tagObj.IsAlive() and tagObj.GetHP() <= 0 and tagObj.GetFaction() != curObj.GetFaction():
			killObjList.append(tagObj)
			if tagObj.IsAlive() and tagObj.GetHP() <= 0:
			dieObjList.append(tagObj)
			if tagObj.GetFaction() != curObj.GetFaction():
			killObjList.append(tagObj)
			TurnAttack.SetObjKilled(turnFight, tagObj, curObj, useSkill)
			if curObj.IsAlive() and curObj.GetHP() <= 0:
			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 = []
			for hurtObj in useSkill.GetHurtObjList():
			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_Recovery) and (isTurnNormalSkill or isAngerSkill) and tagObj.IsAlive():
			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):
			missObjIDList.append(hurtObjID)
			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)
			@@ -753,9 +1263,12 @@
			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)
			# 优先触发本技能额外效果，注：仅该技能释放后该技能的额外效果视为主技能的效果，优先级最高
			__DoCurSkillEff(turnFight, curObj, useSkill, missObjIDList, isUseSkill)

			if selfAlive:
			__DoCurSkillEff(turnFight, curObj, useSkill, effIgnoreObjIDList, isUseSkill)

			# ========== 以下触发被动 ==========

			# 破盾时
			@@ -764,22 +1277,74 @@
			tagObj = batObjMgr.getBatObj(tagObjID)
			TurnPassive.OnTriggerPassiveEffect(turnFight, buffObj, ChConfig.TriggerWay_ShieldBroken, tagObj, connSkillTypeID=buffSkillTypeID)

			for tagObj in useSkill.GetTagObjList():
			# 有击杀时
			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 == curID or tagID in missObjIDList:
			# 自己或对方闪避了不再触发被动
			if tagID in effIgnoreObjIDList:
			continue

			isExObj = tagObj in tagObjListEx # 是否额外目标

			# 掉血时
			if tagID in beHurtObjIDList:
			TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeHurt, curObj, connSkill=useSkill)

			# 直接攻击
			if isUseSkill and not SkillCommon.IsBuff(useSkill) and useSkill.GetSkillType() in [ChConfig.Def_SkillType_Atk]:
			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 killObjList:
			tagObj = killObjList[0]
			TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_KillOneObj, tagObj, connSkill=useSkill)
			for tagObj in killObjList:
			TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_KillTagObj, 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

			@@ -848,6 +1413,7 @@
			if posNum <= 0:
			#非主战单位不加
			return
			addXP = GetEnhanceXP(gameObj, addXP)
			curXP = gameObj.GetXP()
			updXP = curXP + addXP
			gameObj.SetXP(updXP)
			@@ -861,7 +1427,10 @@
			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)
			@@ -869,7 +1438,18 @@
			Sync_PropertyRefreshView(turnFight, gameObj, ChConfig.AttrID_XP, updXP, addXP, diffType=1, relatedSkillID=relatedSkillID)
			return

			def __DoCurSkillEff(turnFight, curObj, useSkill, missObjIDList, isUseSkill):
			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)
			@@ -882,15 +1462,15 @@
			continue

			effID = curEffect.GetEffectID()
			GameWorld.DebugLog("◆执行额外技能效果: %s, triggerWay=%s,missObjIDList=%s" % (effID, triggerWay, missObjIDList))
			GameWorld.DebugLog("●执行额外技能效果: skillID=%s,effID=%s, triggerWay=%s,effIgnoreObjIDList=%s" % (useSkill.GetSkillID(), effID, triggerWay, effIgnoreObjIDList))
			if effID == 5010:
			# 额外技能效果
			__doUseEnhanceSkill(turnFight, curObj, useSkill, curEffect, missObjIDList)
			__doUseEnhanceSkill(turnFight, curObj, useSkill, curEffect, effIgnoreObjIDList)
			continue

			for tagObj in useSkill.GetTagObjList():
			tagID = tagObj.GetID()
			if tagID in missObjIDList:
			if tagID in effIgnoreObjIDList:
			# 闪避了不触发
			continue

			@@ -898,38 +1478,51 @@

			return

			def __doUseEnhanceSkill(turnFight, curBatObj, useSkill, curEffect, missObjIDList):
			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)
			GameWorld.DebugLog("额外触发的技能: enhanceSkillID=%s,checkInStateList=%s" % (enhanceSkillID, checkInStateList))
			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 missObjIDList:
			GameWorld.DebugLog(" 闪避的不触发: tagID=%s" % (tagID))
			if tagID in effIgnoreObjIDList:
			GameWorld.DebugLog(" 闪避或免疫的不触发: 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
			@@ -943,19 +1536,26 @@

			# 只执行一次，防止群攻时额外触发多次
			GameWorld.DebugLog("重新锁定目标! enhanceSkillID=%s" % enhanceSkillID)
			if checkInStateList:
			inState = False
			if checkInStateList or checkHeroJob:
			inState, haveJob = False, False
			for tagObj in tagObjList:
			if tagObj.CheckInState(checkInStateList):
			tagID = tagObj.GetID()
			if tagID in effIgnoreObjIDList:
			continue
			if not inState and tagObj.CheckInState(checkInStateList):
			inState = True
			break
			if not inState:
			GameWorld.DebugLog(" 没有目标在状态下不触发: tagObj not in state:%s" % str(checkInStateList))
			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):
			def OnUsePassiveSkill(turnFight, batObj, tagObj, passiveSkill, connSkill=None, effSkillID=0, effectID=0, connBuff=None):
			'''被动触发使用技能
			@param passiveSkill: 释放的被动技能
			@param connSkill: 由什么技能引起的
			@@ -965,84 +1565,52 @@
			'''
			if not passiveSkill:
			return
			isOK = False
			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()
			GameWorld.DebugLog("被动触发技能，继承主技能目标! effSkillID=%s,effectID=%s,passiveSkillID=%s,happenRate=%s" % (effSkillID, effectID, passiveSkillID, happenRate))
			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 happenRate != ChConfig.Def_MaxRateValue and not GameWorld.CanHappen(happenRate, ChConfig.Def_MaxRateValue):
			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)
			isOK = OnUseSkill(turnFight, batObj, passiveSkill, passiveTagObjList, batType=ChConfig.TurnBattleType_Passive, bySkill=connSkill, byBuff=connBuff)
			else:
			GameWorld.DebugLog("被动触发技能，重新锁定目标! effSkillID=%s,effectID=%s,passiveSkillID=%s" % (effSkillID, effectID, passiveSkillID))
			isOK = OnUseSkill(turnFight, batObj, passiveSkill, batType=ChConfig.TurnBattleType_Passive, bySkill=connSkill)
			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 __doSkillHurtHP(turnFight, attacker, defObj, curSkill):
			## 执行技能伤血，只计算伤血，其他逻辑等技能同步后再处理
			# @return: None - 没有执行成功，即忽略该目标

			atkObj = attacker
			atkID = atkObj.GetID()
			defID = defObj.GetID()
			skillID = curSkill.GetSkillID()
			hurtObj = curSkill.AddHurtObj(defID)

			atkSkillPer = curSkill.GetSkillPer()
			atkSkillValue = curSkill.GetSkillValue()

			dHP = defObj.GetHP() # 防守方当前血量
			dMaxHP = defObj.GetMaxHP() # 防守方最大血量

			zhansha = False # 斩杀特殊处理
			# նɱ
			if zhansha:
			pass

			else:
			hurtValue, hurtTypes = CalcHurtHP(turnFight, atkObj, defObj, curSkill, atkSkillValue, atkSkillPer)
			hurtValue, realHurtHP = CalcHurtHPWithBuff(turnFight, atkObj, defObj, curSkill, hurtValue)

			#伤害结构体
			hurtObj.SetHurtTypes(hurtTypes)
			hurtObj.SetHurtHP(hurtValue)
			hurtObj.SetRealHurtHP(realHurtHP)
			remainHP = min(dMaxHP, max(0, dHP - realHurtHP)) # 剩余血量

			remainHP = int(remainHP) #防范
			lostHP = dHP - remainHP # 实际掉血量
			hurtObj.SetLostHP(lostHP)
			hurtObj.SetCurHP(remainHP)
			defObj.SetHP(remainHP)
			atkObj.SetLastHurtValue(hurtValue)
			GameWorld.DebugLog(" 伤血: atkID=%s,defID=%s,hurtValue=%s,realHurtHP=%s,lostHP=%s,%s/%s"
			% (atkID, defID, hurtValue, realHurtHP, lostHP, defObj.GetHP(), defObj.GetMaxHP()))
			TurnAttack.AddTurnObjHurtValue(atkObj, defObj, hurtValue, lostHP, skillID)

			#反弹伤害
			CalcBounceHP(turnFight, atkObj, defObj, hurtObj, curSkill)

			#吸血
			CalcSuckBlood(atkObj, defObj, hurtObj, curSkill)
			return

			def CalcHurtHP(turnFight, atkObj, defObj, curSkill, atkSkillValue, atkSkillPer, **kwargs):
			'''计算伤害，默认按攻击计算
			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:
			@@ -1056,17 +1624,18 @@
			isTurnNormalSkill = SkillCommon.isTurnNormalSkill(curSkill)
			isAngerSkill = SkillCommon.isAngerSkill(curSkill)
			isDot = ("damageoftime" in kwargs)
			angerOverflow = 0 # 怒气溢出值

			mustHit = False # 是否必命中
			if isAngerSkill:
			if not isTurnNormalSkill: # 仅普攻判断是否闪避
			mustHit = True

			angerOverflow = atkObj.GetAngerOverflow() # 怒气溢出值
			if isAngerSkill:
			curXP = atkObj.GetXP()
			angerOverflow = max(atkObj.GetXP() - IpyGameDataPY.GetFuncCfg("AngerXP", 2), 0)
			GameWorld.DebugLog("XP必命中! curXP=%s,angerOverflow=%s" % (curXP, angerOverflow))
			GameWorld.DebugLog("怒技攻击! curXP=%s,angerOverflow=%s" % (curXP, angerOverflow))

			#命中公式攻击方类型不同，公式不同
			if isTurnNormalSkill and not mustHit:
			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)
			@@ -1091,13 +1660,18 @@

			if isSuperHit:
			hurtTypes \|= pow(2, ChConfig.HurtType_SuperHit)
			aSuperDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_SuperDamPer)
			dSuperDamPerDef = atkObj.GetBatAttrValue(ChConfig.AttrID_SuperDamPerDef)
			aSuperDamPer = IpyGameDataPY.GetFuncCfg("SuperHitCfg", 2) * 10000
			aSuperDamPer += atkObj.GetBatAttrValue(ChConfig.AttrID_SuperDamPer)
			aSuperDamPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_SuperDamPer, curSkill)

			dSuperDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_SuperDamPerDef)
			GameWorld.DebugLog("aSuperDamPer=%s,dSuperDamPerDef=%s" % (aSuperDamPer, dSuperDamPerDef))

			if isParry:
			hurtTypes \|= pow(2, ChConfig.HurtType_Parry)

			if ignoreDef:
			GameWorld.DebugLog("无视防御/真实伤害!")
			hurtTypes \|= pow(2, ChConfig.HurtType_IgnoreDef)

			if isStun:
			@@ -1108,13 +1682,15 @@

			aAtk = atkObj.GetAtk() # 攻击方最大攻击

			dHP = defObj.GetHP()
			dHP, dMaxHP = defObj.GetHP(), defObj.GetMaxHP()
			dDef = 0 if ignoreDef else defObj.GetDef() # 防守方防御力

			atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPer, curSkill)
			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:
			@@ -1123,9 +1699,17 @@

			aAngerSkillPer, dAngerSkillPerDef = 0, 0
			if isAngerSkill:
			aAngerSkillPer = atkObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPer) # 普技增伤
			dAngerSkillPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPerDef) # 普技减伤

			aAngerSkillPer = atkObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPer) # 怒技增伤
			aAngerSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddAngerSkillPerByXP, curSkill)

			dAngerSkillPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPerDef) # 怒技减伤

			aDOTPer, dDOTPerDef = 0, 0
			if isDot:
			aDOTPer = atkObj.GetBatAttrValue(ChConfig.AttrID_DOTPer)
			dDOTPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_DOTPerDef)
			GameWorld.DebugLog("aDOTPer=%s,dDOTPerDef=%s" % (aDOTPer, dDOTPerDef))

			aAddSkillPer = 0 # 技能增伤
			aAddSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_SkillPer, curSkill)

			@@ -1137,12 +1721,41 @@
			aPMDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_PhyDamPer)
			dPMDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_PhyDamPerDef)

			# 阵营增减伤
			aCountry = atkObj.GetCountry()
			dCountry = defObj.GetCountry()
			countryAttrIDDict = {1:[ChConfig.AttrID_WeiFinalDamPer, ChConfig.AttrID_WeiFinalDamPerDef],
			2:[ChConfig.AttrID_ShuFinalDamPer, ChConfig.AttrID_ShuFinalDamPerDef],
			3:[ChConfig.AttrID_WuFinalDamPer, ChConfig.AttrID_WuFinalDamPerDef],
			4:[ChConfig.AttrID_QunFinalDamPer, ChConfig.AttrID_QunFinalDamPerDef],
			}
			aCountryDamPer = atkObj.GetBatAttrValue(countryAttrIDDict.get(dCountry, [0, 0])[0])
			dCountryDamPerDef = defObj.GetBatAttrValue(countryAttrIDDict.get(aCountry, [0, 0])[1])

			aComboDamPer, dComboDamPerDef = 0, 0 # 连击增伤
			if batType == ChConfig.TurnBattleType_Combo:
			aComboDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_ComboDamPer)
			dComboDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_ComboDamPerDef)

			aPursueDamPer, dPursueDamPerDef = 0, 0 # 追击增伤
			if batType == ChConfig.TurnBattleType_Pursue:
			aPursueDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_PursueDamPer)
			dPursueDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_PursueDamPerDef)

			aPVPDamPer, dPVPDamPerDef = 0, 0 # PVP
			if turnFight.getPVPPlayerID() > 0:
			aPVPDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_PVPDamPer)
			dPVPDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_PVPDamPerDef)
			GameWorld.DebugLog("PVP aPVPDamPer=%s,dPVPDamPerDef=%s" % (aPVPDamPer, dPVPDamPerDef))

			# 所有万分率参数统一除10000.0
			atkSkillPer /= 10000.0
			aNormalSkillPer /= 10000.0
			dNormalSkillPerDef /= 10000.0
			aAngerSkillPer /= 10000.0
			dAngerSkillPerDef /= 10000.0
			aDOTPer /= 10000.0
			dDOTPerDef /= 10000.0
			aAddSkillPer /= 10000.0
			aPMDamPer /= 10000.0
			dPMDamPerDef /= 10000.0
			@@ -1150,27 +1763,38 @@
			dSuperDamPerDef /= 10000.0
			aFinalDamPer /= 10000.0
			dFinalDamPerDef /= 10000.0
			aCountryDamPer /= 10000.0
			dCountryDamPerDef /= 10000.0
			aComboDamPer /= 10000.0
			dComboDamPerDef /= 10000.0
			aPursueDamPer /= 10000.0
			dPursueDamPerDef /= 10000.0
			aPVPDamPer /= 10000.0
			dPVPDamPerDef /= 10000.0

			if calcType != ChConfig.Def_Calc_Attack:
			aAtk = GetCalcBaseValue(calcType, atkObj, defObj)
			GameWorld.DebugLog("伤血计算: atkID=%s,defID=%s,skillID=%s,atkSkillPer=%s,calcType=%s,aAtk=%s,dDef=%s,dHP=%s,hurtTypes=%s,aAddSkillPer=%s"
			% (atkID, defID, skillID, atkSkillPer, calcType, aAtk, dDef, dHP, hurtTypes, aAddSkillPer))
			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))
			GameWorld.DebugLog("aCountry=%s,dCountry=%s,aCountryDamPer=%s,dCountryDamPerDef=%s" % (aCountry, dCountry, aCountryDamPer, dCountryDamPerDef))

			# 持续性伤害
			if isTurnNormalSkill:
			hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 1))
			GameWorld.DebugLog(" 普攻技能伤害=%s" % (hurtValue))
			GameWorld.DebugLog(" 普攻技能伤害=%s,aNormalSkillPer=%s,dNormalSkillPerDef=%s" % (hurtValue, aNormalSkillPer, dNormalSkillPerDef))
			elif isAngerSkill:
			hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 2))
			GameWorld.DebugLog(" 怒气技能伤害=%s" % (hurtValue))
			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))
			hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 3))
			GameWorld.DebugLog(" 其他伤害=%s" % (hurtValue))

			if isParry:
			@@ -1190,10 +1814,31 @@
			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)
			@@ -1210,14 +1855,15 @@
			happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("StunCfg", 1))
			if not GameWorld.CanHappen(happenRate):
			return False
			GameWorld.DebugLog("击晕了: happenRate=%s,aStunRate=%s,dStunRateDef=%s" % (happenRate, aStunRate, dStunRateDef))
			stunSkillID = IpyGameDataPY.GetFuncCfg("StunCfg", 2)
			TurnBuff.DoAddBuffBySkillID(turnFight, defObj, stunSkillID, atkObj, curSkill, afterLogic=True)
			return True
			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.IsInControlled():
			#被控制无法格挡
			if defObj.IsInControlledHard():
			#被硬控无法格挡
			return False

			defID = defObj.GetID()
			@@ -1226,7 +1872,7 @@
			parryYJBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_ParryYJ)
			if parryYJBuff and parryYJBuff.GetLayer():
			GameWorld.DebugLog("格挡印记格挡了: buffID=%s,buffLayer=%s" % (parryYJBuff.GetBuffID(), parryYJBuff.GetLayer()))
			TurnBuff.DecBuffLayer(turnFight, defObj, parryYJBuff, 1, curSkill.GetSkillID())
			TurnBuff.DoBuffLayerChange(turnFight, defObj, parryYJBuff, parryYJBuff.GetLayer() - 1, curSkill)
			return True

			aParryRateDef = atkObj.GetBatAttrValue(ChConfig.AttrID_ParryRateDef)
			@@ -1239,80 +1885,444 @@
			return True
			return False

			def CalcHurtHPWithBuff(turnFight, atkObj, defObj, curSkill, hurtValue):
			## 计算伤害后，因各种buff和状态的影响处理
			# @return: hurtValue, realHurtHP
			def CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes=0):
			'''计算buff影响得到最终伤害: 如无敌、增减伤盾等
			@param hurtValue: 公式计算的伤害值
			@return: hurtValue, hurtTypes, immuneHurt
			'''

			immuneHurt = 0 # 免疫伤害值
			if hurtValue <= 0:
			return 0, 0
			hurtValue = 0
			return hurtValue, hurtTypes, immuneHurt

			# 减伤盾减伤，会改变 hurtValue
			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 # 是否是额外目标

			# 承伤盾承伤，剩余时间短的优先承伤，承伤不影响输出，相当于额外的HP，仅用于抵扣掉血，仅改变 realHurtHP
			realHurtHP = hurtValue
			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):
			'''计算某个阵营的伤害平摊，每个阵营独立计算即可，减少复杂度
			优先级: 甄宓 > 曹仁 > 董白；
			减少复杂度，固定把董白最后算，这样每个阵营的伤害单独计算均摊即可
			@param hurtValueDict: 目标伤害字典
			@param immuneHurtDict: 目前最终免疫伤害字典
			@param caorenProtectObj: 曹仁防护对象，可能为 None 或 0 或某一个对象
			'''

			# 甄宓潜能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(" 曹仁的效果不平摊曹仁自身的伤害，只是曹仁帮别人摊! 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 index in range(buffMgr.GetBuffCount()):
			buff = buffMgr.GetBuffByIndex(index)
			for buff in buffMgr.FindBuffListByState(ChConfig.BatObjState_DamShield):
			skillData = buff.GetSkillData()
			# 承伤盾
			if SkillCommon.isDamageShieldSkill(skillData):
			remainTime = buff.GetRemainTime() # 剩余回合
			if not skillData.GetLastTime():
			remainTime = 999 # 永久盾
			buffValue = buff.GetValue1() + buff.GetValue2() * ChConfig.Def_PerPointValue # 剩余盾值
			shieldBuffList.append([remainTime, buffValue, buff])

			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 realHurtHP <= 0:
			if shieldHurtValue <= 0:
			break
			buffID = buff.GetBuffID()
			if realHurtHP < buffValue:
			damageShieldValue = realHurtHP
			buffSkillID = buff.GetSkillID()
			if shieldHurtValue < buffValue:
			decShieldValue = shieldHurtValue
			else:
			damageShieldValue = buffValue
			GameWorld.DebugLog(" 承伤盾: buffID=%s,buffValue=%s,realHurtHP=%s,damageShieldValue=%s" % (buffID, buffValue, realHurtHP, damageShieldValue))
			realHurtHP -= damageShieldValue # 承伤值
			if damageShieldValue >= buffValue:
			GameWorld.DebugLog(" 删除盾: buffID=%s,realHurtHP=%s" % (buffID, realHurtHP))
			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 - damageShieldValue
			GameWorld.DebugLog(" 更新盾值: updShieldValue=%s,realHurtHP=%s" % (updShieldValue, realHurtHP))
			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"])

			return hurtValue, max(0, realHurtHP)
			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

			bounceHP = int(hurtObj.GetHurtHP() * random.uniform(0.1, 0.2))
			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" % (bounceHP, atkObj.GetHP(), atkObj.GetMaxHP()))
			bounceHP, realBounceHP = CalcHurtHPWithBuff(turnFight, defObj, atkObj, curSkill, bounceHP)
			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)

			if realBounceHP > 0:
			remainHP = atkObj.GetHP() - realBounceHP # 反弹允许弹到负值，如果最终吸血没有吸到正值则算死亡
			atkObj.SetHP(remainHP)
			GameWorld.DebugLog(" bounceHP=%s,realBounceHP=%s,%s/%s" % (bounceHP, realBounceHP, atkObj.GetHP(), atkObj.GetMaxHP()))

			TurnAttack.AddTurnObjHurtValue(defObj, atkObj, bounceHP, realBounceHP, isBounce=True)
			DoLostHP(turnFight, atkObj, defObj, bounceHP, curSkill, "Bounce", hpCanNegative=True, immuneHurt=immuneHurt) # 反弹后生命允许负值
			return

			def CalcSuckBlood(atkObj, defObj, hurtObj, curSkill):
			def CalcSuckBlood(turnFight, atkObj, defObj, hurtObj, curSkill):
			'''计算吸血
			'''

			@@ -1321,9 +2331,31 @@
			return

			aSuckHPPer = atkObj.GetBatAttrValue(ChConfig.AttrID_SuckHPPer)
			aCurePer = atkObj.GetBatAttrValue(ChConfig.AttrID_CurePer)

			dSuckHPPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_SuckHPPerDef)
			dCureDefPer = defObj.GetBatAttrValue(ChConfig.AttrID_CurePerDef)

			aSuckHPPer /= float(ChConfig.Def_MaxRateValue)
			aCurePer /= float(ChConfig.Def_MaxRateValue)
			dSuckHPPerDef /= float(ChConfig.Def_MaxRateValue)
			dCureDefPer /= float(ChConfig.Def_MaxRateValue)

			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()
			@@ -1333,52 +2365,68 @@

			hurtObj.SetSuckHP(suckHP)
			atkObj.SetHP(remainHP)
			GameWorld.DebugLog(" 吸血=%s,remainHP=%s/%s,aSuckHPPer=%s,dSuckHPPerDef=%s" % (suckHP, remainHP, maxHP, aSuckHPPer, dSuckHPPerDef))
			GameWorld.DebugLog(" 吸血=%s,remainHP=%s/%s,aSuckHPPer=%s,dSuckHPPerDef=%s,aCurePer=%s,dCureDefPer=%s"
			% (suckHP, remainHP, maxHP, aSuckHPPer, dSuckHPPerDef, aCurePer, dCureDefPer))

			# 吸血暂定算治疗
			TurnAttack.AddTurnObjCureHP(atkObj, atkObj, suckHP, cureHP)
			return

			def CalcCureHP(turnFight, userObj, tagObj, curSkill, largeNum=False):
			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()

			cureBaseValue = GetCalcBaseValue(cureType, userObj, tagObj)
			skillPer += GetAddSkillPer(turnFight, userObj, tagObj, curSkill)

			skillPer += TurnPassive.GetTriggerEffectValue(turnFight, userObj, tagObj, ChConfig.PassiveEff_AddSkillPer, curSkill)
			aCurePer = userObj.GetBatAttrValue(ChConfig.AttrID_CurePer) # 治疗加成
			dCureDefPer = relativeObj.GetBatAttrValue(ChConfig.AttrID_CurePerDef) # 对位的弱化治疗

			# 回合制
			curePer = 0 # 治疗加成
			cureDefPer = 0 # 敌方的弱化治疗
			angerOverflow = 0 # 怒气溢出值
			if SkillCommon.isAngerSkill(curSkill):
			angerOverflow = max(userObj.GetXP() - IpyGameDataPY.GetFuncCfg("AngerXP", 2), 0)
			#enemyObj = TurnAttack.GetEnemyObj(userObj)
			#curePer += GameObj.GetCurePer(userObj)
			#if enemyObj:
			# cureDefPer += GameObj.GetCureDefPer(enemyObj)

			angerOverflow = userObj.GetAngerOverflow() # 怒气溢出值

			skillPer /= float(ChConfig.Def_MaxRateValue)
			curePer /= float(ChConfig.Def_MaxRateValue)
			cureDefPer /= float(ChConfig.Def_MaxRateValue)
			aCurePer /= float(ChConfig.Def_MaxRateValue)
			dCureDefPer /= float(ChConfig.Def_MaxRateValue)

			baseValue = max(0, cureBaseValue) # 防止基值被弱化为负值，在恢复比例也是负值的情况下负负得正导致可以恢复血量
			baseValue = GetCalcBaseValue(cureType, userObj, tagObj, curSkill)

			#公式计算治疗值
			cureHP = eval(IpyGameDataPY.GetFuncCompileCfg("CureFormula", 1))
			if not largeNum:
			cureHP = min(cureHP, ChConfig.Def_UpperLimit_DWord)
			cureHP = max(1, int(cureHP)) # 保底1点
			GameWorld.DebugLog("计算治疗值(%s)：skillID=%s,cureType=%s,baseValue=%s,skillPer=%s,aCurePer=%s,dCureDefPer=%s,angerOverflow=%s"
			% (cureHP, skillID, cureType, baseValue, skillPer, aCurePer, dCureDefPer, angerOverflow))

			GameWorld.DebugLog("计算治疗值(%s)：skillID=%s,cureType=%s,baseValue=%s,skillPer=%s,curePer=%s,cureDefPer=%s,angerOverflow=%s"
			% (cureHP, curSkill.GetSkillID(), cureType, baseValue, skillPer, curePer, cureDefPer, angerOverflow))
			return cureHP
			# 额外治疗值
			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 int(cureHP)

			def GetCalcBaseValue(calcType, curObj, tagObj):
			def GetCalcBaseValue(calcType, curObj, tagObj, curSkill):
			##获得基础计算值
			baseValue = 0
			if calcType == ChConfig.Def_Calc_Attack:
			baseValue = curObj.GetAtk()
			elif calcType == ChConfig.Def_Calc_MaxHP:
			@@ -1387,9 +2435,30 @@
			baseValue = curObj.GetLastHurtValue()
			elif calcType == ChConfig.Def_Calc_TagMaxHP:
			baseValue = 0 if not tagObj else tagObj.GetMaxHP()
			return baseValue
			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):
			def DoDOTAttack(turnFight, batObj, curBuff, hurtValue, hurtTypes, **kwargs):
			## 执行单次dot逻辑
			skillID = curBuff.GetSkillID()
			skillIpyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
			@@ -1406,45 +2475,57 @@

			atkID = ownerID
			defID = defObj.GetID()
			tagObjList = [defObj]

			poolMgr = ObjPool.GetPoolMgr()
			useSkill = poolMgr.acquire(BattleObj.PySkill, skillIpyData, atkID)
			useSkill.SetTagObjList(tagObjList)
			useSkill.ClearHurtObj()
			hurtObj = useSkill.AddHurtObj(defID)
			# 结算需要同步标签
			useTag = "Skill_%s_%s_Dot" % (atkID, skillID)
			Sync_TurnFightTag(turnFight, useTag, 0)

			dHP = defObj.GetHP()
			GameWorld.DebugLog("结算dot: atkID=%s,defID=%s,buffID=%s,skillID=%s,ownerID=%s,hurtValue=%s,hurtTypes=%s,dHP=%s"
			% (atkID, defID, buffID, skillID, ownerID, hurtValue, hurtTypes, dHP))
			hurtValue, realHurtHP = CalcHurtHPWithBuff(turnFight, atkObj, defObj, useSkill, hurtValue)
			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)

			# dot的反弹、吸血待定
			hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes)
			calcHurtResults = [[defObj, hurtValue, hurtTypes, immuneHurt]]
			DoSkillHurtHP(turnFight, atkObj, useSkill, calcHurtResults, "DOT")

			remainHP = max(0, dHP - realHurtHP) # 剩余血量
			lostHP = dHP - remainHP # 实际掉血量
			defObj.SetHP(remainHP)
			atkObj.SetLastHurtValue(hurtValue)
			GameWorld.DebugLog(" hurtValue=%s,realHurtHP=%s,lostHP=%s,%s/%s" % (hurtValue, realHurtHP, lostHP, defObj.GetHP(), defObj.GetMaxHP()))

			hurtObj.SetHurtTypes(hurtTypes)
			hurtObj.SetHurtHP(hurtValue)
			hurtObj.SetRealHurtHP(realHurtHP)
			hurtObj.SetLostHP(lostHP)
			hurtObj.SetCurHP(remainHP)

			TurnAttack.AddTurnObjHurtValue(atkObj, batObj, hurtValue, lostHP, skillID)

			Sync_PropertyRefreshView(turnFight, defObj, ChConfig.AttrID_HP, remainHP, hurtValue, diffType=0, skillID=skillID, hurtTypes=hurtTypes)
			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()
			@@ -1453,6 +2534,8 @@
			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)
			@@ -1464,7 +2547,36 @@
			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()
			@@ -1510,3 +2622,15 @@
			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