#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package Skill.TurnSkill
|
#
|
# @todo:»ØºÏÕ½¶·¼¼ÄÜ
|
# @author hxp
|
# @date 2025-08-06
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: »ØºÏÕ½¶·¼¼ÄÜ
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2025-08-06 18:30"""
|
#-------------------------------------------------------------------------------
|
|
import ChConfig
|
import GameWorld
|
import BattleObj
|
import SkillCommon
|
import IpyGameDataPY
|
import IPY_GameWorld
|
import ChPyNetSendPack
|
import PlayerControl
|
import ShareDefine
|
import TurnPassive
|
import TurnAttack
|
import TurnBuff
|
import ObjPool
|
import FBLogic
|
|
import random
|
|
def GetPMType(batObj, useSkill):
|
## »ñÈ¡Îï·¨É˺¦ÀàÐÍ
|
# GetHurtType ¸öλÊýÓ÷¨¸Ä³É pvp pve±êʶ£¬Ê®Î»Êý-Îï¹¥·¨¹¥ IPY_GameWorld.ghtPhy = 1
|
#---¼¼Äܹ¥»÷, ¶Á±í»ñÈ¡¹¥»÷ÀàÐÍ---
|
ght = useSkill.GetHurtType() % 10
|
if ght == IPY_GameWorld.ghtMag: # ×öÅäÖüæÈÝÓã¬ÓÅÏÈÑéÖ¤·¨ÉË£¬·ñÔòĬÈÏÎïÉË
|
return IPY_GameWorld.ghtMag
|
return IPY_GameWorld.ghtPhy
|
|
def IsIgnoreDef(useSkill):
|
## ÊÇ·ñÎÞÊÓ·ÀÓù
|
return useSkill.GetHurtType() / 10 == 1 # 2ΪÕæÉË£¬´ýÀ©Õ¹
|
|
def OnUseSkill(turnFight, curBatObj, useSkill, tagObjList=None, batType=ChConfig.TurnBattleType_Normal, bySkill=None, byBuff=None, comboLimit=False, atkBackTag=None):
|
'''ʹÓü¼ÄÜͨÓÃÈë¿Ú
|
@param useSkill: ʹÓõļ¼ÄÜ£¬×¢Òâ²¢²»Ò»¶¨ÊÇÉíÉϵļ¼ÄÜ£¬¿ÉÄÜÖ»ÊÇ SkillData ±íÊý¾Ý
|
@param bySkill: ÓÉÄĸö¼¼ÄܶîÍâ´¥·¢µÄ£¬±ÈÈ總¼Ó´¥·¢µÄ¼¼ÄÜ»ò±»¶¯¼¼Äܾù¿ÉÄÜÓÉij¸ö¼¼ÄÜ´¥·¢
|
@param comboLimit: ÊÇ·ñÇ¿ÖÆÏÞÖÆÁ¬»÷
|
@param atkBackTag: ·´»÷Ä¿±ê
|
@return: ÊÇ·ñ³É¹¦
|
'''
|
if not useSkill:
|
return
|
|
skillID = useSkill.GetSkillID()
|
if not skillID:
|
return
|
|
if not curBatObj.IsAlive():
|
return
|
|
objID = curBatObj.GetID()
|
|
if hasattr(useSkill, "GetRemainTime") and useSkill.GetRemainTime() > 0:
|
GameWorld.DebugLog("¼¼ÄÜCDÖÐ! skillID=%s,RemainTime=%s" % (skillID, useSkill.GetRemainTime()))
|
return
|
|
buffStateGroups = useSkill.GetBuffStateLimit()
|
if buffStateGroups:
|
limitState = curBatObj.IsInBuffStateGroup(buffStateGroups)
|
if limitState:
|
GameWorld.DebugLog("¼¼ÄÜʹÓô¦ÓÚbuff״̬ÏÞÖÆÖÐ! skillID=%s,buffStateGroups=%s,limitState=%s" % (skillID, buffStateGroups, limitState))
|
return
|
|
if CheckSkillUseCntLimit(curBatObj, useSkill):
|
return
|
|
#ûÓÐÖ¸¶¨Ä¿±ê£¬Ôò°´¼¼ÄÜ×ÔÉíµÄÄ¿±êÂß¼
|
if not tagObjList:
|
tagObjList = GetSkillTags(turnFight, curBatObj, useSkill, atkBackTag)
|
rate = useSkill.GetHappenRate()
|
if rate:
|
rate += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddSkillRate, useSkill)
|
for tagObj in tagObjList[::-1]:
|
if not GameWorld.CanHappen(rate, ChConfig.Def_MaxRateValue):
|
tagObjList.remove(tagObj)
|
|
if not tagObjList:
|
# ¿ÉÀ©Õ¹ÆäËûÄ¿±êÑ¡Ôñ£¬È縴»î¼¼ÄÜûÓÐËÀÍöµ¥Î»Ê±ÔòʹÓÃÁíÍâµÄЧ¹û
|
GameWorld.DebugLog("ÕÒ²»µ½¼¼ÄÜÄ¿±ê! skillID=%s,mapID=%s,funcLineID=%s" % (skillID, turnFight.mapID, turnFight.funcLineID), turnFight.playerID)
|
return
|
|
oneActionUseCnt = turnFight.GetOneActionUseSkillCnt(objID)
|
if oneActionUseCnt >= 20:
|
GameWorld.ErrLog("µ¥´ÎÐж¯ÀÛ¼ÆʹÓü¼ÄÜ´ïµ½ÉÏÏÞ! objID=%s,oneActionUseCnt=%s" % (objID, oneActionUseCnt), turnFight.playerID)
|
return
|
oneActionUseCnt = turnFight.SetOneActionUseSkillCnt(objID, oneActionUseCnt + 1)
|
|
# ×Ó¼¼ÄÜÅÆøÒç³öÖµÒ²ÓÐЧ£¬ËùÒÔ×Ó¼¼Äܲ»´¦Àí
|
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,angerOverflow=%s,curXP=%s,oneActionUseCnt=%s"
|
% (objID, skillID, len(tagObjList), batType, bySkillID, curBatObj.GetHP(), curBatObj.GetMaxHP(), angerOverflow, curXP, oneActionUseCnt))
|
# ÒÔÏÂΪ¼¼ÄÜ¿ÉÒÔʹÓõĴ¦Àí£¬Ö®ºóµÄÂ߼ĬÈϼ¼ÄÜʹÓóɹ¦
|
|
poolMgr = ObjPool.GetPoolMgr()
|
usePoolSkill = False
|
if isinstance(useSkill, IpyGameDataPY.IPY_Skill):
|
usePoolSkill = True
|
# ͳһʹÓà BattleObj.PySkill
|
useSkill = poolMgr.acquire(BattleObj.PySkill, useSkill, objID)
|
|
useSkill.ResetUseRec()
|
useSkill.SetTagObjList(tagObjList)
|
useSkill.SetBatType(batType)
|
useSkill.SetBySkill(bySkill)
|
useSkill.SetByBuff(byBuff)
|
|
isTurnNormalSkill = SkillCommon.isTurnNormalSkill(useSkill)
|
if isTurnNormalSkill:
|
# ÆÕ¹¥×·»÷ʱǿÖÆÖØпªÊ¼ËãÁ¬»÷
|
useSkill.ComboCheckStart(batType == ChConfig.TurnBattleType_Pursue)
|
|
curBatObj.ClearSkillTempAttr()
|
tagIDList = []
|
for tagObj in tagObjList:
|
tagIDList.append(tagObj.GetID())
|
tagObj.ClearSkillTempAttr()
|
|
# Óй¦ÄÜ·ÖÀàµÄ¼¼Äܶ¼ÈÏΪÊÇÖ÷¼¼ÄÜ
|
if useSkill.GetFuncType():
|
curBatObj.SetMainTagIDList(tagIDList)
|
|
useTag = ""
|
if IsNeedSyncSkill(useSkill):
|
# ÒòΪ¿ÉÄÜ´¥·¢Á¬»÷£¬ËùÒÔ±ê¼ÇÐè´øÉÏÀÛ¼ÆʹÓü¼ÄÜ´ÎÊý£¬È·±£Î¨Ò»
|
useTag = "Skill_%s_%s_%s" % (objID, skillID, curBatObj.GetSkillUseCnt(skillID) + 1)
|
Sync_TurnFightTag(turnFight, useTag, 0)
|
|
#Õâ¸ö¼¼ÄÜÊÇBuff
|
if SkillCommon.IsBuff(useSkill):
|
__doAddBuff(turnFight, curBatObj, useSkill)
|
else:
|
__doUseSkill(turnFight, curBatObj, useSkill)
|
|
DoAttackResult(turnFight, curBatObj, useSkill)
|
|
if useTag:
|
Sync_TurnFightTag(turnFight, useTag, 1)
|
|
# ´¦Àí·´»÷ »ò Á¬»÷
|
if isTurnNormalSkill:
|
if comboLimit or not DoCombo(turnFight, curBatObj, useSkill):
|
useSkill.ComboInterrupt()
|
|
# ×îºóÖØÖᢻØÊÕ¶ÔÏó
|
useSkill.ResetUseRec()
|
if usePoolSkill:
|
poolMgr.release(useSkill)
|
return True
|
|
def CheckSkillUseCntLimit(batObj, useSkill):
|
## ¼ì²é¼¼ÄÜʹÓôÎÊýÊÇ·ñÊÜÏÞ
|
# @return: ÊÇ·ñÊÜÏÞ
|
if not hasattr(useSkill, "GetEffectByID"):
|
return
|
effect = useSkill.GetEffectByID(ChConfig.SkillEff_SkillUseCntLimit)
|
if not effect:
|
return
|
useCntLimit = effect.GetEffectValue(0) # ÿ³¡Õ½¶·×î´ó´ÎÊý£¬0²»ÏÞ
|
turnUseCntLimit = effect.GetEffectValue(1) # ÿ´ó»ØºÏ×î´ó´ÎÊý£¬0²»ÏÞ
|
|
skillID = useSkill.GetSkillID()
|
if useCntLimit:
|
useCnt = batObj.GetSkillUseCnt(skillID)
|
if useCnt >= useCntLimit:
|
GameWorld.DebugLog("¼¼ÄÜÿ³¡Õ½¶·Ê¹ÓôÎÊýÊÜÏÞ! skillID=%s,useCnt=%s >= %s" % (skillID, useCnt, useCntLimit))
|
return True
|
|
if turnUseCntLimit:
|
turnUseCnt = batObj.GetSkillTurnUseCnt(skillID)
|
if turnUseCnt >= turnUseCntLimit:
|
GameWorld.DebugLog("¼¼ÄÜÿ´ó»ØºÏʹÓôÎÊýÊÜÏÞ! skillID=%s,turnUseCnt=%s >= %s" % (skillID, turnUseCnt, turnUseCntLimit))
|
return True
|
|
return
|
|
def IsNeedSyncSkill(useSkill):
|
## ʹÓÃÐèҪͬ²½B427ʹÓü¼ÄÜ
|
if useSkill.GetSkillType() in [ChConfig.Def_SkillType_Atk, ChConfig.Def_SkillType_Cure, ChConfig.Def_SkillType_CleanBuff]:
|
return True
|
if useSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_TurnNormaSkill, ChConfig.Def_SkillFuncType_AngerSkill]:
|
return True
|
return False
|
|
def GetSkillTags(turnFight, curBatObj, useSkill, atkBackTag=None):
|
## »ñÈ¡¼¼ÄÜÄ¿±ê
|
# @return: [Ö÷Ä¿±ê, Ä¿±ê2, ...]
|
|
tagAim = useSkill.GetTagAim()
|
tagFriendly = useSkill.GetTagFriendly()
|
tagAffect = useSkill.GetTagAffect()
|
tagCount = useSkill.GetTagCount()
|
|
lineupNumSet = None
|
changeRet = CheckChangeTagEff(turnFight, curBatObj, useSkill)
|
if changeRet:
|
lineupNumSet, changeTagSet = changeRet
|
GameWorld.DebugLog("Ç¿ÖÆÐ޸ļ¼ÄÜÄ¿±ê: lineupNumSet=%s, changeTagSet=%s" % (lineupNumSet, changeTagSet))
|
tagAim, tagFriendly, tagAffect, tagCount = changeTagSet
|
|
# ×Ô¼º£¬Ö±½Ó·µ»Ø
|
if tagAim == ChConfig.SkillTagAim_Self:
|
return [curBatObj]
|
|
tagCount += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddSkillTagCnt, useSkill)
|
#GameWorld.DebugLog("ËÑË÷¼¼ÄÜÄ¿±ê: skillID=%s,tagAim=%s,tagFriendly=%s,tagAffect=%s,tagCount=%s" % (useSkill.GetSkillID(), tagAim, tagFriendly, tagAffect, tagCount))
|
|
# Ä¿±êÑ¡ÔñÓÅÏȼ¶£¬¼¯»ð > changeRet > ÷È»ó > »ìÂÒ > ³°·í > ·´»÷ > ³£¹æ
|
# ¼¯»ð£ºÖ±½Óͨ¹ýЧ¹û5015Ö¸¶¨ÁËÄ¿±ê£¬²»»á×ßµ½ÕâÀËùÒÔÕâÀï¿É²»´¦Àí
|
# ÷È»ó: µÐÓÑ»¥»»; Ö±½Ó¹¥»÷¼¼Äܲ»°üº¬×Ô¼º£¬Ö»Ê£×Ô¼º»¥»»ºóÊǼº·½Ê±²»Êͷż¼ÄÜ
|
# »ìÂÒ: Ëæ»úµÐÓÑ; Ö±½Ó¹¥»÷¼¼Äܲ»°üº¬×Ô¼º£¬Ö»Ê£×Ô¼º»¥»»ºóÊǼº·½Ê±²»Êͷż¼ÄÜ
|
# ³°·í: Ä¿±êÊǵз½Ê±Ç¿ÖÆÄ¿±êÒ»¶¨°üº¬Ê©·¨Õß
|
# ·´»÷: Ð޸ļ¼ÄÜ×ݺáΪ·´»÷Ä¿±êËùÔÚ×ݺáÇÒΪÖ÷Ä¿±ê£¨ÓÅÏȼ¶µÍÓÚÈí¿Ø¡¢Ö¸¶¨buff״̬Ŀ±ê£¬¸ßÓÚÊôÐÔÌõ¼þÄ¿±ê£©
|
|
# È·ÈϵÐÓÑ
|
inCharm, inChaos = False, False # ÊÇ·ñ÷È»óÖÐ, ÊÇ·ñ»ìÂÒÖÐ
|
if changeRet:
|
pass
|
elif curBatObj.CheckInState(ChConfig.BatObjState_Charm):
|
inCharm = True
|
tagFriendly = 0 if tagFriendly else 1 # ÷È»ó: µÐÓÑ»¥»»
|
elif curBatObj.CheckInState(ChConfig.BatObjState_Chaos):
|
inChaos = True
|
tagFriendly = random.randint(0, 1) # »ìÂÒ: Ëæ»úµÐÓÑ
|
#GameWorld.DebugLog("inCharm=%s,inChaos=%s,tagFriendly=%s" % (inCharm, inChaos, tagFriendly))
|
isNoSelf = False # ÊÇ·ñ²»°üº¬×Ô¼º
|
if inCharm or inChaos:
|
if SkillCommon.isAttackDirectSkill(useSkill):
|
isNoSelf = True
|
#GameWorld.DebugLog("ÌØÊâ²»°üº¬×Ô¼º")
|
|
# ¸ù¾ÝµÐÓѹØϵȷ¶¨ÕóÓª¼°Ò»Ð©µÐÓѹØϵµÄÌØÊâÂß¼
|
sneerObjFirst = True # ³°·íÄ¿±êÊÇ·ñÓÅÏÈ
|
sneerTagObj = None # ³°·íÄ¿±ê
|
atkBackTagFrist = True # ·´»÷Ä¿±êÊÇ·ñÓÅÏÈ
|
specMainObj = None # ÌØÊâÖ÷Ä¿±ê£¬Ä¿Ç°½öµÐ¶Ô¹ØϵÓÐЧ£¬Èç³°·í¡¢·´»÷µÈÓÅÏÈÉ趨ΪÖ÷Ä¿±ê£¬¿É¼æÈÝ÷Ȼ󡢻ìÂÒ
|
specObjID, specObjPosNum, sepcObjLineupNum = 0, 0, 0
|
curFaction = curBatObj.GetFaction()
|
if tagFriendly:
|
tagFaction = curFaction
|
sneerTagObj = None
|
atkBackTag = None
|
else:
|
tagFaction = ChConfig.Def_FactionB if curFaction == ChConfig.Def_FactionA else ChConfig.Def_FactionA
|
sneerTagObj = curBatObj.GetSneerTagObj() # ±»³°·íµÄÄ¿±ê£¬¶ÔµÐµÄÇ¿ÖÆËø¶¨±»³°·íÄ¿±ê
|
if sneerTagObj:
|
specMainObj = sneerTagObj
|
#GameWorld.DebugLog("³°·íÌØÊâÖ÷Ä¿±ê")
|
elif atkBackTag:
|
specMainObj = atkBackTag
|
#GameWorld.DebugLog("·´»÷ÌØÊâÖ÷Ä¿±ê")
|
|
if specMainObj:
|
specObjID = specMainObj.GetID()
|
specObjPosNum = specMainObj.GetPosNum()
|
sepcObjLineupNum = specMainObj.GetLineupNum()
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
lineupNum = curBatObj.GetLineupNum()
|
posNum = curBatObj.GetPosNum()
|
|
# È·ÈÏÕóÈݱàºÅ˳Ðò£¬¶àV¶àʱÓÐÓÃ
|
batFaction = turnFight.getBatFaction(tagFaction)
|
if lineupNumSet != None and not tagFriendly:
|
lineupNumList = [lineupNumSet] # ÒѾÓÐÖ¸¶¨µÐ·½µÄijһÕóÈÝ
|
elif tagFaction == curFaction:
|
lineupNumList = [lineupNum] # ÓÑ·½ÔÝʱ½öÏÞÖÆ×Ô¼ºÕóÈÝ
|
else:
|
# µÐ·½ÓÅÏÈ: ÌØÊâÄ¿±êÕóÈÝ > ¶ÔλÕóÈÝ > ÆäËûÕóÈÝ
|
if specMainObj:
|
lineupNumList = [sepcObjLineupNum]
|
else:
|
lineupNumList = [lineupNum]
|
for tagNum in batFaction.lineupDict.keys():
|
if tagNum not in lineupNumList:
|
lineupNumList.append(tagNum)
|
|
batLineup = None
|
aimObjList = [] # ÏÈɸѡ³ö·¶Î§Ä¿±ê
|
for num in lineupNumList:
|
batLineup = batFaction.getBatlineup(num)
|
|
# ¶Ôλ
|
if tagAim == ChConfig.SkillTagAim_Relative:
|
if specMainObj:
|
aimObjList.append(specMainObj)
|
else:
|
relativeObj = __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup)
|
if relativeObj:
|
aimObjList.append(relativeObj)
|
|
# Ç°ÅÅ
|
elif tagAim == ChConfig.SkillTagAim_FrontRow:
|
aimObjList = __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, False, isNoSelf)
|
|
# ºóÅÅ
|
elif tagAim == ChConfig.SkillTagAim_BackRow:
|
aimObjList = __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, True, isNoSelf)
|
|
# ÊúÅÅ/×ÝÅÅ
|
elif tagAim == ChConfig.SkillTagAim_Vertical:
|
# ÓÅÏÈ×Ô¼ºËùÔÚ×Ý
|
inColNum = ChConfig.GetInColNum(posNum)
|
colNumList = range(1, 1 + ChConfig.TurnFightCols)
|
if inColNum in colNumList:
|
colNumList.remove(inColNum)
|
colNumList.insert(0, inColNum)
|
|
# ÓÅÏÈÌØÊâÄ¿±êËùÔÚ×Ý
|
if specMainObj:
|
specInColNum = ChConfig.GetInColNum(specObjPosNum)
|
if specInColNum in colNumList:
|
colNumList.remove(specInColNum)
|
colNumList.insert(0, specInColNum)
|
|
GameWorld.DebugLog("×ÝÅÅ: colNumList=%s,specObjID-PosNum=%s-%s" % (colNumList, specObjID, specObjPosNum))
|
for col in colNumList:
|
for row in range(1, 1 + ChConfig.TurnFightRows):
|
pNum = (row - 1) * ChConfig.TurnFightCols + col
|
#GameWorld.DebugLog(" col=%s,row=%s,pNum=%s" % (col, row, pNum))
|
if pNum not in batLineup.posObjIDDict:
|
continue
|
tagObjID = batLineup.posObjIDDict[pNum]
|
tagBatObj = batObjMgr.getBatObj(tagObjID)
|
if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
|
continue
|
aimObjList.append(tagBatObj)
|
if aimObjList:
|
break
|
|
# ÆäËû£¬Ä¬ÈÏÈ«²¿
|
else:
|
inColNum = ChConfig.GetInColNum(posNum) # Íæ¼ÒËùÔÚ×ÝÁÐ
|
# ÓÅÏÈ×Ô¼ºËùÔÚ×Ý
|
colNumList = range(1, 1 + ChConfig.TurnFightCols)
|
if inColNum in colNumList:
|
colNumList.remove(inColNum)
|
colNumList.insert(0, inColNum)
|
|
GameWorld.DebugLog("È«²¿: colNumList=%s,specObjID-PosNum=%s-%s" % (colNumList, specObjID, specObjPosNum))
|
# °´Ç°ÅÅÓÅÏÈÔÔò
|
for row in range(1, 1 + ChConfig.TurnFightRows):
|
for col in colNumList:
|
pNum = (row - 1) * ChConfig.TurnFightCols + col
|
#GameWorld.DebugLog(" col=%s,row=%s,pNum=%s" % (col, row, pNum))
|
if pNum not in batLineup.posObjIDDict:
|
continue
|
tagObjID = batLineup.posObjIDDict[pNum]
|
tagBatObj = batObjMgr.getBatObj(tagObjID)
|
if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
|
continue
|
aimObjList.append(tagBatObj)
|
|
# Ä¿±êϸ·Ö
|
# ѪÁ¿×îµÍ
|
if tagAffect == ChConfig.SkillTagAffect_HPLowest:
|
aimObjList.sort(key=lambda o:(o.GetHP()), reverse=False)
|
#GameWorld.DebugLog("ѪÁ¿×îµÍÅÅÐò: %s" % [[o.GetID(), o.GetHP(), o.GetMaxHP()] for o in aimObjList])
|
|
# ѪÁ¿×î¸ß
|
elif tagAffect == ChConfig.SkillTagAffect_HPHighest:
|
aimObjList.sort(key=lambda o:(o.GetHP()), reverse=True)
|
#GameWorld.DebugLog("ѪÁ¿×î¸ßÅÅÐò: %s" % [[o.GetID(), o.GetHP(), o.GetMaxHP()] for o in aimObjList])
|
|
# ¹¥»÷Á¦×î¸ß
|
elif tagAffect == ChConfig.SkillTagAffect_AtkHighest:
|
aimObjList.sort(key=lambda o:(o.GetAtk()), reverse=True)
|
#GameWorld.DebugLog("¹¥»÷Á¦×î¸ßÅÅÐò: %s" % [[o.GetID(), o.GetHP(), o.GetMaxHP()] for o in aimObjList])
|
|
# δ±»¿ØÖÆÓÅÏÈ
|
elif tagAffect == ChConfig.SkillTagAffect_UncontrolledPriority:
|
sneerObjFirst = False
|
aimObjList.sort(key=lambda o:(o.IsInControlled()))
|
GameWorld.DebugLog("δ±»¿ØÖÆÓÅÏÈ: %s" % [[o.GetID(), o.IsInControlled()] for o in aimObjList])
|
|
# ×ÆÉÕ/Ðþ»ðÄ¿±êÓÅÏÈ
|
elif tagAffect == ChConfig.SkillTagAffect_Burn:
|
atkBackTagFrist = False
|
relativeObj = __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup)
|
sortObjList = [] # ÓÅÏÈ×ÆÉÕÄ¿±ê£¬ÔÙ¶Ôλ
|
for aimObj in aimObjList:
|
sortValue = 0
|
buffMgr = aimObj.GetBuffManager()
|
if buffMgr.FindBuffListByState(ChConfig.BatObjState_Burn) or buffMgr.FindBuffListByState(ChConfig.BatObjState_BurnPlus):
|
sortValue = 2
|
elif relativeObj and relativeObj.GetID() == aimObj.GetID():
|
sortValue = 1
|
sortObjList.append([sortValue, aimObj])
|
sortObjList.sort(reverse=True)
|
aimObjList = [s[1] for s in sortObjList]
|
|
# ½ö·ÙѪ£¨¶¾ÄÌ£©Ä¿±ê
|
elif tagAffect == ChConfig.SkillTagAffect_PoisonCure:
|
atkBackTagFrist = False
|
for aimObj in aimObjList[::-1]:
|
if not aimObj.CheckInState(ChConfig.BatObjState_PoisonCure):
|
aimObjList.remove(aimObj)
|
else:
|
# ·¶Î§Ä¿±ê³¬¹ý¸öÊý£¬ÔòËæ»úÈ¡
|
if tagCount and len(aimObjList) > tagCount:
|
random.shuffle(aimObjList)
|
|
# ÒÔÏÂÓÅÏȼ¶ÏÈ´¦ÀíµÄÓÅÏȼ¶ÊÓΪ½ÏµÍ
|
if atkBackTagFrist and atkBackTag:
|
if atkBackTag in aimObjList and aimObjList.index(atkBackTag) != 0:
|
aimObjList.remove(atkBackTag)
|
aimObjList.insert(0, atkBackTag)
|
|
# ³°·íÓÅÏÈ
|
if sneerObjFirst and sneerTagObj:
|
if sneerTagObj in aimObjList and aimObjList.index(sneerTagObj) != 0:
|
aimObjList.remove(sneerTagObj)
|
aimObjList.insert(0, sneerTagObj)
|
|
# Ò»¶¨°üº¬×Ô¼º
|
if tagFriendly == 2 and not isNoSelf:
|
if curBatObj not in aimObjList:
|
aimObjList.append(curBatObj)
|
|
# ×îºóÈ¥³ý¶àÓàµÄÄ¿±ê
|
if tagCount and len(aimObjList) > tagCount:
|
aimObjList = aimObjList[:tagCount]
|
|
return aimObjList
|
|
def CheckChangeTagEff(turnFight, curBatObj, useSkill):
|
## ¼¼ÄÜ×ÔÉíÉ趨ǿÖÆÐÞ¸ÄÄ¿±ê£¬Ä¿Ç°Ôݶ¨ÓÅÏȼ¶×î¸ß£¬ÎÞÊÓÈí¿Ø
|
# IPY_Skill ûÓÐ GetEffectByID£¬Ôݲ»×öÖ§³Ö£¬Ä¿Ç°Ð¡ÇÇż¼×¨Óã¬ÒÔºóÓÐÓÃÓÚ±ðµÄÔÙ˵
|
if not hasattr(useSkill, "GetEffectByID"):
|
return
|
cureWayExEff = useSkill.GetEffectByID(ChConfig.SkillEff_ChangeTag)
|
if not cureWayExEff:
|
return
|
changeTagSet = cureWayExEff.GetEffectValue(0)
|
checkInStates = cureWayExEff.GetEffectValue(1)
|
if not checkInStates:
|
return None, changeTagSet
|
|
curFaction = curBatObj.GetFaction()
|
tagFaction = ChConfig.Def_FactionB if curFaction == ChConfig.Def_FactionA else ChConfig.Def_FactionA
|
batFaction = turnFight.getBatFaction(tagFaction)
|
|
lineupNum = curBatObj.GetLineupNum()
|
lineupNumList = [lineupNum] # µÐ·½ÓÅÏȶÔλÕóÈÝ£¬ÔÙÆäËûÕóÈÝ
|
for tagNum in batFaction.lineupDict.keys():
|
if tagNum not in lineupNumList:
|
lineupNumList.append(tagNum)
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for num in lineupNumList:
|
batLineup = batFaction.getBatlineup(num)
|
for tagID in batLineup.posObjIDDict.values():
|
tagObj = batObjMgr.getBatObj(tagID)
|
if tagObj.IsAlive() and tagObj.CheckInState(checkInStates):
|
return lineupNum, changeTagSet
|
return
|
|
def __getRowAimObjList(batObjMgr, curBatObj, specMainObj, batLineup, tagAffect, rowReverse, isNoSelf=False):
|
## »ñÈ¡ºáÅÅÄ¿±ê¶ÔÏóÁбí
|
# @param rowReverse: ÊÇ·ñºóÅÅÓÅÏÈÔÔò
|
# @param noSelf: ÊÇ·ñÏÞÖÆ°üº¬×Ô¼º
|
|
# Ç°ºóÅÅ˳Ðò
|
if rowReverse:
|
rowNumList = range(1, 1 + ChConfig.TurnFightRows)[::-1]
|
else:
|
rowNumList = range(1, 1 + ChConfig.TurnFightRows)
|
|
# ÓÅÏÈÌØÊâ¶ÔÏóËùÔÚÐÐ
|
specObjID, specObjPosNum = 0, 0
|
if specMainObj:
|
specObjID = specMainObj.GetID()
|
specObjPosNum = specMainObj.GetPosNum()
|
sneerInRowNum = ChConfig.GetInRowNum(specObjPosNum) # ËùÔÚÐÐÅÅ
|
if sneerInRowNum in rowNumList:
|
rowNumList.remove(sneerInRowNum)
|
rowNumList.insert(0, sneerInRowNum)
|
|
inColNum = ChConfig.GetInColNum(curBatObj.GetPosNum()) # Íæ¼ÒËùÔÚ×ÝÁÐ
|
# ÓÅÏÈ×Ô¼ºËùÔÚ×Ý£¬ÎªÖ÷Ä¿±ê
|
colNumList = range(1, 1 + ChConfig.TurnFightCols)
|
if inColNum in colNumList:
|
colNumList.remove(inColNum)
|
colNumList.insert(0, inColNum)
|
|
GameWorld.DebugLog("Ç°ºóÅÅ: rowNumList=%s,colNumList=%s,specObjID-PosNum=%s-%s" % (rowNumList, colNumList, specObjID, specObjPosNum))
|
aimObjList = []
|
for row in rowNumList:
|
for col in colNumList:
|
pNum = (row - 1) * ChConfig.TurnFightCols + col
|
#GameWorld.DebugLog(" row=%s,col=%s,pNum=%s" % (row, col, pNum))
|
if pNum not in batLineup.posObjIDDict:
|
continue
|
tagObjID = batLineup.posObjIDDict[pNum]
|
tagBatObj = batObjMgr.getBatObj(tagObjID)
|
if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf):
|
continue
|
aimObjList.append(tagBatObj)
|
if aimObjList:
|
break
|
|
return aimObjList
|
|
def GetRelativeObj(turnFight, curBatObj):
|
'''»ñÈ¡¶ÔλĿ±ê£¬½öÓÃÓڷǼ¼ÄÜÄ¿±êµÄ¶ÔλÂß¼£¬ÈçÁ¬»÷¡¢ÈõÁƵÈÏà¶ÔÊôÐÔµÄÅжϣ¬¼¼ÄÜÄ¿±êͳһʹÓà GetSkillTags
|
'''
|
sneerObj = curBatObj.GetSneerTagObj()
|
if sneerObj:
|
# Óг°·íÄ¿±êÓÅÏÈÖ±½Ó¶Ôλ
|
return sneerObj
|
|
curFaction = curBatObj.GetFaction()
|
# ĬÈ϶ÔλµÐ¶ÔÕóÓª
|
tagFaction = ChConfig.Def_FactionB if curFaction == ChConfig.Def_FactionA else ChConfig.Def_FactionA
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
lineupNum = curBatObj.GetLineupNum()
|
posNum = curBatObj.GetPosNum()
|
|
batFaction = turnFight.getBatFaction(tagFaction)
|
lineupNumList = [lineupNum] # µÐ·½ÓÅÏȶÔλÕóÈÝ£¬ÔÙÆäËûÕóÈÝ£¬Ö§³Ö¶àÕóÈݶÔÕ½
|
for tagNum in batFaction.lineupDict.keys():
|
if tagNum not in lineupNumList:
|
lineupNumList.append(tagNum)
|
|
for num in lineupNumList:
|
batLineup = batFaction.getBatlineup(num)
|
relativeObj = __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup)
|
if relativeObj:
|
return relativeObj
|
|
# ÀíÂÛÉÏÖ»ÒªÕ½¶·Ã»ÓнáÊø£¬Ò»¶¨»áÓжÔλĿ±ê£¬ÕâÀïĬÈÏ·µ»Ø×Ô¼º£¬·½±ãÍâ²ãÂß¼´¦Àí£¬Íâ²ã¿É²»ÐèÒªÅжÏÊÇ·ñ´æÔÚ¶ÔλĿ±ê
|
return curBatObj
|
|
def __GetRelativeObjDefault(batObjMgr, curBatObj, posNum, batLineup):
|
## »ñÈ¡ÔÚijһÕóÈÝÖеÄĬÈ϶ÔλĿ±ê£¬²»°üÀ¨×Ô¼º
|
if not batLineup:
|
return
|
tagAffect = ChConfig.SkillTagAffect_None # ĬÈ϶ÔλĿ±ê²»ÐèҪϸ·ÖÄ¿±ê£¬Ä¬ÈϹæÔò¼´¿É
|
inColNum = ChConfig.GetInColNum(posNum) # Íæ¼ÒËùÔÚ×ÝÁÐ
|
# ÓÅÏÈ×Ô¼ºËùÔÚ×Ý
|
colNumList = range(1, 1 + ChConfig.TurnFightCols)
|
if inColNum in colNumList:
|
colNumList.remove(inColNum)
|
colNumList.insert(0, inColNum)
|
|
# °´Ç°ÅÅÓÅÏÈÔÔò
|
for row in range(ChConfig.TurnFightRows):
|
for col in colNumList:
|
pNum = row * ChConfig.TurnFightCols + col
|
if pNum not in batLineup.posObjIDDict:
|
continue
|
tagObjID = batLineup.posObjIDDict[pNum]
|
tagBatObj = batObjMgr.getBatObj(tagObjID)
|
if not __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf=True):
|
continue
|
return tagBatObj
|
|
return
|
|
def __skillTagFilter(curBatObj, tagBatObj, tagAffect, isNoSelf=False):
|
## ¼¼ÄÜÄ¿±ê¹ýÂËÆ÷
|
# @return: ÊÇ·ñÔÊÐíÌí¼Ó¸Ãµ¥Î»
|
if not tagBatObj:
|
return False
|
if tagAffect != ChConfig.SkillTagAffect_Death and not tagBatObj.IsAlive():
|
return False
|
if tagAffect == ChConfig.SkillTagAffect_Death and tagBatObj.IsAlive():
|
return False
|
if isNoSelf:
|
if tagBatObj.GetID() == curBatObj.GetID():
|
#GameWorld.DebugLog("²»°üº¬×Ô¼º")
|
return False
|
#if not tagBatObj.GetCanAttack(): ²ß»®ÒªÇ󲻿ɹ¥»÷µÄ¶ÔÏóÒ²Òª¿ÉÑ¡ÖÐ
|
# return False
|
return True
|
|
def __doAddBuff(turnFight, curBatObj, useSkill):
|
#Ö´ÐÐÌí¼Óbuff
|
|
#¹â»·¼¼ÄÜ£¬ÐèÏÈÌí¼ÓÊ©·¨Õß
|
if useSkill.GetSkillType() == ChConfig.Def_SkillType_Halo:
|
curID = curBatObj.GetID()
|
skillID = useSkill.GetSkillID()
|
GameWorld.DebugLog("¹â»·¼¼ÄÜÏȸøÊ©·¨ÕßÌí¼Ó¹âÔ´buff! skillID=%s,ownerID=%s" % (skillID, curID))
|
if TurnBuff.OnAddBuff(turnFight, curBatObj, useSkill, buffOwner=curBatObj):
|
for tagBatObj in useSkill.GetTagObjList():
|
if tagBatObj.GetID() == curBatObj.GetID():
|
continue
|
TurnBuff.OnAddBuff(turnFight, tagBatObj, useSkill, buffOwner=curBatObj)
|
else:
|
for tagBatObj in useSkill.GetTagObjList():
|
TurnBuff.OnAddBuff(turnFight, tagBatObj, useSkill, buffOwner=curBatObj)
|
|
return
|
|
def __doUseSkill(turnFight, curBatObj, useSkill):
|
|
atkType = useSkill.GetAtkType()
|
GameWorld.DebugLog("__doUseSkill: curID=%s,skillID=%s,atkType=%s" % (curBatObj.GetID(), useSkill.GetSkillID(), atkType))
|
|
__doHarmSelf(turnFight, curBatObj, useSkill)
|
|
# ͨÓù¥»÷
|
if atkType == 1:
|
SkillModule_1(turnFight, curBatObj, useSkill)
|
# ÖÎÁÆ
|
if atkType == 2:
|
SkillModule_2(turnFight, curBatObj, useSkill)
|
# ¸´»î
|
elif atkType == 3:
|
pass
|
# ¶à´Î¹¥»÷£¨ËøÄ¿±ê¶à´ÎÉ˺¦£¬·ÇÇ°¶ËµÄ¶à¶ÎƮѪ£©
|
elif atkType == 4:
|
pass
|
# µ¯Éä¹¥»÷
|
elif atkType == 5:
|
SkillModule_5(turnFight, curBatObj, useSkill)
|
# ÅÆøÔö
|
elif atkType == 6:
|
SkillModule_6(turnFight, curBatObj, useSkill, "Increase")
|
# ÅÆø¼õ
|
elif atkType == 7:
|
SkillModule_6(turnFight, curBatObj, useSkill, "Reduce")
|
# ÅÆø͵
|
elif atkType == 8:
|
SkillModule_6(turnFight, curBatObj, useSkill, "Steal")
|
# µ¯ÉäÖÎÁÆ
|
elif atkType == 9:
|
SkillModule_9(turnFight, curBatObj, useSkill)
|
|
return
|
|
def __doHarmSelf(turnFight, curBatObj, useSkill):
|
## Ê©·¨Ç°×Ô²Ð
|
harmEff = useSkill.GetEffectByID(ChConfig.SkillEff_UseSkillHarmSelf)
|
if not harmEff:
|
return
|
harmPer = harmEff.GetEffectValue(0) # ×ԲаٷֱÈ
|
noEnoughDo = harmEff.GetEffectValue(1) # ²»×ãʱ¿Û³ý·½Ê½ 0-²»¿Û£»1-×Ôɱ£»2-¿ÛÊ£1µã
|
curHP = curBatObj.GetHP()
|
maxHP = curBatObj.GetMaxHP()
|
harmHP = int(maxHP * harmPer / 100.0)
|
lostHP = harmHP
|
if curHP <= harmHP:
|
if noEnoughDo == 0:
|
lostHP = 0
|
elif noEnoughDo == 2:
|
lostHP -= 1
|
|
updHP = max(curHP - lostHP, 0)
|
curBatObj.SetHP(updHP, False)
|
GameWorld.DebugLog("ʹÓü¼ÄÜʱ×Ô²Ð: curHP=%s/%s,harmPer=%s,harmHP=%s,lostHP=%s,updHP=%s,noEnoughDo=%s"
|
% (curHP, maxHP, harmPer, harmHP, lostHP, updHP, noEnoughDo))
|
|
curBatObj.SetHarmSelfHP(harmHP) # ÎÞÊÓʵ¼Ê¿ÛѪÁ¿£¬Ö±½Ó¸üÐÂ
|
|
# µ¥¶À֪ͨǰ¶Ë±íÏÖ
|
hurtTypes = pow(2, ChConfig.HurtType_HarmSelf)
|
diffType, diffValue = 0, lostHP
|
skillID = relatedSkillID = useSkill.GetSkillID()
|
Sync_PropertyRefreshView(turnFight, curBatObj, ChConfig.AttrID_HP, updHP, diffValue, diffType, skillID, relatedSkillID, hurtTypes)
|
return
|
|
def SkillModule_1(turnFight, curBatObj, useSkill):
|
## ͨÓù¥»÷£¬µ¥¹¥¡¢Èº¹¥
|
|
# ¼ÆËãÉ˺¦
|
calcHurtResults = []
|
for tagBatObj in useSkill.GetTagObjList():
|
hurtValue, hurtTypes, immuneHurt = __calcSkillHurt(turnFight, curBatObj, tagBatObj, useSkill)
|
calcHurtResults.append([tagBatObj, hurtValue, hurtTypes, immuneHurt])
|
|
DoSkillHurtHP(turnFight, curBatObj, useSkill, calcHurtResults)
|
return
|
|
def __calcSkillHurt(turnFight, atkObj, defObj, curSkill):
|
## ¼ÆËã¼¼ÄÜÉ˺¦£¬Ö»¼ÆËãÖµ£¬²»×öʵ¼Ê´¦Àí
|
# @return: hurtValue, hurtTypes, immuneHurt
|
atkSkillPer = curSkill.GetSkillPer()
|
atkSkillValue = curSkill.GetSkillValue()
|
hurtValue, hurtTypes = CalcFormatHurt(turnFight, atkObj, defObj, curSkill, atkSkillValue, atkSkillPer)
|
hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes)
|
return hurtValue, hurtTypes, immuneHurt
|
|
def SkillModule_5(turnFight, curBatObj, useSkill):
|
## µ¯É䣨¶à´Î¹¥»÷£¬Çл»Ä¿±ê£¬µ¥Ä¿±ê¿É¶à´Î£©
|
|
ricochetObjList = GetRicochetObjRankList(turnFight, curBatObj, useSkill)
|
|
# µ¯Éä¼¼ÄÜÐèÏÈ´Óµ¯ÉäÄ¿±êÀïԤѡºÃ²ÜÈÊÒª·À»¤µÄ¶ÔÏó
|
caorenProtectObj = None # ²ÜÈʱ£»¤µÄÄ¿±ê£¬ÑªÁ¿×îµÍµÄ£¬²ÜÈÊרÓ㬲»µ²×Ô¼º£¬²»µ²Î޵У¬Ë³ÑÓÖ±µ½Ò»¸ö¿ÉÒÔµ²µÄ×îµÍѪÁ¿Ä¿±ê£¬Èç¹ûûÓоͲ»µ²
|
for tagObj in ricochetObjList:
|
tagID = tagObj.GetID()
|
if tagID == ChConfig.HeroID_Caoren:
|
continue
|
if tagObj.CheckInState(ChConfig.BatObjState_Wudi):
|
continue
|
if not caorenProtectObj or tagObj.GetHP() < caorenProtectObj.GetHP():
|
caorenProtectObj = tagObj
|
if caorenProtectObj == None:
|
caorenProtectObj = 0 # ±ê¼ÇΪÒÑɸѡ¹ý
|
|
# °´Ë³ÐòÒ»¸ö¸öµ¯É˺¦
|
for tagBatObj in ricochetObjList:
|
hurtValue, hurtTypes, immuneHurt = __calcSkillHurt(turnFight, curBatObj, tagBatObj, useSkill)
|
|
calcHurtResults = [[tagBatObj, hurtValue, hurtTypes, immuneHurt]]
|
DoSkillHurtHP(turnFight, curBatObj, useSkill, calcHurtResults, "RicochetHurt", caorenProtectObj, isManyTimes=True)
|
|
return
|
|
def GetRicochetObjRankList(turnFight, curBatObj, useSkill):
|
## »ñÈ¡µ¯ÉäÄ¿±ê¶ÓÁÐ
|
ricochetCnt = useSkill.GetTagCount() # µ¯Éä´ÎÊý£¬Ä¬ÈÏÈ¡¼¼ÄÜÄ¿±êÊý
|
randEffect = useSkill.GetEffectByID(ChConfig.SkillEff_RandRicochetCnt)
|
if randEffect:
|
valueA = randEffect.GetEffectValue(0)
|
valueB = max(randEffect.GetEffectValue(1), valueA)
|
ricochetCnt = random.randint(valueA, valueB)
|
GameWorld.DebugLog("Ëæ»úµ¯Éä´ÎÊý: %s,valueA=%s,valueB=%s" % (ricochetCnt, valueA, valueB))
|
ricochetCnt += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddRicochetCnt, useSkill)
|
|
# µ¯É䣺ÓÅÏȵ¯Éä´ÎÊýÉÙµÄÄ¿±ê£¬ÏàͬĿ±ê¿Éµ¯Éä¶à´Î
|
tagObjList = useSkill.GetTagObjList()
|
random.shuffle(tagObjList)
|
objCnt = len(tagObjList)
|
ricochetObjList = []
|
ricochetObjIDList = []
|
for index in range(ricochetCnt):
|
tagObj = tagObjList[index % objCnt]
|
ricochetObjList.append(tagObj)
|
ricochetObjIDList.append(tagObj.GetID())
|
|
GameWorld.DebugLog("µ¯Éä´ÎÊý: %s, ricochetObjIDList=%s" % (ricochetCnt, ricochetObjIDList))
|
return ricochetObjList
|
|
def SkillModule_2(turnFight, curBatObj, useSkill):
|
## ÖÎÁÆ
|
|
calcCureResults = []
|
relativeObj = GetRelativeObj(turnFight, curBatObj)
|
for tagBatObj in useSkill.GetTagObjList():
|
cureHP = CalcCureHP(turnFight, curBatObj, tagBatObj, useSkill, relativeObj=relativeObj)
|
poisonCureOwner = GetPoisonCureOwner(tagBatObj)
|
calcCureResults.append([tagBatObj, cureHP, poisonCureOwner])
|
|
DoSkillCureHP(turnFight, curBatObj, useSkill, calcCureResults)
|
return
|
|
def SkillModule_9(turnFight, curBatObj, useSkill):
|
## µ¯ÉäÖÎÁÆ£¨¶à´ÎÖÎÁÆ£¬Çл»Ä¿±ê£¬µ¥Ä¿±ê¿É¶à´Î£©
|
|
relativeObj = GetRelativeObj(turnFight, curBatObj)
|
ricochetObjList = GetRicochetObjRankList(turnFight, curBatObj, useSkill)
|
|
# µ¯Éä¼¼ÄÜÐèÏÈ´Óµ¯ÉäÄ¿±êÀïԤѡºÃ²ÜÈÊÒª·À»¤µÄ¶ÔÏó£¬Óж¾Ä̵ÄÇé¿ö
|
poisonCureOwnerDict = {}
|
caorenProtectObj = None # ²ÜÈʱ£»¤µÄÄ¿±ê£¬ÑªÁ¿×îµÍµÄ£¬²ÜÈÊרÓ㬲»µ²×Ô¼º£¬²»µ²Î޵У¬Ë³ÑÓÖ±µ½Ò»¸ö¿ÉÒÔµ²µÄ×îµÍѪÁ¿Ä¿±ê£¬Èç¹ûûÓоͲ»µ²
|
for tagObj in ricochetObjList:
|
tagID = tagObj.GetID()
|
if tagID not in poisonCureOwnerDict:
|
poisonCureOwner = GetPoisonCureOwner(tagObj)
|
poisonCureOwnerDict[tagID] = poisonCureOwner
|
poisonCureOwner = poisonCureOwnerDict[tagID]
|
if not poisonCureOwner:
|
continue
|
if tagID == ChConfig.HeroID_Caoren:
|
continue
|
if tagObj.CheckInState(ChConfig.BatObjState_Wudi):
|
continue
|
if not caorenProtectObj or tagObj.GetHP() < caorenProtectObj.GetHP():
|
caorenProtectObj = tagObj
|
if caorenProtectObj == None:
|
caorenProtectObj = 0 # ±ê¼ÇΪÒÑɸѡ¹ý
|
|
for tagBatObj in ricochetObjList:
|
cureHP = CalcCureHP(turnFight, curBatObj, tagBatObj, useSkill, relativeObj=relativeObj)
|
poisonCureOwner = poisonCureOwnerDict.get(tagBatObj.GetID())
|
calcCureResults = [[tagBatObj, cureHP, poisonCureOwner]]
|
|
DoSkillCureHP(turnFight, curBatObj, useSkill, calcCureResults, "RicochetCure", caorenProtectObj, isManyTimes=True)
|
|
return
|
|
def DoSkillCureHP(turnFight, atkObj, curSkill, calcCureResults, lostType="", caorenProtectObj=None, isManyTimes=False):
|
'''½áËã¼¼ÄÜÖÎÁÆ
|
@param calcCureResults: ¼¼Äܹ«Ê½¼ÆËãºóµÄÉ˺¦½á¹û [[tagBatObj, cureHP, poisonCureOwner], ...]
|
@param caorenProtectObj: ²ÜÈÊרÓã¬Òª·À»¤µÄ¶ÔÏó
|
@param isManyTimes: ÊÇ·ñÊǺó¶Ë¶à´Î¼ÆËãµÄ
|
'''
|
|
skillID = curSkill.GetSkillID()
|
calcHurtResults = []
|
for tagBatObj, cureHP, poisonCureOwner in calcCureResults:
|
# »ã×ܶ¾ÄÌ
|
if poisonCureOwner:
|
hurtTypes = pow(2, ChConfig.HurtTYpe_Cure)
|
hurtTypes |= pow(2, ChConfig.HurtType_PoisonCureHurt)
|
hurtValue = cureHP
|
hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, tagBatObj, hurtValue, hurtTypes)
|
calcHurtResults.append([tagBatObj, hurtValue, hurtTypes, immuneHurt])
|
continue
|
|
# ·Ç¶¾Ä̵ÄÖ´ÐÐÖÎÁÆ
|
dID = tagBatObj.GetID()
|
dHP = tagBatObj.GetHP()
|
dMapHP = tagBatObj.GetMaxHP()
|
|
remainHP = min(dHP + cureHP, dMapHP)
|
realCureHP = max(remainHP - dHP, 0)
|
tagBatObj.SetHP(remainHP)
|
|
hurtObj = curSkill.AddHurtObj(dID)
|
hurtObj.AddHurtType(ChConfig.HurtTYpe_Cure)
|
hurtObj.SetHurtHP(cureHP)
|
hurtObj.SetLostHP(realCureHP)
|
hurtObj.SetCurHP(tagBatObj.GetHP())
|
GameWorld.DebugLog(" ÖÎÁÆ: dID=%s,cureHP=%s,realCureHP=%s,%s/%s" % (dID, cureHP, realCureHP, tagBatObj.GetHP(), dMapHP))
|
|
TurnAttack.AddTurnObjCureHP(tagBatObj, atkObj, cureHP, realCureHP, skillID)
|
|
# ÔÙ½áË㶾ÄÌÉ˺¦
|
DoSkillHurtHP(turnFight, atkObj, curSkill, calcHurtResults, "PoisonCure", caorenProtectObj, isManyTimes)
|
return
|
|
def GetPoisonCureOwner(defObj):
|
## »ñÈ¡Íæ¼ÒÉíÉϵĶ¾ÄÌbuff¹éÊôÕß
|
# @return: buffOwner or None-ÎÞ¶¾ÄÌbuff
|
buffMgr = defObj.GetBuffManager()
|
poisonCureBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_PoisonCure) # ¶¾ÄÌÔݶ¨Î¨Ò»
|
if not poisonCureBuff:
|
return
|
ownerID = poisonCureBuff.GetOwnerID()
|
buffOwner = BattleObj.GetBatObjMgr().getBatObj(ownerID) # ¹¥»÷·½
|
return buffOwner
|
|
def DoCureOfTime(turnFight, batObj, curBuff, cureHP, **kwargs):
|
## Ö´ÐгÖÐøÖÎÁƵ¥´ÎÂß¼
|
skillID = curBuff.GetSkillID()
|
skillIpyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
|
if not skillIpyData:
|
return
|
buffID = curBuff.GetBuffID()
|
ownerID = curBuff.GetOwnerID()
|
buffOwner = BattleObj.GetBatObjMgr().getBatObj(ownerID) # ÖÎÁÆ·½
|
if not buffOwner:
|
return
|
|
defObj = batObj
|
poisonCureOwner = GetPoisonCureOwner(defObj)
|
atkObj = poisonCureOwner if poisonCureOwner else buffOwner
|
|
atkID = atkObj.GetID()
|
defID = defObj.GetID()
|
|
# ½áËãÐèҪͬ²½±êÇ©
|
useTag = "Skill_%s_%s_Cot" % (atkID, skillID)
|
Sync_TurnFightTag(turnFight, useTag, 0)
|
|
dHP = defObj.GetHP()
|
dMaxHP = defObj.GetMaxHP()
|
GameWorld.DebugLog("½áËã³ÖÐøÖÎÁÆ: atkID=%s,defID=%s,buffID=%s,skillID=%s,ownerID=%s,cureHP=%s,dHP=%s/%s"
|
% (atkID, defID, buffID, skillID, ownerID, cureHP, dHP, dMaxHP))
|
layer = curBuff.GetLayer()
|
if layer > 0:
|
cureHP *= layer
|
GameWorld.DebugLog(" ¶à²ãbuff: cureHP=%s,layer=%s" % (cureHP, layer))
|
#if "FinalDamPer" in kwargs:
|
# FinalDamPer = kwargs["FinalDamPer"]
|
# hurtValue *= (10000 + FinalDamPer) / 10000.0
|
# GameWorld.DebugLog(" ÔöÉË: hurtValue=%s,FinalDamPer=%s" % (hurtValue, FinalDamPer))
|
|
poolMgr = ObjPool.GetPoolMgr()
|
useSkill = poolMgr.acquire(BattleObj.PySkill, skillIpyData, atkID)
|
useSkill.SetTagObjList([defObj])
|
useSkill.SetBatType(ChConfig.TurnBattleType_Cot)
|
|
poisonCureOwner = GetPoisonCureOwner(defObj)
|
if poisonCureOwner:
|
GameWorld.DebugLog("±¾´ÎÖÎÁÆΪ¶¾ÄÌ: cureHP=%s" % cureHP)
|
hurtValue = cureHP
|
hurtTypes = pow(2, ChConfig.HurtTYpe_Cure)
|
hurtTypes |= pow(2, ChConfig.HurtType_PoisonCureHurt)
|
hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, poisonCureOwner, defObj, hurtValue, hurtTypes)
|
calcHurtResults = [[defObj, hurtValue, hurtTypes, immuneHurt]]
|
DoSkillHurtHP(turnFight, poisonCureOwner, useSkill, calcHurtResults, "PoisonCOT")
|
else:
|
remainHP = min(dHP + cureHP, dMaxHP)
|
realCureHP = max(remainHP - dHP, 0)
|
defObj.SetHP(remainHP)
|
|
hurtObj = useSkill.AddHurtObj(defID)
|
hurtObj.AddHurtType(ChConfig.HurtTYpe_Cure)
|
hurtObj.SetHurtHP(cureHP)
|
hurtObj.SetLostHP(realCureHP)
|
hurtObj.SetCurHP(defObj.GetHP())
|
GameWorld.DebugLog(" ÖÎÁÆ: dID=%s,cureHP=%s,realCureHP=%s,%s/%s" % (defID, cureHP, realCureHP, defObj.GetHP(), dMaxHP))
|
|
TurnAttack.AddTurnObjCureHP(defObj, atkObj, cureHP, realCureHP, skillID)
|
|
Sync_UseSkill(turnFight, atkObj, useSkill)
|
|
DoBeAttackResult(turnFight, atkObj, useSkill)
|
|
# ֪ͨ½áÊø±êÇ©
|
Sync_TurnFightTag(turnFight, useTag, 1)
|
|
useSkill.ResetUseRec()
|
poolMgr.release(useSkill)
|
return
|
|
def SkillModule_6(turnFight, curBatObj, useSkill, opType):
|
## ÅÆøÔö¼õ͵
|
|
curID = curBatObj.GetID()
|
skillID = useSkill.GetSkillID()
|
bySkill = useSkill.GetBySkill()
|
relatedSkillID = bySkill.GetSkillID() if bySkill else 0
|
|
#cureType = useSkill.GetCalcType()
|
skillPer = useSkill.GetSkillPer()
|
skillValue = useSkill.GetSkillValue()
|
|
xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2)
|
calcValue = int(xpMax * skillPer / 10000.0 + skillValue)
|
attrID = ChConfig.AttrID_XP
|
|
GameWorld.DebugLog("ÅÆø%s: curID=%s,calcValue=%s,skillID=%s,skillPer=%s,skillValue=%s,relatedSkillID=%s"
|
% (opType, curID, calcValue, skillID, skillPer, skillValue, relatedSkillID))
|
curStealTotal = 0
|
for tagBatObj in useSkill.GetTagObjList():
|
|
tagID = tagBatObj.GetID()
|
# ¼õ
|
if opType == "Reduce":
|
diffType = 0
|
tagXP = tagBatObj.GetXP()
|
diffValue = min(tagXP, calcValue) # È¡½ÏСֵ£¬²»×ãʱʣ¶àÉÙ¼õ¶àÉÙ
|
updValue = tagXP - diffValue
|
tagBatObj.SetXP(updValue, False)
|
GameWorld.DebugLog(" ¼õÅÆø: tagID=%s,diffValue=%s,tagXP=%s,updXP=%s" % (tagID, diffValue, tagXP, updValue))
|
Sync_PropertyRefreshView(turnFight, tagBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
|
|
# ͵
|
elif opType == "Steal":
|
diffType = 0
|
tagXP = tagBatObj.GetXP()
|
diffValue = min(tagXP, calcValue) # È¡½ÏСֵ£¬²»×ãʱʣ¶àÉÙ¼õ¶àÉÙ
|
updValue = tagXP - diffValue
|
tagBatObj.SetXP(updValue, False)
|
GameWorld.DebugLog(" ͵ÅÆø: tagID=%s,diffValue=%s,tagXP=%s,updXP=%s" % (tagID, diffValue, tagXP, updValue))
|
Sync_PropertyRefreshView(turnFight, tagBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
|
|
curStealTotal += diffValue
|
|
# ÆäËûĬÈϼÓ
|
else:
|
diffType = 1
|
tagXP = tagBatObj.GetXP()
|
diffValue = GetEnhanceXP(tagBatObj, calcValue)
|
updValue = tagXP + diffValue
|
tagBatObj.SetXP(updValue, False)
|
GameWorld.DebugLog(" ¼ÓÅÆø: tagID=%s,diffValue=%s,tagXP=%s,updXP=%s" % (tagID, diffValue, tagXP, updValue))
|
Sync_PropertyRefreshView(turnFight, tagBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
|
|
if curStealTotal > 0:
|
diffType = 1
|
curXP = curBatObj.GetXP()
|
diffValue = GetEnhanceXP(tagBatObj, curStealTotal)
|
updValue = curXP + diffValue
|
curBatObj.SetXP(updValue, False)
|
GameWorld.DebugLog(" ¼Ó×ÜÅÆø: curID=%s,curStealTotal=%s,curXP=%s,diffValue=%s,updXP=%s" % (curID, curStealTotal, curXP, diffValue, updValue))
|
Sync_PropertyRefreshView(turnFight, curBatObj, attrID, updValue, diffValue, diffType, skillID, relatedSkillID)
|
|
return
|
|
def DoAttackResult(turnFight, curBatObj, useSkill):
|
'''Ö´Ðй¥»÷½á¹û
|
@param curBatObj: Ê©·¨·½»òbuff¹éÊô·½
|
'''
|
|
if curBatObj:
|
# ·´µ¯¡¢ÎüѪ¡¢Æ½Ì¯É˺¦×ԲРµÄÔÒò£¬ÐèҪͳһ´¦Àíºó½áË㣬¿ÉÄܵ¼ÖÂHPΪ¸ºÖµ£¬ÐÞÕýΪ0
|
if curBatObj.GetHP() < 0:
|
curBatObj.SetHP(0)
|
|
if useSkill.GetBatType() == ChConfig.TurnBattleType_AtkBack:
|
curBatObj.AddBigTurnAtkbackCnt()
|
skillID = useSkill.GetSkillID()
|
curBatObj.AddSkillUseCnt(skillID)
|
if useSkill.GetCoolDownTime():
|
useSkill.SetRemainTime(useSkill.GetCoolDownTime())
|
|
# ÐèÏȼ¼ÄÜʹÓà - Ç°¶Ë°´Ë³ÐòÓÅÏȱíÏÖ¼¼ÄÜÊÍ·ÅÄÚÈÝ£¬Ç°¶ËÐèÒª¶¯×÷»òÓÐÉËѪÔò֪ͨ
|
if IsNeedSyncSkill(useSkill):
|
Sync_UseSkill(turnFight, curBatObj, useSkill)
|
|
__doCostZhanchui(turnFight, curBatObj, useSkill)
|
__doSkillUserAnger(turnFight, curBatObj, useSkill)
|
|
DoBeAttackResult(turnFight, curBatObj, useSkill, True)
|
return
|
|
def DoCombo(turnFight, atkObj, useSkill):
|
'''
|
¸ñµ²¡¢·´»÷¡¢Á¬»÷¹æÔò
|
1. ËùÓÐÎ佫»ò¹ÖÎï¾ù¿ÉÄܲúÉú¸ñµ²£¬Èº¹¥Ê±¸ñµ²Ò»¶ÔÒ»Åжϣ¬¾ù¿ÉÄܲúÉú¸ñµ²
|
2. ½öÆÕ¹¥Ê±¿É±»·´»÷£¬·´Åжϱ¾´Î¼¼ÄÜÄ¿±êÖеÄÖ÷Ä¿±ê£¨¼´¶ÔλĿ±ê£©ÊÇ·ñ²úÉú¸ñµ²£¬ÇÒÊǽüÕ½Î佫£¬ÊǵĻ°¿É·´»÷
|
|
Á¬»÷£º
|
1. ½öÆÕ¹¥¿ÉÁ¬»÷£¬·´»÷´ò¶ÏÁ¬»÷
|
2. ·Ç¶ÔµÐ¼¼ÄÜ£¬ÈçÄÌÂè»ØѪÆÕ¹¥£¬Åж϶ÔλĿ±ê¿¹Á¬ÊôÐÔÊÇ·ñ¿ÉÁ¬»÷
|
3. ¶ÔµÐ¼¼ÄÜ£¬Åжϱ¾´Î¼¼ÄÜÄ¿±êÖеÄÖ÷Ä¿±ê£¨¼´¶ÔλĿ±ê£©¿¹Á¬ÊôÐÔÊÇ·ñ¿ÉÁ¬»÷
|
|
¶ÔµÐ¼¼ÄÜÖ÷Ä¿±ê£º
|
µ¥Ì壺 ĬÈϸÃÄ¿±ê
|
³°·í£º ÓÅÏȱ»³°·íµÄÄ¿±ê
|
ºáÅÅ£º ÓÅÏȸÃÅÅÖÐÓë×Ô¼ºÍ¬Áеģ¬·ñÔò°´Ë³Ðò
|
×ÝÅÅ£º ÓÅÏÈÇ°ÃæµÄµ¥Î»
|
'''
|
|
if turnFight.winFaction:
|
return
|
|
if not useSkill.ComboEnable():
|
return
|
|
if not atkObj.IsAlive():
|
return
|
|
tagFriendly = useSkill.GetTagFriendly()
|
if tagFriendly:
|
tagObj = GetRelativeObj(turnFight, atkObj)
|
else:
|
tagObjList = useSkill.GetTagObjList()
|
if not tagObjList:
|
return
|
tagObj = tagObjList[0] # µÚÒ»¸öĬÈÏΪÖ÷Ä¿±ê£¬¼¼ÄܶÔÏóÑ¡ÔñÂ߼ʱ¾ö¶¨Ö÷Ä¿±ê
|
atkBackSkill = __getCanAtkBackSkill(atkObj, tagObj, useSkill)
|
if atkBackSkill:
|
# ¿ÉÒÔ·´»÷£¬´ò¶ÏÁ¬»÷
|
GameWorld.DebugLog("¡ñ %s ¡¾·´»÷¡¿" % TurnAttack.GetObjName(tagObj))
|
OnUseSkill(turnFight, tagObj, atkBackSkill, batType=ChConfig.TurnBattleType_AtkBack, atkBackTag=atkObj)
|
return
|
|
if not tagObj:
|
return
|
|
comboNum = useSkill.GetComboNum()
|
aComboRate = atkObj.GetBatAttrValue(ChConfig.AttrID_ComboRate)
|
aComboRate += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, tagObj, ChConfig.AttrID_ComboRate, useSkill)
|
|
dComboRateDef = tagObj.GetBatAttrValue(ChConfig.AttrID_ComboRateDef)
|
happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("ComboCfg", 1))
|
if not GameWorld.CanHappen(happenRate):
|
GameWorld.DebugLog("ÎÞ·¨Á¬»÷! atkID=%s,happenRate=%s,aComboRate=%s,dComboRateDef=%s,comboNum=%s"
|
% (atkObj.GetID(), happenRate, aComboRate, dComboRateDef, comboNum))
|
return
|
GameWorld.DebugLog("¡ñ %s ¡¾Á¬»÷¡¿ happenRate=%s,aComboRate=%s,dComboRateDef=%s,comboNum=%s"
|
% (TurnAttack.GetObjName(atkObj), happenRate, aComboRate, dComboRateDef, comboNum))
|
useSkill.SetComboNum(comboNum + 1)
|
|
# Á¬»÷Ìس¤
|
DoHeroSpecialty(turnFight, atkObj, ChConfig.HeroSpecialty_Combo, useSkill.GetSkillID())
|
|
# Á¬»÷¸ù¾Ý¼¼ÄÜÄ¿±êÅäÖÃÂß¼ÖØÐÂÑ¡ÔñÄ¿±ê
|
OnUseSkill(turnFight, atkObj, useSkill, batType=ChConfig.TurnBattleType_Combo)
|
return True
|
|
def __getCanAtkBackSkill(atkObj, tagObj, useSkill):
|
'''»ñÈ¡ÊÇ·ñ¿É·´»÷¼°·´»÷¼¼ÄÜ
|
B½ø¹¥A1 A2 A3£¬Ö÷Ä¿±ê£¨´ÓA1 A2 A3Ñ¡£©
|
Ö÷Ä¿±ê´¥·¢¸ñµ²Ê±£¬ÈôBΪ½üÕ½£¬·¢¶¯·´»÷£¬·Ç½üÕ½£¬²»·¢¶¯·´»÷£¬·´»÷ÒÔÆÕ¹¥½øÐз´»÷
|
ÈôΪ·Ç¹¥»÷À࣬Ôò°´¼¼ÄÜÔÀ´µÄÄ¿±ê
|
ÈôÆÕ¹¥Êǹ¥»÷À༼ÄÜÔòÐ޸ļ¼ÄÜ×ݺáΪBËùÔÚ×ݺáÇÒBΪÖ÷Ä¿±ê£¨ÓÅÏȼ¶µÍÓÚÈí¿Ø¡¢Ö¸¶¨buff״̬Ŀ±ê£¬¸ßÓÚÊôÐÔÌõ¼þÄ¿±ê£©
|
'''
|
if not tagObj:
|
return
|
|
atkID = atkObj.GetID()
|
tagID = tagObj.GetID()
|
if not tagObj.CanAction():
|
GameWorld.DebugLog("µ±Ç°×´Ì¬ÎÞ·¨·´»÷! tagID=%s" % (tagID))
|
return
|
|
if atkObj.GetFaction() == tagObj.GetFaction():
|
#GameWorld.DebugLog("ͬÕóÓª²»´¥·¢·´»÷!") # ÷È»ó¿ÉÄܵ¼Ö´ò×Ô¼ºÈË
|
return
|
|
canAtkbackDictTypeList = IpyGameDataPY.GetFuncEvalCfg("ParryCfg", 2)
|
if atkObj.GetAtkDistType() not in canAtkbackDictTypeList:
|
heroID = atkObj.GetHeroID()
|
GameWorld.DebugLog("¹¥»÷·½Ô¶½üÀàÐÍÎ佫²»¿É·´»÷! atkID=%s,heroID=%s,AtkDistType=%s not in %s" % (atkID, heroID, atkObj.GetAtkDistType(), canAtkbackDictTypeList))
|
return
|
|
canAtkBack = False
|
for hurtObj in useSkill.GetHurtObjListAll():
|
if hurtObj.GetObjID() != tagID:
|
continue
|
if hurtObj.HaveHurtType(ChConfig.HurtType_Parry): # ¸ñµ²Ê±¿É·´»÷
|
canAtkBack = True
|
break
|
|
if not canAtkBack:
|
GameWorld.DebugLog("ûÓиñµ²²»¿É·´»÷! tagID=%s" % tagID)
|
return
|
|
# ´ó»ØºÏµ¥Î佫·´»÷´ÎÊýÏÞÖÆ
|
bigTurnAtkbackCntMax = IpyGameDataPY.GetFuncCfg("ParryCfg", 4)
|
if bigTurnAtkbackCntMax:
|
atkbackCnt = tagObj.GetBigTurnAtkbackCnt()
|
if atkbackCnt >= bigTurnAtkbackCntMax:
|
GameWorld.DebugLog("±¾´ó»ØºÏÀۼƷ´»÷´ÎÊý´ïÉÏÏÞ! atkbackCnt=%s >= %s" % (atkbackCnt, bigTurnAtkbackCntMax))
|
return
|
|
skillManager = tagObj.GetSkillManager()
|
for index in range(0, skillManager.GetSkillCount()):
|
useSkill = skillManager.GetSkillByIndex(index)
|
if not useSkill:
|
continue
|
if useSkill.GetFuncType() == ChConfig.Def_SkillFuncType_TurnNormaSkill: # ʹÓÃÆÕ¹¥·´»÷
|
GameWorld.DebugLog("¿ÉÒÔ·´»÷! tagID=%s" % tagID)
|
return useSkill
|
return
|
|
def DoBeAttackResult(turnFight, curObj, useSkill, isUseSkill=False):
|
'''±»¹¥»÷½á¹û
|
@param curObj: Ê©·¨·½»òbuff¹éÊô·½
|
@param isUseSkill: ÊÇ·ñÊÇÖ±½ÓʹÓü¼ÄܵĹ¥»÷½á¹û£¬·ñÔòÊÓΪ³ÖÐøÐÔµÄ
|
'''
|
|
#curID = curObj.GetID()
|
isTurnNormalSkill = SkillCommon.isTurnNormalSkill(useSkill)
|
isAngerSkill = SkillCommon.isAngerSkill(useSkill)
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
|
# ÓÅÏÈ´¦ÀíafterLogic£¬¿ÉÔÙÔ¤ÏÈ»ã×ÜһЩ»á´¥·¢±»¶¯µÄÐÅÏ¢
|
relatedSkillID = useSkill.GetSkillID()
|
shieldBrokenList = [] # ¼Ç¼¶ÜÆÆ
|
afterLogicList = useSkill.GetAfterLogicList()
|
for logicType, logicData in afterLogicList:
|
if logicType == ChConfig.AfterLogic_DelBuff:
|
buffObjID, buff, tagObjID = logicData
|
buffSkillData = buff.GetSkillData()
|
buffSkillTypeID = buffSkillData.GetSkillTypeID()
|
TurnBuff.DoBuffDelAfterLogicOver(turnFight, buffObjID, buff, useSkill)
|
if SkillCommon.isDamageShieldSkill(buffSkillData):
|
shieldBrokenList.append([buffObjID, tagObjID, buffSkillTypeID])
|
|
elif logicType == ChConfig.AfterLogic_AddBuff:
|
batObj = logicData[0]
|
buff = logicData[1]
|
TurnBuff.SyncBuffRefresh(turnFight, batObj, buff, relatedSkillID, isNewAdd=True)
|
|
elif logicType == ChConfig.AfterLogic_SyncBuff:
|
buffObj = logicData[0]
|
buff = logicData[1]
|
TurnBuff.SyncBuffRefresh(turnFight, buffObj, buff, relatedSkillID)
|
|
# ͳ¼Æ»÷ɱ
|
killObjList = [] # »÷ɱÆäËûÕóӪĿ±êÁбí
|
dieObjList = [] # ËÀÍöµÄµ¥Î»ÁÐ±í£¬°üº¬ÓÑ·½µ¥Î»»ò×Ô¼º
|
tagObjList = useSkill.GetTagObjList() # Ö÷ҪĿ±êÁбí
|
tagObjListEx = useSkill.GetTagObjListEx() # ¶îÍâÄ¿±êÁбí
|
tagObjListAll = tagObjList + tagObjListEx
|
for tagObj in tagObjListAll:
|
tagID = tagObj.GetID()
|
if tagObj.IsAlive() and tagObj.GetHP() <= 0:
|
dieObjList.append(tagObj)
|
if tagObj.GetFaction() != curObj.GetFaction():
|
killObjList.append(tagObj)
|
TurnAttack.SetObjKilled(turnFight, tagObj, curObj, useSkill)
|
useSkill.SetKillObjList(killObjList)
|
# ÅжÏ×Ô¼º£¬ÒòΪ·´µ¯¡¢Æ½Ì¯É˺¦µÄÔÒò£¬ÓпÉÄÜ×Ô¼º¸ÉËÀ×Ô¼º
|
selfAlive = curObj.IsAlive()
|
if selfAlive and curObj.GetHP() <= 0:
|
selfAlive = False
|
dieObjList.append(curObj)
|
TurnAttack.SetObjKilled(turnFight, curObj)
|
|
# ͳ¼ÆÉËѪ£¬¿ÉÄܵ¥¸ö¼¼ÄܶÔͬһĿ±êÔì³É¶à´ÎÉ˺¦
|
totalHurtValue = 0
|
isSuperHit, isStun, isSuckHP = False, False, False
|
missObjIDList, immuneObjIDList = [], [] # ÉÁ±Ü¡¢ÃâÒ߶ÔÏóIDÁбí
|
beHurtObjIDList = [] # ÊÜÉ˵ĶÔÏóIDÁбí
|
for hurtObj in useSkill.GetHurtObjListAll():
|
hurtObjID = hurtObj.GetObjID()
|
tagObj = batObjMgr.getBatObj(hurtObjID)
|
if not tagObj:
|
continue
|
if not hurtObj.HaveHurtType(ChConfig.HurtTYpe_Cure) and not hurtObj.HaveHurtType(ChConfig.HurtType_Immune) \
|
and (isTurnNormalSkill or isAngerSkill) and tagObj.IsAlive():
|
__doSkillHurtAnger(tagObj, hurtObj.GetLostHP(), useSkill)
|
|
if hurtObj.HaveHurtType(ChConfig.HurtType_Normal):
|
totalHurtValue += hurtObj.GetHurtHP()
|
if hurtObj.GetLostHP() > 0: # ÓеôѪµÄ
|
if hurtObjID not in beHurtObjIDList:
|
beHurtObjIDList.append(hurtObjID)
|
|
if hurtObj.HaveHurtType(ChConfig.HurtType_Miss):
|
if hurtObjID not in missObjIDList:
|
missObjIDList.append(hurtObjID)
|
DoHeroSpecialty(turnFight, tagObj, ChConfig.HeroSpecialty_Miss, relatedSkillID)
|
|
if hurtObj.HaveHurtType(ChConfig.HurtType_Immune):
|
if hurtObjID not in immuneObjIDList:
|
immuneObjIDList.append(hurtObjID)
|
|
if hurtObj.HaveHurtType(ChConfig.HurtType_Parry):
|
DoHeroSpecialty(turnFight, tagObj, ChConfig.HeroSpecialty_Parry, relatedSkillID)
|
|
if hurtObj.HaveHurtType(ChConfig.HurtType_SuperHit):
|
isSuperHit = True
|
|
if hurtObj.HaveHurtType(ChConfig.HurtType_Stun):
|
isStun = True
|
|
if hurtObj.GetSuckHP() > 0:
|
isSuckHP = True
|
|
# ¼Ç¼×îºóÒ»´Î×ÜÉ˺¦£¬ÓÐÉ˺¦Ä¿±ê²Å¼Ç¼
|
if totalHurtValue:
|
curObj.SetLastHurtValue(totalHurtValue)
|
|
# Ⱥ¹¥Ö»´¥·¢Ò»´ÎÌس¤
|
if isSuperHit:
|
DoHeroSpecialty(turnFight, curObj, ChConfig.HeroSpecialty_SuperHit, relatedSkillID)
|
if isStun:
|
DoHeroSpecialty(turnFight, curObj, ChConfig.HeroSpecialty_Stun, relatedSkillID)
|
if isSuckHP:
|
DoHeroSpecialty(turnFight, curObj, ChConfig.HeroSpecialty_SuckHP, relatedSkillID)
|
|
# ½áË㸱±¾Ïà¹ØµÄ¹¥»÷½á¹û£¬½öÖ÷¶¯·¢ÆðÍæ¼ÒÕóÈÝÎ佫´¥·¢
|
curPlayer = turnFight.curPlayer
|
if curPlayer and curObj and curObj.GetOwnerID() == curPlayer.GetPlayerID():
|
FBLogic.OnPlayerLineupAttackResult(curPlayer, curObj, killObjList, useSkill, turnFight.mapID, turnFight.funcLineID)
|
|
effIgnoreObjIDList = missObjIDList + immuneObjIDList
|
useSkill.SetEffIgnoreObjIDList(effIgnoreObjIDList)
|
# ÓÅÏÈ´¥·¢±¾¼¼ÄܶîÍâЧ¹û£¬×¢£º½ö¸Ã¼¼ÄÜÊͷźó¸Ã¼¼ÄܵĶîÍâЧ¹ûÊÓΪÖ÷¼¼ÄܵÄЧ¹û£¬ÓÅÏȼ¶×î¸ß
|
if selfAlive:
|
__DoCurSkillEff(turnFight, curObj, useSkill, effIgnoreObjIDList, isUseSkill)
|
|
# ========== ÒÔÏ´¥·¢±»¶¯ ==========
|
|
# ÆƶÜʱ
|
for buffObjID, tagObjID, buffSkillTypeID in shieldBrokenList:
|
buffObj = batObjMgr.getBatObj(buffObjID)
|
tagObj = batObjMgr.getBatObj(tagObjID)
|
TurnPassive.OnTriggerPassiveEffect(turnFight, buffObj, ChConfig.TriggerWay_ShieldBroken, tagObj, connSkillTypeID=buffSkillTypeID)
|
|
# Óл÷ɱʱ
|
for index, tagObj in enumerate(killObjList):
|
if index == 0:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_KillOneObj, tagObj, connSkill=useSkill)
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_KillTagObj, tagObj, connSkill=useSkill)
|
|
if dieObjList:
|
for faction in [ChConfig.Def_FactionA, ChConfig.Def_FactionB]:
|
batFaction = turnFight.getBatFaction(faction)
|
for lineupNum in batFaction.lineupDict.keys():
|
batLineup = batFaction.getBatlineup(lineupNum)
|
for lineupObjID in batLineup.posObjIDDict.values():
|
lineupObj = batObjMgr.getBatObj(lineupObjID)
|
if not lineupObj.IsAlive():
|
continue
|
for dieObj in dieObjList:
|
# µÐ·½µ¥Î»ËÀÍöʱ
|
if lineupObj.GetFaction() != dieObj.GetFaction():
|
TurnPassive.OnTriggerPassiveEffect(turnFight, lineupObj, ChConfig.TriggerWay_EnemyDie, dieObj, connSkill=useSkill)
|
# ¼º·½µ¥Î»ËÀÍöʱ
|
else:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, lineupObj, ChConfig.TriggerWay_FriendDie, dieObj, connSkill=useSkill)
|
|
triggerOne = False
|
batType = useSkill.GetBatType()
|
isAttackDirect = (isUseSkill and SkillCommon.isAttackDirectSkill(useSkill)) # ÊÇ·ñÖ±½Ó¹¥»÷
|
for tagObj in tagObjListAll:
|
tagID = tagObj.GetID()
|
if tagID in effIgnoreObjIDList:
|
continue
|
|
isExObj = tagObj in tagObjListEx # ÊÇ·ñ¶îÍâÄ¿±ê
|
|
# µôѪʱ
|
if tagID in beHurtObjIDList:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeHurt, curObj, connSkill=useSkill)
|
|
# Ö±½Ó¹¥»÷
|
if isAttackDirect and not isExObj:
|
if not triggerOne:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_AttackOverDirectOne, tagObj, connSkill=useSkill)
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_AttackOverDirect, tagObj, connSkill=useSkill)
|
TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeAttackedDirect, curObj, connSkill=useSkill)
|
# ³ÖÐøÉ˺¦
|
elif not isAttackDirect:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeAnyEffect, curObj, connSkill=useSkill)
|
# Êܵ½³ÖÐøÉ˺¦
|
if tagID in beHurtObjIDList and not isExObj:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeDOTHurt, curObj, connSkill=useSkill)
|
|
# ʹÓü¼Äܺó
|
if isUseSkill and not isExObj:
|
if not triggerOne:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_UseSkillOverOne, tagObj, connSkill=useSkill)
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curObj, ChConfig.TriggerWay_UseSkillOver, tagObj, connSkill=useSkill)
|
|
# Á¬»÷
|
if batType == ChConfig.TurnBattleType_Combo and not isExObj:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BeCombo, curObj, connSkill=useSkill)
|
# ×·»÷
|
elif batType == ChConfig.TurnBattleType_Pursue and not isExObj:
|
TurnPassive.OnTriggerPassiveEffect(turnFight, tagObj, ChConfig.TriggerWay_BePursue, curObj, connSkill=useSkill)
|
|
triggerOne = True # ÉèÖÃÒѾ´¥·¢¹ýÒ»´Î
|
|
# ÑéÖ¤ÊÇ·ñ½áË㣬×îºó´¦Àí
|
if dieObjList:
|
turnFight.checkOverByKilled()
|
|
return
|
|
def __doCostZhanchui(turnFight, curBatObj, useSkill):
|
|
turnFight.mapID
|
if turnFight.mapID != ChConfig.Def_FBMapID_Main:
|
## ½öÖ÷ÏßÕ½¶·ÐèÒª
|
return
|
|
curPlayer = turnFight.curPlayer
|
if not curPlayer:
|
return
|
# ½öÖ÷¶¯·¢ÆðÍæ¼ÒÕóÈÝÎ佫Êͷż¼ÄÜÐèÒªÏûºÄ
|
if curBatObj.GetOwnerID() != curPlayer.GetPlayerID():
|
return
|
|
costZhanchui = 0
|
batType = useSkill.GetBatType()
|
if batType != ChConfig.TurnBattleType_Normal:
|
# Ôݶ¨½ö³£¹æÖ÷¶¯µã»÷ÐÐΪµÄÐèÒª¿Û³ýÕ½´¸£¨ÓëÇ°¶ËÊÖ¶¯Õ½¶·µã»÷µÄ´¥·¢µãͬ²½£©£¬±»¶¯´¥·¢µÄÔݶ¨²»¿Û
|
return
|
|
if SkillCommon.isAngerSkill(useSkill):
|
costZhanchui = IpyGameDataPY.GetFuncCfg("ZhanchuiCost", 2)
|
elif SkillCommon.isTurnNormalSkill(useSkill):
|
costZhanchui = IpyGameDataPY.GetFuncCfg("ZhanchuiCost", 1)
|
|
if costZhanchui <= 0:
|
return
|
|
fightPoint = max(curPlayer.GetFightPoint(), 1) # Ö÷ÏßÕ½¶·ÏûºÄ±¶Öµ£¬Ä¬ÈÏ1
|
costZhanchuiTotal = costZhanchui * fightPoint
|
if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, costZhanchuiTotal, isNotify=False):
|
# ²»×ãʱ£¬ÓжàÉÙ¿Û¶àÉÙ
|
nowMoney = PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao)
|
PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, min(nowMoney, costZhanchuiTotal), isNotify=False)
|
|
return
|
|
def __doSkillUserAnger(turnFight, curBatObj, useSkill):
|
## ¼¼ÄÜÊÍ·ÅÕßÅÆøÏà¹Ø
|
if SkillCommon.isAngerSkill(useSkill):
|
curBatObj.SetXP(0)
|
elif SkillCommon.isTurnNormalSkill(useSkill) and useSkill.GetBatType() == ChConfig.TurnBattleType_Normal:
|
addXP = IpyGameDataPY.GetFuncCfg("AngerXP", 3)
|
AddTurnFightXP(curBatObj, addXP, "skillID:%s" % useSkill.GetSkillID())
|
return
|
|
def __doSkillHurtAnger(batObj, lostHP, useSkill):
|
## ½áËãÊÜÉËÕßÅÆø
|
if lostHP <= 0:
|
return
|
addXP = IpyGameDataPY.GetFuncCfg("AngerXP", 4)
|
if addXP <= 0:
|
return
|
AddTurnFightXP(batObj, addXP, "skillID:%s" % useSkill.GetSkillID())
|
return
|
|
def AddTurnFightXP(gameObj, addXP, reason=""):
|
## »ØºÏÕ½¶·Ôö¼ÓXP
|
if addXP <= 0 or not addXP:
|
#GameWorld.DebugLog(" ûÓÐÔö¼ÓXP! curID=%s" % (gameObj.GetID()))
|
return
|
posNum = gameObj.GetPosNum()
|
if posNum <= 0:
|
#·ÇÖ÷Õ½µ¥Î»²»¼Ó
|
return
|
addXP = GetEnhanceXP(gameObj, addXP)
|
curXP = gameObj.GetXP()
|
updXP = curXP + addXP
|
gameObj.SetXP(updXP)
|
GameWorld.DebugLog(" ¸üÐÂXP: curID=%s,curXP=%s,addXP=%s,updXP=%s,reason=%s" % (gameObj.GetID(), curXP, addXP, updXP, reason))
|
return
|
|
def DoHeroSpecialty(turnFight, gameObj, specialty, relatedSkillID=0):
|
## Ö´ÐÐÎ佫Ìس¤
|
if gameObj.GetSpecialty() != specialty:
|
return
|
specialtyAddXPDict = IpyGameDataPY.GetFuncEvalCfg("AngerXP", 5, {})
|
if str(specialty) not in specialtyAddXPDict:
|
return
|
if not gameObj.IsAlive():
|
return
|
addXP = specialtyAddXPDict[str(specialty)]
|
addXP = GetEnhanceXP(gameObj, addXP)
|
curXP = gameObj.GetXP()
|
updXP = curXP + addXP
|
gameObj.SetXP(updXP, False)
|
GameWorld.DebugLog(" Ìس¤¼ÓXP: curID=%s,curXP=%s,addXP=%s,updXP=%s,ÌØÐÔ=%s" % (gameObj.GetID(), curXP, addXP, updXP, specialty))
|
Sync_PropertyRefreshView(turnFight, gameObj, ChConfig.AttrID_XP, updXP, addXP, diffType=1, relatedSkillID=relatedSkillID)
|
return
|
|
def GetEnhanceXP(gameObj, addXP):
|
## »ñÈ¡ÌáÉýºóµÄxpÖµ
|
addPer = gameObj.GetBatAttrValue(ChConfig.AttrID_XPRecoverPer)
|
# ÆäËûÇ¿»¯¡¢Èõ»¯
|
if addPer == 0:
|
return addXP
|
objID = gameObj.GetID()
|
updAddXP = int(addXP * max(10000 + addPer, 0) / 10000.0)
|
GameWorld.DebugLog("ÅÆø»Ö¸´ÌáÉý: objID=%s,addXP=%s,addPer=%s,updAddXP=%s" % (objID, addXP, addPer, updAddXP))
|
return updAddXP
|
|
def __DoCurSkillEff(turnFight, curObj, useSkill, effIgnoreObjIDList, isUseSkill):
|
## Ö´Ðб¾¼¼ÄÜ/buffÊͷźó¶îÍâЧ¹û
|
for index in xrange(useSkill.GetEffectCount()):
|
curEffect = useSkill.GetEffect(index)
|
triggerWay = curEffect.GetTriggerWay()
|
if isUseSkill:
|
if triggerWay != ChConfig.TriggerWay_CurSkillEff:
|
continue
|
else:
|
if triggerWay != ChConfig.TriggerWay_CurSkillEffLst:
|
continue
|
|
effID = curEffect.GetEffectID()
|
GameWorld.DebugLog("¡ñÖ´ÐжîÍâ¼¼ÄÜЧ¹û: skillID=%s,effID=%s, triggerWay=%s,effIgnoreObjIDList=%s" % (useSkill.GetSkillID(), effID, triggerWay, effIgnoreObjIDList))
|
if effID == 5010:
|
# ¶îÍâ¼¼ÄÜЧ¹û
|
__doUseEnhanceSkill(turnFight, curObj, useSkill, curEffect, effIgnoreObjIDList)
|
continue
|
|
for tagObj in useSkill.GetTagObjList():
|
tagID = tagObj.GetID()
|
if tagID in effIgnoreObjIDList:
|
# ÉÁ±ÜÁ˲»´¥·¢
|
continue
|
|
TurnPassive.DoSkillEffectLogic(turnFight, curObj, tagObj, useSkill, curEffect, useSkill)
|
|
return
|
|
def __doUseEnhanceSkill(turnFight, curBatObj, useSkill, curEffect, effIgnoreObjIDList):
|
## Ö´ÐÐÖ÷¼¼ÄܵĶîÍâ¼¼ÄÜЧ¹û
|
#if useSkill.GetBatType() == ChConfig.TurnBattleType_Enhance:
|
# #GameWorld.DebugLog("×ÔÉíΪ¶îÍâ´¥·¢µÄ¼¼Äܲ»ÔÙ´¥·¢¶îÍâ¼¼ÄÜ! skillID=%s" % useSkill.GetSkillID())
|
# return
|
enhanceSkillID = curEffect.GetEffectValue(0)
|
checkInStateList = curEffect.GetEffectValue(1)
|
checkHeroJob = curEffect.GetEffectValue(2)
|
GameWorld.DebugLog("¶îÍâ´¥·¢µÄ¼¼ÄÜ: enhanceSkillID=%s,checkInStateList=%s£¬checkHeroJob=%s" % (enhanceSkillID, checkInStateList, checkHeroJob))
|
tagObjList = useSkill.GetTagObjList()
|
|
enhanceSkillData = IpyGameDataPY.GetIpyGameData("Skill", enhanceSkillID)
|
if not enhanceSkillData:
|
return
|
|
killObjList = useSkill.GetKillObjList()
|
if killObjList:
|
invalidSkillID = TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_SkillInvalid, useSkill,
|
triggerWay=ChConfig.TriggerWay_KillOneObj)
|
if invalidSkillID and invalidSkillID == enhanceSkillID:
|
GameWorld.DebugLog("Óл÷ɱĿ±êʱ¸Ã¼¼ÄÜÎÞЧ! enhanceSkillID=%s" % enhanceSkillID)
|
return
|
|
# ¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê
|
if enhanceSkillData.GetTagAim() == ChConfig.SkillTagAim_MainSkill:
|
GameWorld.DebugLog("¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê! enhanceSkillID=%s" % enhanceSkillID)
|
# ¶îÍâ´¥·¢µÄ¼¼ÄÜÖ±½ÓÔÚÍâ²ã¼ì²é¸ÅÂÊ£¬Èç¹û¶¼Ã»Óд¥·¢Ôò²»ÐèÒªÔÙ´¦Àí
|
enhanceRate = enhanceSkillData.GetHappenRate()
|
enhanceRate += TurnPassive.GetTriggerEffectValue(turnFight, curBatObj, None, ChConfig.PassiveEff_AddSkillRate, connSkillTypeID=enhanceSkillData.GetSkillTypeID())
|
enchanceTagObjList = []
|
for tagObj in tagObjList:
|
tagID = tagObj.GetID()
|
if not tagObj.IsAlive():
|
GameWorld.DebugLog(" Òѱ»»÷ɱ²»´¥·¢: tagID=%s" % (tagID))
|
continue
|
if tagID in effIgnoreObjIDList:
|
GameWorld.DebugLog(" ÉÁ±Ü»òÃâÒߵIJ»´¥·¢: tagID=%s" % (tagID))
|
continue
|
if checkInStateList:
|
if not tagObj.CheckInState(checkInStateList):
|
GameWorld.DebugLog(" ²»ÔÚ״̬ϲ»´¥·¢: tagID=%s not in state:%s" % (tagID, checkInStateList))
|
continue
|
if checkHeroJob and checkHeroJob != tagObj.GetJob():
|
GameWorld.DebugLog(" ·ÇÄ¿±êÖ°Òµ²»´¥·¢: tagID=%s,job=%s != %s" % (tagID, tagObj.GetJob(), checkHeroJob))
|
continue
|
if enhanceRate and enhanceRate != ChConfig.Def_MaxRateValue and not GameWorld.CanHappen(enhanceRate, ChConfig.Def_MaxRateValue):
|
GameWorld.DebugLog(" ¸ÅÂʲ»´¥·¢: tagID=%s,enhanceRate=%s" % (tagID, enhanceRate))
|
continue
|
|
enchanceTagObjList.append(tagObj)
|
|
if enchanceTagObjList:
|
OnUseSkill(turnFight, curBatObj, enhanceSkillData, enchanceTagObjList, batType=ChConfig.TurnBattleType_Enhance, bySkill=useSkill)
|
|
return
|
|
# Ö»Ö´ÐÐÒ»´Î£¬·ÀֹȺ¹¥Ê±¶îÍâ´¥·¢¶à´Î
|
GameWorld.DebugLog("ÖØÐÂËø¶¨Ä¿±ê! enhanceSkillID=%s" % enhanceSkillID)
|
if checkInStateList or checkHeroJob:
|
inState, haveJob = False, False
|
for tagObj in tagObjList:
|
tagID = tagObj.GetID()
|
if tagID in effIgnoreObjIDList:
|
continue
|
if not inState and tagObj.CheckInState(checkInStateList):
|
inState = True
|
if not haveJob and checkHeroJob and checkHeroJob == tagObj.GetJob():
|
haveJob = True
|
if checkInStateList and not inState:
|
GameWorld.DebugLog(" ûÓÐÃüÖÐÄ¿±êÔÚ״̬ϲ»´¥·¢: tagObj not in state:%s" % str(checkInStateList))
|
return
|
if checkHeroJob and not haveJob:
|
GameWorld.DebugLog(" ûÓÐÃüÖÐÄ¿±êΪĿ±êÖ°Òµ²»´¥·¢: checkHeroJob=%s" % checkHeroJob)
|
return
|
OnUseSkill(turnFight, curBatObj, enhanceSkillData, batType=ChConfig.TurnBattleType_Enhance, bySkill=useSkill)
|
return
|
|
def OnUsePassiveSkill(turnFight, batObj, tagObj, passiveSkill, connSkill=None, effSkillID=0, effectID=0, connBuff=None):
|
'''±»¶¯´¥·¢Ê¹Óü¼ÄÜ
|
@param passiveSkill: Êͷŵı»¶¯¼¼ÄÜ
|
@param connSkill: ÓÉʲô¼¼ÄÜÒýÆðµÄ
|
@param effSkillID: ±»¶¯Ð§¹ûËùÊôµÄ¼¼ÄÜID
|
@param effectID: ±»¶¯Ð§¹ûID
|
×¢£º¿ÉÄÜÓÉAÒýÆð´¥·¢B¼¼ÄܵÄЧ¹ûÊͷż¼ÄÜC
|
'''
|
if not passiveSkill:
|
return
|
bySkillID = 0
|
if connSkill:
|
bySkillID = connSkill.GetSkillID()
|
elif connBuff:
|
bySkillID = connBuff.GetSkillID()
|
passiveSkillID = passiveSkill.GetSkillID()
|
if passiveSkillID == bySkillID:
|
#GameWorld.DebugLog("###±»¶¯´¥·¢¼¼Äܲ»´¥·¢×ÔÉí£¬·ÀÖ¹ËÀÑ»·! effSkillID=%s,effectID=%s,passiveSkillID=%s" % (effSkillID, effectID, passiveSkillID))
|
return
|
|
if hasattr(passiveSkill, "GetRemainTime") and passiveSkill.GetRemainTime() > 0:
|
#GameWorld.DebugLog("±»¶¯´¥·¢¼¼ÄÜCDÖÐ! skillID=%s,RemainTime=%s" % (passiveSkillID, passiveSkill.GetRemainTime()))
|
return
|
|
isOK = False
|
# ¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê
|
if passiveSkill.GetTagAim() == ChConfig.SkillTagAim_MainSkill:
|
happenRate = passiveSkill.GetHappenRate()
|
happenRate += TurnPassive.GetTriggerEffectValue(turnFight, batObj, None, ChConfig.PassiveEff_AddSkillRate, passiveSkill)
|
GameWorld.DebugLog("±»¶¯´¥·¢¼¼ÄÜ£¬¼Ì³ÐÖ÷¼¼ÄÜÄ¿±ê! effSkillID=%s,effectID=%s,passiveSkillID=%s,happenRate=%s,bySkillID=%s" % (effSkillID, effectID, passiveSkillID, happenRate, bySkillID))
|
if not tagObj:
|
return
|
tagID = tagObj.GetID()
|
if not tagObj.IsAlive():
|
GameWorld.DebugLog(" Òѱ»»÷ɱ²»´¥·¢: tagID=%s" % (tagID))
|
return
|
if happenRate and not GameWorld.CanHappen(happenRate, ChConfig.Def_MaxRateValue):
|
GameWorld.DebugLog(" ¸ÅÂʲ»´¥·¢: tagID=%s,happenRate=%s" % (tagID, happenRate))
|
return
|
passiveTagObjList = [tagObj]
|
isOK = OnUseSkill(turnFight, batObj, passiveSkill, passiveTagObjList, batType=ChConfig.TurnBattleType_Passive, bySkill=connSkill, byBuff=connBuff)
|
else:
|
GameWorld.DebugLog("±»¶¯´¥·¢¼¼ÄÜ£¬ÖØÐÂËø¶¨Ä¿±ê! effSkillID=%s,effectID=%s,passiveSkillID=%s,bySkillID=%s" % (effSkillID, effectID, passiveSkillID, bySkillID))
|
isOK = OnUseSkill(turnFight, batObj, passiveSkill, batType=ChConfig.TurnBattleType_Passive, bySkill=connSkill, byBuff=connBuff)
|
|
return isOK
|
|
def CalcFormatHurt(turnFight, atkObj, defObj, curSkill, atkSkillValue, atkSkillPer, **kwargs):
|
'''°´¹«Ê½¼ÆËãÉ˺¦£¬Ä¬ÈÏ°´¹¥»÷¼ÆËã
|
'''
|
|
#mapID = turnFight.mapID
|
skillID = curSkill.GetSkillID()
|
pmType = GetPMType(atkObj, curSkill)
|
ignoreDef = IsIgnoreDef(curSkill)
|
batType = curSkill.GetBatType()
|
|
changeHurtType = TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_ChangeHurtType, curSkill)
|
if changeHurtType == 1:
|
ignoreDef = True
|
GameWorld.DebugLog("Ç¿ÖƱä¸ü±¾´ÎÉ˺¦ÎªÎÞÊÓ·ÀÓù! skillID=%s" % skillID)
|
|
atkID = atkObj.GetID()
|
defID = defObj.GetID()
|
|
calcType = curSkill.GetCalcType() # É˺¦¼ÆË㷽ʽ 0-°´¹¥»÷
|
isTurnNormalSkill = SkillCommon.isTurnNormalSkill(curSkill)
|
isAngerSkill = SkillCommon.isAngerSkill(curSkill)
|
isDot = ("damageoftime" in kwargs)
|
|
mustHit = False # ÊÇ·ñ±ØÃüÖÐ
|
if not isTurnNormalSkill: # ½öÆÕ¹¥ÅжÏÊÇ·ñÉÁ±Ü
|
mustHit = True
|
|
angerOverflow = atkObj.GetAngerOverflow() # ÅÆøÒç³öÖµ
|
if isAngerSkill:
|
curXP = atkObj.GetXP()
|
GameWorld.DebugLog("ż¼¹¥»÷! curXP=%s,angerOverflow=%s" % (curXP, angerOverflow))
|
|
#ÃüÖй«Ê½ ¹¥»÷·½ÀàÐͲ»Í¬£¬¹«Ê½²»Í¬
|
if not mustHit and not curSkill.GetEffectByID(ChConfig.SkillEff_MustHit) and not defObj.IsInControlledHard():
|
aMissRateDef = atkObj.GetBatAttrValue(ChConfig.AttrID_MissRateDef) #atkObj.GetHit() # ¿¹ÉÁ±ÜÂÊ - ÃüÖÐ
|
dMissRate = defObj.GetBatAttrValue(ChConfig.AttrID_MissRate) # ÉÁ±ÜÂÊ
|
missNum = curSkill.GetTagMissNum(defID)
|
missRate = eval(IpyGameDataPY.GetFuncCompileCfg("MissCfg", 1))
|
if GameWorld.CanHappen(missRate):
|
GameWorld.DebugLog("ÉÁ±ÜÁË! missRate=%s,dMissRate=%s,aMissRateDef=%s,missNum=%s" % (missRate, dMissRate, aMissRateDef, missNum))
|
curSkill.SetTagMissNum(defID, missRate + 1)
|
return 0, pow(2, ChConfig.HurtType_Miss)
|
|
hurtTypes = pow(2, ChConfig.HurtType_Normal)
|
|
isSuperHit, isParry, isStun = False, False, False
|
aSuperDamPer, dSuperDamPerDef = 0, 0
|
# ±©»÷£¨dot³ýÍ⣩
|
if not isDot:
|
isSuperHit = CanSuperHit(turnFight, atkObj, defObj, curSkill) # ÊÇ·ñ±©»÷
|
|
# ÉÁ±Ü¡¢»÷ÔΡ¢¸ñµ²
|
if isTurnNormalSkill:
|
isParry = CanParry(turnFight, atkObj, defObj, curSkill) # ÊÇ·ñ¸ñµ²
|
isStun = CanStun(turnFight, atkObj, defObj, curSkill) # ÊÇ·ñ»÷ÔÎ
|
|
if isSuperHit:
|
hurtTypes |= pow(2, ChConfig.HurtType_SuperHit)
|
aSuperDamPer = 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:
|
hurtTypes |= pow(2, ChConfig.HurtType_Stun)
|
|
#²ÎÓëÔËËãµÄÊýÖµ
|
#rand = random.random() #ÖÖ×ÓÊý 0~1
|
|
aAtk = atkObj.GetAtk() # ¹¥»÷·½×î´ó¹¥»÷
|
|
dHP, dMaxHP = defObj.GetHP(), defObj.GetMaxHP()
|
dDef = 0 if ignoreDef else defObj.GetDef() # ·ÀÊØ·½·ÀÓùÁ¦
|
|
atkSkillPer += GetAddSkillPer(turnFight, atkObj, defObj, curSkill)
|
|
aFinalDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_FinalDamPer) # ×îÖÕ¼Ó³É
|
dFinalDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_FinalDamPerDef) # ×îÖÕ¼õÉË
|
|
aFinalDamPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddFinalDamPer, curSkill)
|
|
aNormalSkillPer, dNormalSkillPerDef = 0, 0
|
if isTurnNormalSkill:
|
aNormalSkillPer = atkObj.GetBatAttrValue(ChConfig.AttrID_NormalSkillPer) # ÆÕ¼¼ÔöÉË
|
dNormalSkillPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_NormalSkillPerDef) # ÆÕ¼¼¼õÉË
|
|
aAngerSkillPer, dAngerSkillPerDef = 0, 0
|
if isAngerSkill:
|
aAngerSkillPer = atkObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPer) # ż¼ÔöÉË
|
aAngerSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddAngerSkillPerByXP, curSkill)
|
|
dAngerSkillPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_AngerSkillPerDef) # ż¼¼õÉË
|
|
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)
|
|
# Îï·¨Ôö¼õÉË
|
if pmType == IPY_GameWorld.ghtMag: # ·¨ÉË
|
aPMDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_MagDamPer)
|
dPMDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_MagDamPerDef)
|
else: # ÎïÉË
|
aPMDamPer = atkObj.GetBatAttrValue(ChConfig.AttrID_PhyDamPer)
|
dPMDamPerDef = defObj.GetBatAttrValue(ChConfig.AttrID_PhyDamPerDef)
|
|
# ÕóÓªÔö¼õÉË
|
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
|
aSuperDamPer /= 10000.0
|
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, 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,aNormalSkillPer=%s,dNormalSkillPerDef=%s" % (hurtValue, aNormalSkillPer, dNormalSkillPerDef))
|
elif isAngerSkill:
|
hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 2))
|
GameWorld.DebugLog(" ÅÆø¼¼ÄÜÉ˺¦=%s,aAngerSkillPer=%s,dAngerSkillPerDef=%s" % (hurtValue, aAngerSkillPer, dAngerSkillPerDef))
|
elif isDot:
|
hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("DOTFormula", 1))
|
GameWorld.DebugLog(" ³ÖÐø¼¼ÄÜÉ˺¦=%s" % (hurtValue))
|
elif calcType == ChConfig.Def_Calc_ByBuffValue:
|
hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("CalcTypeFormula", 2))
|
GameWorld.DebugLog(" °´×îºóÒ»´ÎbuffÖµ¼ÆËãÉ˺¦=%s,calcType=%s,LastHurt=%s" % (hurtValue, calcType, aAtk))
|
elif calcType != ChConfig.Def_Calc_Attack:
|
hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("CalcTypeFormula", 1))
|
GameWorld.DebugLog(" ·Ç°´¹¥»÷Á¦É˺¦=%s,calcType=%s,aAtk=%s" % (hurtValue, calcType, aAtk))
|
else:
|
hurtValue = eval(IpyGameDataPY.GetFuncCompileCfg("HurtFormula", 3))
|
GameWorld.DebugLog(" ÆäËûÉ˺¦=%s" % (hurtValue))
|
|
if isParry:
|
parryReduceRatio = IpyGameDataPY.GetFuncCfg("ParryCfg", 3)
|
hurtValue = hurtValue * (1 - parryReduceRatio)
|
GameWorld.DebugLog(" ¸ñµ²ºóÉ˺¦=%s,parryReduceRatio=%s" % (hurtValue, parryReduceRatio))
|
|
multiValue = TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_ChangeHurtMulti, curSkill)
|
if multiValue and multiValue != 1:
|
hurtValue = int(hurtValue * multiValue)
|
GameWorld.DebugLog(" É˺¦±¶Öµ: hurtValue=%s,multiValue=%s" % (hurtValue, multiValue))
|
|
hurtAtkPerMax = curSkill.GetHurtAtkPerMax() # ×î´óÍò·Ö±È£¬ÏÞÖÆ×îÖÕÉ˺¦²»³¬¹ý¹¥»÷Á¦Íò·ÖÂÊ
|
if hurtAtkPerMax:
|
aAtk = atkObj.GetAtk()
|
hurtValueMax = aAtk * hurtAtkPerMax / 10000.0
|
hurtValue = min(hurtValue, hurtValueMax)
|
GameWorld.DebugLog(" É˺¦×î¸ßÏÞÖÆ: hurtValue=%s,hurtAtkPerMax=%s,aAtk=%s" % (hurtValue, hurtAtkPerMax, aAtk))
|
|
# ¾ù̯
|
hurtShareEff = curSkill.GetEffectByID(ChConfig.SkillEff_HurtShare)
|
if hurtShareEff:
|
tagCnt = max(1, len(curSkill.GetTagObjList()))
|
hurtValue = hurtValue / tagCnt
|
GameWorld.DebugLog(" Ä¿±ê¾ù̯É˺¦: hurtValue=%s,tagCnt=%s" % (hurtValue, tagCnt))
|
|
hurtValue = max(1, int(hurtValue)) # ¸ºÖµ¡¢±£µ×·À·¶£¬·Å×îºó
|
return hurtValue, hurtTypes
|
|
def GetAddSkillPer(turnFight, atkObj, defObj, curSkill):
|
## »ñÈ¡¶îÍâÔö¼ÓµÄ¼¼ÄÜÍò·Ö±È
|
atkSkillPer = 0
|
atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPer, curSkill)
|
atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByHP, curSkill)
|
atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByJob, curSkill)
|
atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByBuffLayer, curSkill)
|
atkSkillPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddSkillPerByDeadTeammate, curSkill)
|
return atkSkillPer
|
|
def CanSuperHit(turnFight, atkObj, defObj, curSkill):
|
if TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_MustSuperHit, curSkill):
|
GameWorld.DebugLog("Ä¿±êѪÁ¿µÍÓÚ°Ù·Öxʱ±Ø¶¨±©»÷: defID=%s,hp:%s/%s" % (defObj.GetID(), defObj.GetHP(), defObj.GetMaxHP()))
|
return True
|
|
aSuperHitRate = atkObj.GetBatAttrValue(ChConfig.AttrID_SuperHitRate)
|
aSuperHitRate += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_SuperHitRate, curSkill)
|
dSuperHitRateDef = defObj.GetBatAttrValue(ChConfig.AttrID_SuperHitRateDef)
|
happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("SuperHitCfg", 1))
|
if GameWorld.CanHappen(happenRate):
|
GameWorld.DebugLog("±©»÷ÁË: happenRate=%s,aSuperHitRate=%s,dSuperHitRateDef=%s" % (happenRate, aSuperHitRate, dSuperHitRateDef))
|
return True
|
return False
|
|
def CanStun(turnFight, atkObj, defObj, curSkill):
|
aStunRate = atkObj.GetBatAttrValue(ChConfig.AttrID_StunRate)
|
aStunRate += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.AttrID_StunRate, curSkill)
|
dStunRateDef = defObj.GetBatAttrValue(ChConfig.AttrID_StunRateDef)
|
happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("StunCfg", 1))
|
if not GameWorld.CanHappen(happenRate):
|
return False
|
stunSkillID = IpyGameDataPY.GetFuncCfg("StunCfg", 2)
|
if TurnBuff.DoAddBuffBySkillID(turnFight, defObj, stunSkillID, atkObj, curSkill, afterLogic=True):
|
GameWorld.DebugLog("»÷ÔÎÁË: happenRate=%s,aStunRate=%s,dStunRateDef=%s" % (happenRate, aStunRate, dStunRateDef))
|
return True
|
return False
|
|
def CanParry(turnFight, atkObj, defObj, curSkill):
|
if defObj.IsInControlledHard():
|
#±»Ó²¿ØÎÞ·¨¸ñµ²
|
return False
|
|
defID = defObj.GetID()
|
# ¸ñµ²Ó¡¼Ç
|
buffMgr = defObj.GetBuffManager()
|
parryYJBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_ParryYJ)
|
if parryYJBuff and parryYJBuff.GetLayer():
|
GameWorld.DebugLog("¸ñµ²Ó¡¼Ç¸ñµ²ÁË: buffID=%s,buffLayer=%s" % (parryYJBuff.GetBuffID(), parryYJBuff.GetLayer()))
|
TurnBuff.DoBuffLayerChange(turnFight, defObj, parryYJBuff, parryYJBuff.GetLayer() - 1, curSkill)
|
return True
|
|
aParryRateDef = atkObj.GetBatAttrValue(ChConfig.AttrID_ParryRateDef)
|
dParryRate = defObj.GetBatAttrValue(ChConfig.AttrID_ParryRate)
|
parryNum = curSkill.GetTagParryNum(defID)
|
happenRate = eval(IpyGameDataPY.GetFuncCompileCfg("ParryCfg", 1))
|
if GameWorld.CanHappen(happenRate):
|
GameWorld.DebugLog("¸ñµ²ÁË: happenRate=%s,aParryRateDef=%s,dParryRate=%s,parryNum=%s" % (happenRate, aParryRateDef, dParryRate, parryNum))
|
curSkill.SetTagParryNum(defID, parryNum + 1)
|
return True
|
return False
|
|
def CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes=0):
|
'''¼ÆËãbuffÓ°ÏìµÃµ½×îÖÕÉ˺¦: ÈçÎ޵С¢Ôö¼õÉ˶ܵÈ
|
@param hurtValue: ¹«Ê½¼ÆËãµÄÉ˺¦Öµ
|
@return: hurtValue, hurtTypes, immuneHurt
|
'''
|
|
immuneHurt = 0 # ÃâÒßÉ˺¦Öµ
|
if hurtValue <= 0:
|
hurtValue = 0
|
return hurtValue, hurtTypes, immuneHurt
|
|
hurtValue = int(hurtValue)
|
if defObj.CheckInState(ChConfig.BatObjState_Wudi):
|
hurtTypes |= pow(2, ChConfig.HurtType_Immune) # Ìí¼ÓÃâÒß
|
immuneHurt = hurtValue
|
hurtValue = 0
|
return hurtValue, hurtTypes, immuneHurt
|
|
# Ôö¼õÉ˶ܣ¬ »á¸Ä±ä hurtValue£¬Çø±ðÓë¼ÆË㹫ʽÖеÄÔö¼õÉË£¬ÕâÀï´¦ÀíµÄÊǶԹ«Ê½¼ÆËã½á¹ûµÄÔÙ´ÎÔö¼õ
|
|
hurtValue = max(0, hurtValue)
|
return hurtValue, hurtTypes, immuneHurt
|
|
def DoSkillHurtHP(turnFight, atkObj, curSkill, calcHurtResults, lostType="", caorenProtectObj=None, isManyTimes=False):
|
'''½áËã¼ÆËãºÃµÄ¼¼ÄÜÉ˺¦
|
@param calcHurtResults: ¼¼Äܹ«Ê½¼ÆËãºóµÄÉ˺¦½á¹û [[tagBatObj, hurtValue, hurtTypes, immuneHurt], ...]
|
@param caorenProtectObj: ²ÜÈÊרÓã¬Òª·À»¤µÄ¶ÔÏó
|
@param isManyTimes: ÊÇ·ñÊǺó¶Ë¶à´Î¼ÆËãÉ˺¦µÄ
|
'''
|
if not calcHurtResults:
|
return
|
|
isAttackDirect = SkillCommon.isAttackDirectSkill(curSkill) # ÊÇ·ñÖ±½Ó¹¥»÷
|
# ¼ÆËãƽ̯
|
finalHurtResults = __calcAverageHurt(turnFight, atkObj, curSkill, calcHurtResults, caorenProtectObj, isAttackDirect)
|
|
# Ö´ÐÐ×îÖÕÉ˺¦½áËã
|
mainHurtObj = None
|
for hurtInfo in finalHurtResults:
|
defObj, hurtValue, hurtTypes, immuneHurt = hurtInfo[:4]
|
isEx = hurtInfo[4] if len(hurtInfo) > 4 else 0 # ÊÇ·ñÊǶîÍâÄ¿±ê
|
|
lostHP = DoLostHP(turnFight, atkObj, defObj, hurtValue, curSkill, lostType, hpCanNegative=True, immuneHurt=immuneHurt)
|
|
#É˺¦½á¹¹Ìå
|
defID = defObj.GetID()
|
if isEx:
|
if isManyTimes and mainHurtObj:
|
hurtObj = mainHurtObj.AddHurtObjEx(defID)
|
else:
|
hurtObj = curSkill.AddHurtObj(defID, isEx=True)
|
curSkill.AddTagObjEx(defObj)
|
else:
|
hurtObj = curSkill.AddHurtObj(defID)
|
if not mainHurtObj:
|
mainHurtObj = hurtObj
|
|
hurtObj.SetHurtTypes(hurtTypes)
|
hurtObj.SetHurtHP(hurtValue)
|
hurtObj.SetLostHP(lostHP)
|
hurtObj.SetCurHP(max(defObj.GetHP(), 0))
|
|
#·´µ¯É˺¦£º½ö·ÇdotµÄ¼¼ÄÜÔì³ÉµÄÉ˺¦¼¼Äܱ¾ÉíÄ¿±ê²Å·´µ¯£¬¸½ÊôÄ¿±ê²»·´µ¯£¨Æ½Ì¯¡¢½¦Éä ¸½ÊôÄ¿±ê£©£¬·´µ¯É˺¦²»Æ½Ì¯
|
if isAttackDirect:
|
CalcBounceHP(turnFight, atkObj, defObj, hurtObj, curSkill)
|
#ÎüѪ£º³ý·´µ¯ÍâµÄÈÎÒâÉ˺¦¶¼Îü
|
CalcSuckBlood(turnFight, atkObj, defObj, hurtObj, curSkill)
|
|
return mainHurtObj
|
|
def __calcAverageHurt(turnFight, curBatObj, useSkill, calcHurtResults, caorenProtectObj=None, isAttackDirect=False):
|
'''¼ÆËãÉ˺¦¾ù̯³ÐÉË
|
@return: finalHurtResults [[tagBatObj, hurtValue, hurtTypes, immuneHurt, <isEx>], ...]
|
'''
|
if not calcHurtResults:
|
return calcHurtResults
|
|
# ÊÇ·ñÔÚÄÚ²ãɸѡ²ÜÈÊ·À»¤Ä¿±ê£¬Íâ²ãÈç¹û´¦Àí¹ýÁ˵«ÊÇΪNoneʱ»áÉèÖÃΪ0
|
checkCaoren = True if (caorenProtectObj == None and isAttackDirect) else False
|
if not isAttackDirect or caorenProtectObj == 0:
|
caorenProtectObj = None
|
|
srcHurtTotal = 0 # Ô´×ÜÉ˺¦
|
hurtValueDict = {} # ×îÖÕÉ˺¦ {objID:hurtValue, ...}
|
immuneHurtDict = {} # ×îÖÕÃâÒßÉ˺¦ {objID:immuneHurt, ...} # ÎÞµÐÄ¿±ê¿É̯É˺¦£¬µ«ÃâÒ߸ÃÉ˺¦
|
tagFaction, tagLineupNum = 0, 0
|
for calcInfo in calcHurtResults:
|
tagObj, hurtValue, _, immuneHurt = calcInfo
|
srcHurtTotal = srcHurtTotal + hurtValue + immuneHurt
|
tagID = tagObj.GetID()
|
hurtValueDict[tagID] = hurtValue
|
if immuneHurt > 0:
|
immuneHurtDict[tagID] = immuneHurt
|
|
if not tagFaction:
|
tagFaction = tagObj.GetFaction()
|
tagLineupNum = tagObj.GetLineupNum()
|
|
# ²»µ²×Ô¼º£¬²»µ²Î޵У¬Ë³ÑÓÖ±µ½Ò»¸ö¿ÉÒÔµ²µÄ×îµÍѪÁ¿Ä¿±ê£¬Èç¹ûûÓоͲ»µ²
|
if checkCaoren and tagID != ChConfig.HeroID_Caoren and not immuneHurt and (not caorenProtectObj or tagObj.GetHP() < caorenProtectObj.GetHP()):
|
caorenProtectObj = tagObj
|
|
isAve, caorenProtectID, otherFactionHurtDict = __calcFactionAverageHurt(turnFight, tagFaction, tagLineupNum, hurtValueDict, immuneHurtDict, caorenProtectObj)
|
if not isAve:
|
#GameWorld.DebugLog("ûÓзÖ̯É˺¦ÔÖµ·µ»Ø")
|
return calcHurtResults
|
GameWorld.DebugLog("±¾ÕóÓª·Ö̯É˺¦½á¹û: %s,ÃâÒßÉ˺¦=%s,¸øµÐÕóÓª=%s,caorenProtectID=%s"
|
% (hurtValueDict, immuneHurtDict, otherFactionHurtDict, caorenProtectID))
|
|
# ¾ù̯¸øÆäËûÕóÓªµÄËã·ÇÖ±½ÓÉ˺¦£¬¼´²ÜÈÊÎÞЧ
|
for key, otherHurtDict in otherFactionHurtDict.items():
|
aveFaction, aveLineupNum = key
|
isAveEx, _, otherFactionHurtDictEx = __calcFactionAverageHurt(turnFight, aveFaction, aveLineupNum, otherHurtDict, immuneHurtDict)
|
|
# ÆäËûÕóÓª·Ö̯ºóµÄ×îÖÕÉ˺¦ÀÛ¼Óµ½Êµ¼Ê×îÖÕÉ˺¦
|
for objID, aveHurt in otherHurtDict.items():
|
hurtValueDict[objID] = hurtValueDict.get(objID, 0) + aveHurt
|
GameWorld.DebugLog("ÆäËûÕóÓª·Ö̯ºóµÄ×îÖÕÉ˺¦: isAveEx=%s,%s,ÃâÒßÉ˺¦=%s,¸øµÐÕóÓª=%s"
|
% (isAveEx, hurtValueDict, immuneHurtDict, otherFactionHurtDictEx))
|
|
# ÆäËûÕóÓªÔٴηÖ̯¸øÆäËûÕóÓªµÄ£¬¶°×Ч¹ûÒýÆð
|
# ¶°×ÔÝʱֻÄÜÔÙ´Î̯¸øÔ´Í·Ò»´ÎÉ˺¦£¬ÔÚ¶àV¶à³¡¾°ÏÂÔݲ»×öÖ§³Ö A¶°× ̯ B¶°× ̯ C¶°×£¬Ä¿Ç°Ö»×ö A->B->A
|
for keyEx, otherHurtDictEx in otherFactionHurtDictEx.items():
|
factionEx, lineupNumEx = keyEx
|
if factionEx != tagFaction or lineupNumEx != tagLineupNum:
|
continue
|
|
for objID, aveHurt in otherHurtDictEx.items():
|
hurtValueDict[objID] = hurtValueDict.get(objID, 0) + aveHurt
|
GameWorld.DebugLog("ÆäËûÕóÓªÔÙ·Ö̯¸øÔ´ÕóÓªµÄÉ˺¦: %s,×îÖÕÉ˺¦=%s,ÃâÒßÉ˺¦=%s"
|
% (otherHurtDictEx, hurtValueDict, immuneHurtDict))
|
|
finalHurtTotal = 0
|
finalHurtResults = []
|
# Ö÷ҪĿ±êÉ˺¦¸üÐÂ
|
for calcInfo in calcHurtResults:
|
tagObj, _, hurtTypes, _ = calcInfo
|
tagID = tagObj.GetID()
|
finalHurt = int(hurtValueDict.pop(tagID, 0))
|
immuneHurt = max(int(immuneHurtDict.pop(tagID, 0)), 0) # ÒòΪÓбê¼Ç-1Öµ£¬ËùÒÔ¼Ómax
|
# Ö÷ҪĿ±êµÄÃâÒß±ê¼ÇÍâ²ãÒѾ´¦Àí£¬½ö¶îÍâ´¦Àí±ê¼Ç²ÜÈÊ·À»¤
|
if caorenProtectID == tagID:
|
hurtTypes |= pow(2, ChConfig.HurtType_CaorenProtect) # ±ê¼ÇÊܵ½²ÜÈÊ·À»¤£¬Ç°¶Ë±íÏÖÐèÒª
|
finalHurtResults.append([tagObj, finalHurt, hurtTypes, immuneHurt])
|
finalHurtTotal = finalHurtTotal + finalHurt + immuneHurt
|
GameWorld.DebugLog("µÃ³öÖ÷ҪĿ±ê·Ö̯ºóµÄ×îÖÕÉ˺¦: tagID=%s,finalHurt=%s,hurtTypes=%s,immuneHurt=%s,finalHurtTotal=%s" % (tagID, finalHurt, hurtTypes, immuneHurt, finalHurtTotal))
|
|
# Ê£ÏÂÉ˺¦ÔòĬÈÏΪ¶îÍâÄ¿±êÉ˺¦£¬·ÅÖ÷ҪĿ±êºóÃæ
|
isEx = 1
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for tagID in set(hurtValueDict.keys() + immuneHurtDict.keys()):
|
tagObj = batObjMgr.getBatObj(tagID)
|
if not tagObj:
|
continue
|
hurtTypes = pow(2, ChConfig.HurtType_Normal)
|
finalHurt = int(hurtValueDict.pop(tagID, 0))
|
immuneHurt = max(int(immuneHurtDict.pop(tagID, 0)), 0)
|
if immuneHurt > 0:
|
hurtTypes |= pow(2, ChConfig.HurtType_Immune) # Ìí¼ÓÃâÒß
|
finalHurtTotal = finalHurtTotal + finalHurt + immuneHurt
|
GameWorld.DebugLog("µÃ³ö¶îÍâÄ¿±ê·Ö̯ºóµÄ×îÖÕÉ˺¦: tagID=%s,finalHurt=%s,hurtTypes=%s,immuneHurt=%s,finalHurtTotal=%s" % (tagID, finalHurt, hurtTypes, immuneHurt, finalHurtTotal))
|
if finalHurt > 0 or immuneHurt > 0: # ¶îÍâÄ¿±êÓÐÊÜÉË»òÃâÒß²ÅËã
|
finalHurtResults.append([tagObj, finalHurt, hurtTypes, immuneHurt, isEx])
|
|
if finalHurtTotal != srcHurtTotal:
|
GameWorld.DebugLog("[·Ö̯É˺¦ºóÎó²îÖµ]=%s,srcHurtTotal=%s,finalHurtTotal=%s" % (srcHurtTotal - finalHurtTotal, srcHurtTotal, finalHurtTotal))
|
return finalHurtResults
|
|
def __calcFactionAverageHurt(turnFight, faction, lineupNum, hurtValueDict, immuneHurtDict, caorenProtectObj=None):
|
'''¼ÆËãij¸öÕóÓªµÄÉ˺¦Æ½Ì¯£¬Ã¿¸öÕóÓª¶ÀÁ¢¼ÆËã¼´¿É£¬¼õÉÙ¸´ÔÓ¶È
|
ÓÅÏȼ¶: Õçåµ > ²ÜÈÊ > ¶°×£»
|
¼õÉÙ¸´ÔӶȣ¬¹Ì¶¨°Ñ¶°××îºóË㣬ÕâÑùÿ¸öÕóÓªµÄÉ˺¦µ¥¶À¼ÆËã¾ù̯¼´¿É
|
@param hurtValueDict: Ä¿±êÉ˺¦×Öµä
|
@param immuneHurtDict: Ä¿Ç°×îÖÕÃâÒßÉ˺¦×Öµä
|
@param caorenProtectObj: ²ÜÈÊ·À»¤¶ÔÏ󣬿ÉÄÜΪ None »ò 0 »ò ijһ¸ö¶ÔÏó
|
'''
|
|
# Õçåµ Ç±ÄÜ1 Ö¯Ãü Õ½¶·¿ªÊ¼£¬ÕçåµÁ´½ÓÈ«Ìå¶ÓÓÑ£¬Ê¹ÈÎÒâ¶ÓÓÑÊܵ½µÄÉ˺¦ÓÉÈ«Ìå¾ù̯£¬³ÖÐø2»ØºÏ
|
# ²ÜÈʵķֵ£´¥·¢Ìõ¼þÔÝʱ³ÌÐòÄڹ̶¨£¬ÓÐÐÞ¸Äʱ³ÌÐòͬ²½ÐÞ¸Ä
|
# ²ÜÈÊ: ÎÒ·½Ó¢ÐÛÊܵ½Ö±½Ó¹¥»÷ʱ£¨Êܵ½Èº¹¥Ê±Ñ¡ÔñѪÁ¿×îµÍµÄÓÑ·½½øÐзÀ»¤£©£¬²ÜÈÊÓÐ30%¸ÅÂÊΪÆä·Öµ£Ò»°ëËùÊÜÉ˺¦£¬Ã¿³É¹¦·Öµ£Ò»´Î£¬²ÜÈÊ»ñµÃ1²ã¼áÈÍ£¬Ê¹ÎÒ·½È«Ìå¼õÉËÌáÉý5%£¬×î¶à6²ã£¬²ÜÈÊËÀÍöЧ¹ûÏûʧ
|
# ¶°×ÅÆø ͬÃüËø ¶ÔµÐ·½¹¥»÷×î¸ßµÄ1¸öÄ¿±êÔì³É¹¥»÷Á¦450%ÎïÀíÉ˺¦£¬²¢ÓëÆäÁ¬½Ó£¬Ê¹Á½ÈËÊܵ½µÄÈÎÒâÉ˺¦Æ½Ì¯£¨Æ½Ì¯É˺¦²»»á±»ÔÙ´Îƽ̯£©£¬³ÖÐø2»ØºÏ
|
caorenSkillID = 1015070
|
effHeroIDList = [ChConfig.HeroID_Zhenfu, ChConfig.HeroID_Caoren, ChConfig.HeroID_Dongbai] # Ôݹ̶¨£¬ÓÐÔö¼ÓÎ佫ÔÙͬ²½ÐÞ¸Ä
|
|
isAve = False
|
caorenProtectID = 0 # ²ÜÈʳɹ¦·À»¤µÄ¶ÔÏóID£¬ÓÐÖµ´ú±íÓзÀ»¤
|
otherFactionHurtDict = {} # ·Ö̯¸øÆäËûÕóÓªµÄÉ˺¦ {(faction, lineupNum):{objID:aveHurt, ...}, ...}
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(lineupNum)
|
batObjMgr = BattleObj.GetBatObjMgr()
|
GameWorld.DebugLog("----¿ªÊ¼¼ÆËãÕóÓª·Ö̯É˺¦: faction=%s,lineupNum=%s,hurtValueDict=%s,ÃâÒßÉ˺¦=%s"
|
% (faction, lineupNum, hurtValueDict, immuneHurtDict))
|
# °´ÓÅÏȼ¶Ë³Ðò´¦ÀíÓµÓзÖ̯Ч¹ûµÄÎ佫
|
for effHeroID in effHeroIDList:
|
if effHeroID not in batLineup.heroObjIDDict:
|
continue
|
objID = batLineup.heroObjIDDict[effHeroID]
|
batObj = batObjMgr.getBatObj(objID)
|
if not batObj or not batObj.IsAlive():
|
continue
|
buffMgr = batObj.GetBuffManager()
|
|
inHurt = objID in hurtValueDict # ¹â»·ÀïµÄÈËÔ±ÊÇ·ñÓÐÊÜÉË
|
aveBuff = None
|
aveObjList = [] # ¿É¾ù̯É˺¦µÄ¶ÔÏóÁбí
|
if effHeroID == ChConfig.HeroID_Caoren:
|
if not caorenProtectObj:
|
GameWorld.DebugLog("ûÓвÜÈÊ¿É·À»¤µÄ¶ÔÏó")
|
continue
|
hpLowestID = caorenProtectObj.GetID()
|
if hpLowestID == objID:
|
GameWorld.DebugLog("²ÜÈʲ»·À»¤×Ô¼º")
|
continue
|
if not inHurt and hpLowestID not in hurtValueDict:
|
GameWorld.DebugLog("²ÜÈʼ°·À»¤¶ÔÏ󶼲»ÔÚÊÜÉËÁбíÀï²»´¦Àí! hpLowestID=%s" % hpLowestID)
|
continue
|
if batObj.IsInControlledHard():
|
GameWorld.DebugLog("²ÜÈʱ»Ó²¿ØÖв»·À»¤")
|
continue
|
caoRenSkill = batObj.GetSkillManager().FindSkillByID(caorenSkillID)
|
if not caoRenSkill:
|
GameWorld.DebugLog("²ÜÈÊ»¹Î´Ñ§Ï°·Öµ£É˺¦¼¼ÄÜ! caorenSkillID=%s" % caorenSkillID)
|
continue
|
if not GameWorld.CanHappen(caoRenSkill.GetHappenRate()):
|
GameWorld.DebugLog("²ÜÈʸÅÂÊδ´¥·¢·À»¤")
|
continue
|
inHurt = True
|
aveObjList = [batObj, caorenProtectObj]
|
GameWorld.DebugLog("²ÜÈÊ´¥·¢·À»¤! hpLowestID=%s" % hpLowestID)
|
|
elif effHeroID == ChConfig.HeroID_Zhenfu:
|
aveBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_Zhiming)
|
|
elif effHeroID == ChConfig.HeroID_Dongbai:
|
aveBuff = buffMgr.FindBuffByState(ChConfig.BatObjState_Link)
|
|
else:
|
continue
|
|
if not aveObjList: # ûÓÐÖ¸¶¨¾ù̯É˺¦µÄ£¬¸ù¾Ý¾ù̯¹â»·buffÕÒ
|
if not aveBuff:
|
GameWorld.DebugLog("ûÓзÖ̯É˺¦¹â»·! effHeroID=%s" % (effHeroID))
|
continue
|
haloObjIDList = aveBuff.GetHaloObjIDList()
|
GameWorld.DebugLog("[·Ö̯¹â»·buff] effHeroID=%s,skillID=%s,objID=%s,haloObjIDList=%s" % (effHeroID, aveBuff.GetSkillID(), objID, haloObjIDList))
|
for haloObjID in haloObjIDList:
|
haloObj = batObjMgr.getBatObj(haloObjID)
|
if not haloObj or not haloObj.IsAlive():
|
continue
|
aveObjList.append(haloObj)
|
if not inHurt and haloObjID in hurtValueDict:
|
inHurt = True
|
|
if not inHurt:
|
GameWorld.DebugLog("Ïà¹ØÈËԱûÓÐÊÜÉË£¬²»´¦Àí·Ö̯É˺¦! effHeroID=%s" % effHeroID)
|
continue
|
|
aveObjCnt = len(aveObjList)
|
if aveObjCnt < 2:
|
GameWorld.DebugLog("Ïà¹ØÈËÔ±ÉÙÓÚ2¸öʱ×ÔÐге£ËùÓÐÉ˺¦! effHeroID=%s,aveObjCnt=%s" % (effHeroID, aveObjCnt))
|
continue
|
|
if not isAve:
|
isAve = True
|
|
if effHeroID == ChConfig.HeroID_Caoren and caorenProtectObj:
|
caorenProtectID = caorenProtectObj.GetID()
|
GameWorld.DebugLog("[²ÜÈÊ·À»¤Ä¿±ê] caorenProtectID=%s,caorenObjID=%s" % (caorenProtectID, objID))
|
|
aveHurtTotal = 0
|
for aveObj in aveObjList:
|
aveObjID = aveObj.GetID()
|
if effHeroID == ChConfig.HeroID_Caoren and aveObjID == objID:
|
GameWorld.DebugLog(" ²ÜÈʵÄЧ¹û²»Æ½Ì¯²ÜÈÊ×ÔÉíµÄÉ˺¦£¬Ö»ÊDzÜÈÊ°ï±ðÈË̯! aveObjID=%s" % aveObjID)
|
continue
|
if aveObjID not in hurtValueDict:
|
continue
|
hurtValue = hurtValueDict.pop(aveObjID, 0) # ±»·Ö̯µÄÉ˺¦ÒªÒƳý
|
if hurtValue <= 0:
|
GameWorld.DebugLog(" ÎÞÉ˺¦µÄ²»´¦Àí£º¿ÉÄÜÊÇ·ÇÖ÷ҪĿ±ê»ò×ÔÉíÒѾÎÞµÐÃâÒßÁËÉ˺¦! aveObjID=%s" % aveObjID)
|
continue
|
aveHurtTotal += hurtValue
|
GameWorld.DebugLog(" Àۼƴý·Ö̯É˺¦! effHeroID=%s,aveObjID=%s,hurtValue=%s,aveHurtTotal=%s" % (effHeroID, aveObjID, hurtValue, aveHurtTotal))
|
|
# ´ó¼Ò·Ö̯
|
aveHurtDict = {} # ±¾ÕóÓª¸Ã·Ö̯Ч¹û·Ö̯É˺¦¼Ç¼
|
aveHurt = round(aveHurtTotal / float(aveObjCnt), 2)
|
GameWorld.DebugLog("¼ÆËã·Ö̯É˺¦! effHeroID=%s,aveHurtTotal=%s,aveObjCnt=%s,aveHurt=%s" % (effHeroID, aveHurtTotal, aveObjCnt, aveHurt))
|
for aveObj in aveObjList:
|
aveObjID = aveObj.GetID()
|
aveFaction = aveObj.GetFaction()
|
|
immuneHurt = immuneHurtDict.get(aveObjID)
|
if immuneHurt == None:
|
if aveObj.CheckInState(ChConfig.BatObjState_Wudi):
|
immuneHurt = 0
|
else:
|
immuneHurt = -1 # ±ê¼ÇûÓÐÎÞµÐ
|
immuneHurtDict[aveObjID] = immuneHurt
|
|
if immuneHurt >= 0:
|
immuneHurtDict[aveObjID] = immuneHurt + aveHurt
|
GameWorld.DebugLog(" ÀÛ¼ÓÃâÒß·Ö̯É˺¦! aveObjID=%s,ÃâÒßÉ˺¦=%s" % (aveObjID, immuneHurtDict))
|
continue
|
|
if aveFaction == faction:
|
aveHurtDict[aveObjID] = aveHurtDict.get(aveObjID, 0) + aveHurt
|
GameWorld.DebugLog(" ÀÛ¼Ó±¾Ð§¹û±¾ÕóÓª·Ö̯É˺¦! aveObjID=%s,aveHurtDict=%s" % (aveObjID, aveHurtDict))
|
else:
|
aveLineupNum = aveObj.GetLineupNum()
|
key = (aveFaction, aveLineupNum)
|
if key not in otherFactionHurtDict:
|
otherFactionHurtDict[key] = {}
|
otherHurtDict = otherFactionHurtDict[key]
|
otherHurtDict[aveObjID] = otherHurtDict.get(aveObjID, 0) + aveHurt
|
GameWorld.DebugLog(" ÀÛ¼Ó±¾Ð§¹ûµÐÕóÓª·Ö̯É˺¦! aveObjID=%s,factionKey=%s,otherHurtDict=%s" % (aveObjID, key, otherHurtDict))
|
|
# »ã×Ü×îÐÂÉ˺¦
|
for aveObjID, aveHurt in aveHurtDict.items():
|
hurtValueDict[aveObjID] = hurtValueDict.get(aveObjID, 0) + aveHurt
|
GameWorld.DebugLog(" ¸üб¾Ð§¹û·Ö̯ºóµÄÉ˺¦! %s,ÃâÒßÉ˺¦=%s,¸øµÐÕóÓª=%s" % (hurtValueDict, immuneHurtDict, otherFactionHurtDict))
|
|
return isAve, caorenProtectID, otherFactionHurtDict
|
|
def DoLostHP(turnFight, atkObj, defObj, hurtValue, curSkill, lostType="", hpCanNegative=False, immuneHurt=0):
|
'''½öÖ´ÐеôѪÂß¼: ³ÐÉË¶ÜµÖ¿Û + Ê£Óà¿ÛѪ
|
@param hurtValue: µôѪÉ˺¦Öµ£¬Ò»°ãÊǸ÷ÖÖ¼ÆËãºóµÄ×îÖÕÉ˺¦Öµ
|
@param hpCanNegative: ¿Û³ýºóµÄÉúÃüÊÇ·ñÔÊÐí¸ºÖµ
|
@param immuneHurt: ÃâÒßµÄÉ˺¦Öµ
|
@param isSkillSelfTag: ÊÇ·ñ¼¼ÄÜ×ÔÉíµÄÖ±½ÓÄ¿±ê£¬Èçƽ̯É˺¦Ä¿±ê¡¢½¦ÉäÉ˺¦Ä¿±êÕâÖ־Ͳ»ËãÖ±½ÓÄ¿±ê
|
@return: lostHP
|
'''
|
|
if immuneHurt > 0:
|
buffMgr = defObj.GetBuffManager()
|
wudiBuffList = buffMgr.FindBuffListByState(ChConfig.BatObjState_Wudi)
|
for buff in wudiBuffList:
|
buffSkillID = buff.GetSkillID()
|
# ¼Ç¼ÃâÒß»ýÔܵÄÉ˺¦
|
buffValue = buff.GetValue1() + buff.GetValue2() * ChConfig.Def_PerPointValue
|
updBuffValue = buffValue + immuneHurt
|
buff.SetValue1(updBuffValue % ChConfig.Def_PerPointValue)
|
buff.SetValue2(updBuffValue / ChConfig.Def_PerPointValue)
|
GameWorld.DebugLog(" Î޵жÜÀÛ¼ÆÃâÒßÉ˺¦: defID=%s,buffID=%s,buffSkillID=%s,buffValue=%s,immuneHurt=%s,updBuffValue=%s,lostType=%s"
|
% (defObj.GetID(), buff.GetBuffID(), buffSkillID, buffValue, immuneHurt, updBuffValue, lostType))
|
|
if hurtValue <= 0:
|
return 0
|
|
atkID = atkObj.GetID()
|
defID = defObj.GetID()
|
skillID = curSkill.GetSkillID()
|
|
# ³ÐÉ˶ܳÐÉË£¬Ê£Óàʱ¼ä¶ÌµÄÓÅÏȳÐÉË£¬³ÐÉ˲»Ó°ÏìÊä³ö£¬Ï൱ÓÚ¶îÍâµÄHP£¬½öÓÃÓÚµÖ¿ÛµôѪ£¬½ö ¸Ä±ä lostHP
|
lostHP = hurtValue
|
shieldBuffList = []
|
buffMgr = defObj.GetBuffManager()
|
for buff in buffMgr.FindBuffListByState(ChConfig.BatObjState_DamShield):
|
skillData = buff.GetSkillData()
|
remainTime = buff.GetRemainTime() # Ê£Óà»ØºÏ
|
if not skillData.GetLastTime():
|
remainTime = 999 # ÓÀ¾Ã¶Ü
|
buffValue = buff.GetValue1() + buff.GetValue2() * ChConfig.Def_PerPointValue # Ê£Óà¶ÜÖµ
|
shieldBuffList.append([remainTime, buffValue, buff])
|
|
if shieldBuffList:
|
#¿ÉÄÜÐèҪͬ²½¶ÜÉ˸úʵ¼Ê¿ÛѪֵ¸øÇ°¶Ë£¬¾ßÌå¿´Ç°¶Ë»¤¶ÜÔõô´¦ÀíÔÙÓÅ»¯
|
shieldHurtPer = 10000 # ¶Ô»¤¶ÜÉ˺¦±È
|
shieldHurtPer += TurnPassive.GetTriggerEffectValue(turnFight, atkObj, defObj, ChConfig.PassiveEff_AddShieldHurtPer, curSkill)
|
shieldHurtPer /= 10000.0
|
shieldHurtValue = int(hurtValue * shieldHurtPer) # ¶Ô»¤¶ÜÉ˺¦
|
GameWorld.DebugLog(" ¶Ô»¤¶Ü×ÜÉ˺¦: shieldHurtValue=%s,shieldHurtPer=%s,hurtValue=%s" % (shieldHurtValue, shieldHurtPer, hurtValue))
|
shieldBuffList.sort()
|
for _, buffValue, buff in shieldBuffList:
|
if shieldHurtValue <= 0:
|
break
|
buffID = buff.GetBuffID()
|
buffSkillID = buff.GetSkillID()
|
if shieldHurtValue < buffValue:
|
decShieldValue = shieldHurtValue
|
else:
|
decShieldValue = buffValue
|
GameWorld.DebugLog(" ³ÐÉ˶ֿܵÛ: buffID=%s,skillID=%s,buffValue=%s,Ê£Óà¶ÜÉË=%s,¿Û³ý¶ÜÖµ=%s" % (buffID, buffSkillID, buffValue, shieldHurtValue, decShieldValue))
|
shieldHurtValue -= decShieldValue # ³ÐÉËÖµ
|
if decShieldValue >= buffValue:
|
GameWorld.DebugLog(" ɾ³ý¶Ü: buffID=%s,Ê£Óà¶ÜÉË=%s" % (buffID, shieldHurtValue))
|
TurnBuff.DoBuffDel(turnFight, defObj, buff, relatedSkill=curSkill, afterLogic=True, tagObj=atkObj)
|
else:
|
updShieldValue = buffValue - decShieldValue
|
GameWorld.DebugLog(" ¸üжÜ: updShieldValue=%s,Ê£Óà¶ÜÉË=%s" % (updShieldValue, shieldHurtValue))
|
buff.SetValue1(updShieldValue % ChConfig.Def_PerPointValue)
|
buff.SetValue2(updShieldValue / ChConfig.Def_PerPointValue)
|
curSkill.AddAfterLogic(ChConfig.AfterLogic_SyncBuff, [defObj, buff, atkObj, "ReduceShieldValue"])
|
|
lostHP = int(shieldHurtValue / shieldHurtPer)
|
GameWorld.DebugLog(" ³ÐÉ˺óÊ£ÓàÉËѪ: lostHP=%s" % (lostHP))
|
|
dHP = defObj.GetHP()
|
remainHP = dHP - lostHP # Ê£ÓàѪÁ¿
|
if not hpCanNegative and remainHP < 0:
|
remainHP = 0
|
lostHP = dHP - remainHP # ʵ¼ÊµôѪÁ¿
|
defObj.SetHP(remainHP)
|
|
GameWorld.DebugLog(" ¿ÛѪ: atkID=%s,defID=%s,hurtValue=%s,lostType=%s,lostHP=%s,dHP=%s,updHP=%s/%s"
|
% (atkID, defID, hurtValue, lostType, lostHP, dHP, defObj.GetHP(), defObj.GetMaxHP()))
|
TurnAttack.AddTurnObjHurtValue(atkObj, defObj, hurtValue, lostHP, skillID, lostType)
|
return lostHP
|
|
def CalcBounceHP(turnFight, atkObj, defObj, hurtObj, curSkill):
|
'''¼ÆËã·´µ¯·´µ¯É˺¦
|
×¢£º·´ÉË/¾£¼¬Ôݲ»×öÊôÐÔÖ§³Ö£¬½ö×öbuffЧ¹ûÖ§³Ö
|
'''
|
if not atkObj.GetCanAttack():
|
return
|
|
damBackPer = 0
|
buffMgr = defObj.GetBuffManager()
|
for buff in buffMgr.FindBuffListByState(ChConfig.BatObjState_DamBackShield):
|
damBackPer += buff.GetValue1()
|
|
if damBackPer <= 0:
|
return
|
|
bounceHP = int(hurtObj.GetHurtHP() * damBackPer / 10000.0)
|
if bounceHP <= 0:
|
return
|
|
GameWorld.DebugLog(" ·´µ¯É˺¦=%s,%s/%s, damBackPer=%s" % (bounceHP, atkObj.GetHP(), atkObj.GetMaxHP(), damBackPer))
|
bounceHP, _, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, bounceHP)
|
if bounceHP <= 0:
|
GameWorld.DebugLog(" bounceHP=%s" % (bounceHP))
|
return
|
hurtObj.SetBounceHP(bounceHP)
|
DoLostHP(turnFight, atkObj, defObj, bounceHP, curSkill, "Bounce", hpCanNegative=True, immuneHurt=immuneHurt) # ·´µ¯ºóÉúÃüÔÊÐí¸ºÖµ
|
return
|
|
def CalcSuckBlood(turnFight, atkObj, defObj, hurtObj, curSkill):
|
'''¼ÆËãÎüѪ
|
'''
|
|
hurtHP = hurtObj.GetHurtHP()
|
if hurtHP <= 1:
|
return
|
|
aSuckHPPer = atkObj.GetBatAttrValue(ChConfig.AttrID_SuckHPPer)
|
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()
|
maxHP = atkObj.GetMaxHP()
|
remainHP = min(curHP + suckHP, maxHP)
|
cureHP = remainHP - curHP # ʵ¼ÊÖÎÁÆÁ¿
|
|
hurtObj.SetSuckHP(suckHP)
|
atkObj.SetHP(remainHP)
|
GameWorld.DebugLog(" ÎüѪ=%s,remainHP=%s/%s,aSuckHPPer=%s,dSuckHPPerDef=%s,aCurePer=%s,dCureDefPer=%s"
|
% (suckHP, remainHP, maxHP, aSuckHPPer, dSuckHPPerDef, aCurePer, dCureDefPer))
|
|
# ÎüѪÔݶ¨ËãÖÎÁÆ
|
TurnAttack.AddTurnObjCureHP(atkObj, atkObj, suckHP, cureHP)
|
return
|
|
def CalcCureHP(turnFight, userObj, tagObj, curSkill, relativeObj=None):
|
''' ¼ÆËãÖÎÁÆÖµ
|
'''
|
|
# ¶ÔλĿ±ê
|
if not relativeObj:
|
relativeObj = GetRelativeObj(turnFight, userObj)
|
|
skillID = curSkill.GetSkillID()
|
cureType = curSkill.GetCalcType()
|
skillPer = curSkill.GetSkillPer()
|
#skillValue = curSkill.GetSkillValue()
|
|
skillPer += GetAddSkillPer(turnFight, userObj, tagObj, curSkill)
|
|
aCurePer = userObj.GetBatAttrValue(ChConfig.AttrID_CurePer) # ÖÎÁƼӳÉ
|
dCureDefPer = relativeObj.GetBatAttrValue(ChConfig.AttrID_CurePerDef) # ¶ÔλµÄÈõ»¯ÖÎÁÆ
|
|
angerOverflow = userObj.GetAngerOverflow() # ÅÆøÒç³öÖµ
|
|
skillPer /= float(ChConfig.Def_MaxRateValue)
|
aCurePer /= float(ChConfig.Def_MaxRateValue)
|
dCureDefPer /= float(ChConfig.Def_MaxRateValue)
|
|
baseValue = GetCalcBaseValue(cureType, userObj, tagObj, curSkill)
|
|
cureHP = eval(IpyGameDataPY.GetFuncCompileCfg("CureFormula", 1))
|
GameWorld.DebugLog("¼ÆËãÖÎÁÆÖµ(%s)£ºskillID=%s,cureType=%s,baseValue=%s,skillPer=%s,aCurePer=%s,dCureDefPer=%s,angerOverflow=%s"
|
% (cureHP, skillID, cureType, baseValue, skillPer, aCurePer, dCureDefPer, angerOverflow))
|
|
# ¶îÍâÖÎÁÆÖµ
|
cureWayExEff = curSkill.GetEffectByID(ChConfig.SkillEff_CureWayEx)
|
if cureWayExEff:
|
cureType = cureWayExEff.GetEffectValue(0)
|
skillPer = cureWayExEff.GetEffectValue(1)
|
skillPer /= float(ChConfig.Def_MaxRateValue)
|
baseValue = GetCalcBaseValue(cureType, userObj, tagObj, curSkill)
|
cureHPEx = eval(IpyGameDataPY.GetFuncCompileCfg("CureFormula", 1))
|
cureHP += cureHPEx
|
GameWorld.DebugLog(" ¶îÍâÖÎÁÆÖµ(%s): cureType=%s,baseValue=%s,skillPer=%s,cureHP=%s" % (cureHPEx, cureType, baseValue, skillPer, cureHP))
|
|
hurtShareEff = curSkill.GetEffectByID(ChConfig.SkillEff_HurtShare)
|
if hurtShareEff:
|
tagCnt = max(1, len(curSkill.GetTagObjList()))
|
cureHP = cureHP / tagCnt
|
GameWorld.DebugLog(" Ä¿±ê¾ù̯ÖÎÁÆ: cureHP=%s,tagCnt=%s" % (cureHP, tagCnt))
|
|
if cureHP < 1:
|
cureHP = 1
|
GameWorld.DebugLog(" ±£µ×ÖÎÁÆÖµ: cureHP=%s" % (cureHP))
|
return int(cureHP)
|
|
def GetCalcBaseValue(calcType, curObj, tagObj, curSkill):
|
##»ñµÃ»ù´¡¼ÆËãÖµ
|
baseValue = 0
|
if calcType == ChConfig.Def_Calc_Attack:
|
baseValue = curObj.GetAtk()
|
elif calcType == ChConfig.Def_Calc_MaxHP:
|
baseValue = curObj.GetMaxHP()
|
elif calcType == ChConfig.Def_Calc_LastHurt:
|
baseValue = curObj.GetLastHurtValue()
|
elif calcType == ChConfig.Def_Calc_TagMaxHP:
|
baseValue = 0 if not tagObj else tagObj.GetMaxHP()
|
elif calcType == ChConfig.Def_Calc_TagLostHP:
|
baseValue = 0 if not tagObj else max(0, tagObj.GetMaxHP() - tagObj.GetHP())
|
elif calcType == ChConfig.Def_Calc_ByBuffValue:
|
byBuff = curSkill.GetByBuff()
|
if byBuff:
|
baseValue = byBuff.GetValue1() + byBuff.GetValue2() * ChConfig.Def_PerPointValue
|
GameWorld.DebugLog("¸ù¾ÝbuffÖµ: %s" % baseValue)
|
elif calcType == ChConfig.Def_Calc_HarmSelfHP:
|
baseValue = curObj.GetHarmSelfHP()
|
GameWorld.DebugLog("¸ù¾Ý×Ô²ÐÖµ: %s" % baseValue)
|
elif calcType == ChConfig.Def_Calc_AtkedSkillHurtHP:
|
bySkill = curSkill.GetBySkill()
|
bySkillID = 0
|
if bySkill:
|
bySkillID = bySkill.GetSkillID()
|
curID = curObj.GetID()
|
for hurtObj in bySkill.GetHurtObjListAll():
|
if curID == hurtObj.GetObjID():
|
baseValue += hurtObj.GetHurtHP()
|
GameWorld.DebugLog("¸ù¾Ý×îºóÊÜ»÷¼¼ÄÜÉ˺¦: %s,bySkillID=%s" % (baseValue, bySkillID))
|
|
return max(0, baseValue)
|
|
def DoDOTAttack(turnFight, batObj, curBuff, hurtValue, hurtTypes, **kwargs):
|
## Ö´Ðе¥´ÎdotÂß¼
|
skillID = curBuff.GetSkillID()
|
skillIpyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
|
if not skillIpyData:
|
return
|
buffID = curBuff.GetBuffID()
|
ownerID = curBuff.GetOwnerID()
|
buffOwner = BattleObj.GetBatObjMgr().getBatObj(ownerID) # ¹¥»÷·½
|
if not buffOwner:
|
return
|
|
atkObj = buffOwner
|
defObj = batObj
|
|
atkID = ownerID
|
defID = defObj.GetID()
|
|
# ½áËãÐèҪͬ²½±êÇ©
|
useTag = "Skill_%s_%s_Dot" % (atkID, skillID)
|
Sync_TurnFightTag(turnFight, useTag, 0)
|
|
dHP = defObj.GetHP()
|
dMaxHP = defObj.GetMaxHP()
|
GameWorld.DebugLog("½áËãdot: atkID=%s,defID=%s,buffID=%s,skillID=%s,ownerID=%s,hurtValue=%s,hurtTypes=%s,dHP=%s/%s"
|
% (atkID, defID, buffID, skillID, ownerID, hurtValue, hurtTypes, dHP, dMaxHP))
|
layer = curBuff.GetLayer()
|
if layer > 0:
|
hurtValue *= layer
|
GameWorld.DebugLog(" ¶à²ãbuffÉ˺¦: hurtValue=%s,layer=%s" % (hurtValue, layer))
|
if "FinalDamPer" in kwargs:
|
FinalDamPer = kwargs["FinalDamPer"]
|
hurtValue *= (10000 + FinalDamPer) / 10000.0
|
GameWorld.DebugLog(" ÔöÉË: hurtValue=%s,FinalDamPer=%s" % (hurtValue, FinalDamPer))
|
|
poolMgr = ObjPool.GetPoolMgr()
|
useSkill = poolMgr.acquire(BattleObj.PySkill, skillIpyData, atkID)
|
useSkill.SetTagObjList([defObj])
|
useSkill.SetBatType(ChConfig.TurnBattleType_Dot)
|
|
hurtValue, hurtTypes, immuneHurt = CalcHurtWithBuff(turnFight, atkObj, defObj, hurtValue, hurtTypes)
|
calcHurtResults = [[defObj, hurtValue, hurtTypes, immuneHurt]]
|
DoSkillHurtHP(turnFight, atkObj, useSkill, calcHurtResults, "DOT")
|
|
Sync_UseSkill(turnFight, atkObj, useSkill)
|
|
DoBeAttackResult(turnFight, atkObj, useSkill)
|
|
# ֪ͨ½áÊø±êÇ©
|
Sync_TurnFightTag(turnFight, useTag, 1)
|
|
useSkill.ResetUseRec()
|
poolMgr.release(useSkill)
|
return
|
|
def Sync_TurnFightTag(turnFight, useTag, sign):
|
## ֪ͨ¼¼ÄܱêÇ©
|
clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagSCTurnFightTag)
|
clientPack.Tag = useTag
|
clientPack.Len = len(clientPack.Tag)
|
clientPack.Sign = sign
|
turnFight.addBatPack(clientPack)
|
return
|
|
def Sync_UseSkill(turnFight, curBatObj, useSkill):
|
## ֪ͨÊͷż¼ÄÜ
|
bySkill = useSkill.GetBySkill()
|
relatedSkillID = bySkill.GetSkillID() if bySkill else 0
|
poolMgr = ObjPool.GetPoolMgr()
|
clientPack = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkill)
|
clientPack.ObjID = curBatObj.GetID()
|
clientPack.PMType = GetPMType(curBatObj, useSkill)
|
clientPack.BattleType = useSkill.GetBatType()
|
clientPack.CurHP = curBatObj.GetHP() % ChConfig.Def_PerPointValue
|
clientPack.CurHPEx = curBatObj.GetHP() / ChConfig.Def_PerPointValue
|
clientPack.SkillID = useSkill.GetSkillID()
|
clientPack.RelatedSkillID = relatedSkillID
|
# ¼¼ÄܵÄÖ÷ÒªÉ˺¦
|
clientPack.HurtList = []
|
for hurtObj in useSkill.GetHurtObjList():
|
hurt = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurt)
|
hurt.ObjID = hurtObj.GetObjID()
|
hurt.AttackTypes = hurtObj.GetHurtTypes()
|
hurt.HurtHP = hurtObj.GetHurtHP() % ChConfig.Def_PerPointValue
|
hurt.HurtHPEx = hurtObj.GetHurtHP() / ChConfig.Def_PerPointValue
|
hurt.CurHP = hurtObj.GetCurHP() % ChConfig.Def_PerPointValue
|
hurt.CurHPEx = hurtObj.GetCurHP() / ChConfig.Def_PerPointValue
|
hurt.SuckHP = min(hurtObj.GetSuckHP(), ChConfig.Def_UpperLimit_DWord)
|
hurt.BounceHP = min(hurtObj.GetBounceHP(), ChConfig.Def_UpperLimit_DWord)
|
hurt.HurtListEx = []
|
# µ¥¸öÉ˺¦µÄ¶îÍâÉ˺¦£¬È絯Éä+ƽ̯É˺¦
|
for hurtObjEx in hurtObj.GetHurtObjListEx():
|
hurtEx = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurtEx)
|
hurtEx.ObjID = hurtObjEx.GetObjID()
|
hurtEx.AttackTypes = hurtObjEx.GetHurtTypes()
|
hurtEx.HurtHP = hurtObjEx.GetHurtHP() % ChConfig.Def_PerPointValue
|
hurtEx.HurtHPEx = hurtObjEx.GetHurtHP() / ChConfig.Def_PerPointValue
|
hurtEx.CurHP = hurtObjEx.GetCurHP() % ChConfig.Def_PerPointValue
|
hurtEx.CurHPEx = hurtObjEx.GetCurHP() / ChConfig.Def_PerPointValue
|
hurtEx.SuckHP = min(hurtObjEx.GetSuckHP(), ChConfig.Def_UpperLimit_DWord)
|
hurt.HurtListEx.append(hurtEx)
|
hurt.HurtCountEx = len(hurt.HurtListEx)
|
clientPack.HurtList.append(hurt)
|
|
# ¼¼ÄܵĶîÍâÉ˺¦£¬Èç³£¹æ¼¼ÄܵÄƽ̯É˺¦
|
clientPack.HurtListEx = []
|
for hurtObjEx in useSkill.GetHurtObjListEx():
|
hurtEx = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurtEx)
|
hurtEx.ObjID = hurtObjEx.GetObjID()
|
hurtEx.AttackTypes = hurtObjEx.GetHurtTypes()
|
hurtEx.HurtHP = hurtObjEx.GetHurtHP() % ChConfig.Def_PerPointValue
|
hurtEx.HurtHPEx = hurtObjEx.GetHurtHP() / ChConfig.Def_PerPointValue
|
hurtEx.CurHP = hurtObjEx.GetCurHP() % ChConfig.Def_PerPointValue
|
hurtEx.CurHPEx = hurtObjEx.GetCurHP() / ChConfig.Def_PerPointValue
|
hurtEx.SuckHP = min(hurtObjEx.GetSuckHP(), ChConfig.Def_UpperLimit_DWord)
|
clientPack.HurtListEx.append(hurtEx)
|
clientPack.HurtCountEx = len(clientPack.HurtListEx)
|
|
# ûÓÐÖ÷ÒªÉ˺¦Ê±ÊÓΪûÓÐÉ˺¦£¬Èç´¿buffµÄ¼¼ÄÜ£¬ÐèҪ֪ͨĿ±ê¸øÇ°¶Ë
|
if not clientPack.HurtList:
|
for tagObj in useSkill.GetTagObjList():
|
tagID = tagObj.GetID()
|
hurt = poolMgr.acquire(ChPyNetSendPack.tagSCUseSkillHurt)
|
hurt.ObjID = tagID
|
hurt.CurHP = tagObj.GetHP() % ChConfig.Def_PerPointValue
|
hurt.CurHPEx = tagObj.GetHP() / ChConfig.Def_PerPointValue
|
clientPack.HurtList.append(hurt)
|
|
clientPack.HurtCount = len(clientPack.HurtList)
|
turnFight.addBatPack(clientPack)
|
return
|
|
def Sync_PropertyRefreshView(turnFight, curBatObj, attrID, value, diffValue, diffType=0, skillID=0, relatedSkillID=0, hurtTypes=0):
|
'''֪ͨ¶ÔÏóÊôÐÔË¢ÐÂչʾB418
|
@param attrID: ֪ͨ±ä»¯µÄÊôÐÔID
|
@param diffValue: ±ä»¯Öµ
|
@param diffType: ±ä»¯ÀàÐÍ£¬0-¼õÉÙ£»1-Ôö¼Ó
|
@param skillID: ʹÓõļ¼ÄܱíID£¬¼´Äĸö¼¼ÄܵÄЧ¹û
|
@param relatedSkillID: ¹ØÁªµÄ¼¼ÄÜID£¬Ò»°ãÊÇÖ÷¼¼ÄÜID£¬·ÇÖ÷¼¼ÄܶîÍâ´¥·¢µÄΪ0
|
@param hurtTypes: Æ®×ÖÀàÐÍ»ã×Ü£¬Ö§³Ö¶àÖÖÀàÐͲ¢´æ£¬ÈçÎÞÊÓ·ÀÓùÇÒ±©»÷ͬʱ±»¸ñµ²£¬¶þ½øÖÆ»òÔËËã×îÖÕÖµ£»0-ʧ°Ü£»1-ÆÕͨ£»2-»ØѪ£»5-¸ñµ²£»6-ÎÞÊÓ·ÀÓù£»7-±©»÷£»9-ÉÁ±Ü
|
'''
|
if attrID not in ChConfig.CDBRefresh_AttrIDDict:
|
return
|
refreshType, isBig = ChConfig.CDBRefresh_AttrIDDict[attrID]
|
poolMgr = ObjPool.GetPoolMgr()
|
clientPack = poolMgr.acquire(ChPyNetSendPack.tagSCObjPropertyRefreshView)
|
clientPack.ObjID = curBatObj.GetID()
|
clientPack.RefreshType = refreshType
|
clientPack.AttackTypes = hurtTypes
|
if isBig:
|
clientPack.Value = value % ShareDefine.Def_PerPointValue
|
clientPack.ValueEx = value / ShareDefine.Def_PerPointValue
|
clientPack.DiffValue = diffValue % ShareDefine.Def_PerPointValue
|
clientPack.DiffValueEx = diffValue / ShareDefine.Def_PerPointValue
|
else:
|
clientPack.Value = value
|
clientPack.ValueEx = 0
|
clientPack.DiffValue = diffValue
|
clientPack.DiffValueEx = 0
|
clientPack.DiffType = diffType
|
clientPack.SkillID = skillID
|
clientPack.RelatedSkillID = relatedSkillID
|
turnFight.addBatPack(clientPack)
|
return
|
|
def Sync_HPRefresh(turnFight, curBatObj):
|
hp, maxHP = curBatObj.GetHP(), curBatObj.GetMaxHP()
|
clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagSCObjHPRefresh)
|
clientPack.ObjID = curBatObj.GetID()
|
clientPack.HP = hp % ShareDefine.Def_PerPointValue
|
clientPack.HPEx = hp / ShareDefine.Def_PerPointValue
|
clientPack.MaxHP = maxHP % ShareDefine.Def_PerPointValue
|
clientPack.MaxHPEx = maxHP / ShareDefine.Def_PerPointValue
|
turnFight.addBatPack(clientPack)
|
return
|
|
