#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package BattleObj
#
# @todo:Õ½¶·¶ÔÏó
# @author hxp
# @date 2025-08-06
# @version 1.0
#
# ÏêϸÃèÊö: py×Ô¶¨ÒåµÄÕ½¶·¶ÔÏ󣬿ÉÒÔÊÇÍæ¼Ò¡¢NPCͨÓõģ¬·ÏÆúÔ­c++µÄPlayer¼°NPC£¬ÍêÈ«ÓÉpy×ÔÐд¦Àí
# MMOÏîÄ¿¿ÉÒÔcurPlayer°ó¶¨Ò»¸öÕ½¶·¶ÔÏó£¬curPlayer½ö×öΪÍæ¼ÒµÄÊý¾Ý¶ÔÏó£¬Õ½¶·Ïà¹ØͳһʹÓÃÕ½¶·¶ÔÏó
#
#-------------------------------------------------------------------------------
#"""Version = 2025-08-06 18:30"""
#-------------------------------------------------------------------------------

import GameWorld
import PyGameData
import TurnAttack
import IpyGameDataPY
import ChNetSendPack
import ShareDefine
import ChConfig
import ObjPool
import TurnPassive
import TurnBuff

class PassiveEffManager():
    ## ±»¶¯Ð§¹û¹ÜÀíÆ÷
    
    def __init__(self, batObj):
        self._batObj = batObj
        # ±»Ó°ÏìµÄ¼¼ÄÜID: 0ΪËùÓм¼ÄÜ
        self._AffectSkillDict = {} # ±»¶¯¼¼ÄÜ {(´¥·¢·½Ê½, ÓÐЧÀ´Ô´):{¼¼ÄÜID:[effID, ...], ...}, ...}
        self._AffectBuffDict = {} # ±»¶¯buff {(´¥·¢·½Ê½, ÓÐЧÀ´Ô´):{buffID:[effID, ...], ...}, ...}
        return
    
    def GetPassiveEffByTrigger(self, triggerWay, connSkillTypeID=0):
        '''»ñÈ¡¿É´¥·¢µÄЧ¹ûÁÐ±í£¬¼¼Äܸúbuff¸ù¾Ý´¥·¢ÓÅÏȼ¶°´Ë³Ðò´¥·¢£¬ÓÅÏȼ¶Ô½¸ßÔ½ÏÈÖ´ÐУ¬Ïàͬʱ¼¼ÄÜÓÅÏÈ
                        ÓÅÏȼ¶Ö®ºóÓÐÐèÒªÔÙÀ©Õ¹
        @return: [["skill/buff", skillID/buffID, effIDList], ...]
        '''
        effList = []
        
        # ÓÅÏÈÈ¡¹ØÁª¼¼ÄܵÄ
        if connSkillTypeID and connSkillTypeID not in [ChConfig.TriggerSrc_Skill, ChConfig.TriggerSrc_Buff]:
            # ¼¼ÄÜ
            key = (triggerWay, connSkillTypeID)
            if key in self._AffectSkillDict:
                effDict = self._AffectSkillDict[key]
                for skillID, effIDList in effDict.items():
                    effList.append(["skill", skillID, effIDList])
                    
            # buff
            key = (triggerWay, connSkillTypeID)
            if key in self._AffectBuffDict:
                effDict = self._AffectBuffDict[key]
                for buffID, effIDList in effDict.items():
                    effList.append(["buff", buffID, effIDList])
                    
        # ËùÓм¼ÄÜÓÐЧµÄ
        key = (triggerWay, ChConfig.TriggerSrc_Skill)
        effDict = self._AffectSkillDict.get(key, {})
        for skillID, effIDList in effDict.items():
            effList.append(["skill", skillID, effIDList])
            
        # ËùÓÐbuffÓÐЧµÄ
        key = (triggerWay, ChConfig.TriggerSrc_Buff)
        effDict = self._AffectBuffDict.get(key, {})
        for buffID, effIDList in effDict.items():
            effList.append(["buff", buffID, effIDList])
            
        return effList
    
    def RefreshSkillPassiveEffect(self):
        self._AffectSkillDict = {}
        
        skillManager = self._batObj.GetSkillManager()
        for index in range(0, skillManager.GetSkillCount()):
            curSkill = skillManager.GetSkillByIndex(index)
            if not curSkill:
                continue
            for index in xrange(curSkill.GetEffectCount()):
                curEffect = curSkill.GetEffect(index)
                effectID = curEffect.GetEffectID()
                if effectID == 0:
                    continue
                self.AddSkillPassiveEffect(curSkill, curEffect)
                
        return self._AffectSkillDict
                
    def AddSkillPassiveEffect(self, curSkill, effect):
        ## Ìí¼Ó¼¼Äܱ»¶¯Ð§¹û
        triggerWay = effect.GetTriggerWay()
        triggerSrc = effect.GetTriggerSrc()
        if not triggerWay:
            return
        if triggerWay == ChConfig.TriggerWay_CurSkillEff:
            return
        if triggerSrc == ChConfig.TriggerSrc_Buff:
            # buffÓÐЧµÄ²»¼Ó½øÀ´
            return
        
        skillID = curSkill.GetSkillID()
        effectID = effect.GetEffectID()
        
        key = (triggerWay, triggerSrc)
        if key not in self._AffectSkillDict:
            self._AffectSkillDict[key] = {}
        effDict = self._AffectSkillDict[key]
        if skillID not in effDict:
            effDict[skillID] = []
        effDict[skillID].append(effectID)
        return
        
    def RefreshBuffPassiveEffect(self):
        self._AffectBuffDict = {}
        buffMgr = self._batObj.GetBuffManager()
        for index in range(buffMgr.GetBuffCount()):
            buff = buffMgr.GetBuffByIndex(index)
            if not buff:
                continue
            skillData = buff.GetSkillData()
            for index in xrange(skillData.GetEffectCount()):
                curEffect = skillData.GetEffect(index)
                effectID = curEffect.GetEffectID()
                if effectID == 0:
                    continue
                self.AddBuffPassiveEffect(buff, skillData, curEffect)
                
        return self._AffectBuffDict
    
    def AddBuffPassiveEffect(self, buff, skillData, effect):
        '''Ìí¼ÓBuff±»¶¯Ð§¹û
                            ͬ¸öbuffµÄ¼¼ÄÜIDÈç¹ûµþ¼Ó¹æÔòÊǶÀÁ¢µÄ£¬ÄÇô¿ÉÄÜͬʱ´æÔÚ¶à¸öÏàͬ¼¼ÄÜЧ¹ûµÄbuff
                            Èç¹û´¥·¢Ð§¹û£¬¾ÍÒª´¥·¢¶à´Î£¬ËùÒÔbuffµÄЧ¹ûÒÔbuffIDΪkey
        '''
        triggerWay = effect.GetTriggerWay()
        triggerSrc = effect.GetTriggerSrc()
        if not triggerWay:
            return
        if triggerWay == ChConfig.TriggerWay_CurSkillEff:
            return
        if triggerSrc == ChConfig.TriggerSrc_Skill:
            # ¼¼ÄÜÓÐЧµÄ²»¼Ó½øÀ´
            return
        
        buffID = buff.GetBuffID()
        effectID = effect.GetEffectID()
        
        key = (triggerWay, triggerSrc)
        if key not in self._AffectBuffDict:
            self._AffectBuffDict[key] = {}
        effDict = self._AffectBuffDict[key]
        if buffID not in effDict:
            effDict[buffID] = []
        effIDList = effDict[buffID]
        if effectID not in effIDList:
            effIDList.append(effectID)
        return
    
    def DelBuffPassiveEffect(self, buffID):
        ## ɾ³ýBuff±»¶¯Ð§¹û
        for key, effDict in self._AffectBuffDict.items():
            if buffID not in effDict:
                continue
            effDict.pop(buffID)
            if not effDict:
                self._AffectBuffDict.pop(key)
        return
    
class HurtObj():
    ## ÉËѪͳ¼Æ
    
    def __init__(self):
        self.Clear()
        return
    
    def Clear(self):
        self._objID = 0
        self._hurtTypes = 0 # ±¾´ÎÉËѪÀàÐÍ£¬ÈçÉÁ±Ü¡¢±©»÷¡¢¸ñµ²µÈ£¬Í¨¹ý¶þ½øÖÆ»òÔËËãµÃµ½×îÖÕÖµ£¬Ö§³Ö¶àÖÖͬʱ³öÏÖ£¬È籩»÷µÄͬʱ±»¸ñµ²
        self._hurtHP = 0 # ¹«Ê½×îÖÕ¼ÆËãµÄÉ˺¦Öµ£¬Ò»°ãÓÃÓÚƮѪ
        self._realHurtHP = 0 # ÕæʵÉËѪֵ£¬±»³ÐÉ˶ֿܵۺóµÄ¿ÉÉËѪµÄÖµ
        self._lostHP = 0 # ʵ¼ÊµôѪֵ
        self._curHP = 0 # ¸üÐÂѪÁ¿
        self._suckHP = 0 # ÎüѪÁ¿
        self._bounceHP = 0 # ·´µ¯ÑªÁ¿
        return
    
    def GetObjID(self): return self._objID
    def SetObjID(self, objID): self._objID = objID
    def GetHurtTypes(self): return self._hurtTypes
    def SetHurtTypes(self, hurtTypes): self._hurtTypes = hurtTypes
    def AddHurtType(self, hurtType):
        ## Ìí¼ÓÉËѪÀàÐÍ£¬µ¥´ÎÉ˺¦Ö§³Ö¶àÖÖÀàÐÍͬʱ³öÏÖ
        self._hurtTypes |= pow(2, hurtType)
        return
    def HaveHurtType(self, hurtType):
        ## ÅжÏÊÇ·ñ´æÔÚijÖÖÉËѪÀàÐÍ
        return self._hurtTypes & pow(2, hurtType) 
    def GetHurtHP(self): return self._hurtHP
    def SetHurtHP(self, hurtHP): self._hurtHP = hurtHP
    def GetRealHurtHP(self): return self._realHurtHP
    def SetRealHurtHP(self, realHurtHP): self._realHurtHP = realHurtHP
    def GetLostHP(self): return self._lostHP
    def SetLostHP(self, lostHP): self._lostHP = lostHP
    def GetCurHP(self): return self._curHP
    def SetCurHP(self, curHP): self._curHP = curHP
    def GetSuckHP(self): return self._suckHP
    def SetSuckHP(self, suckHP): self._suckHP = suckHP
    def GetBounceHP(self): return self._bounceHP
    def SetBounceHP(self, bounceHP): self._bounceHP = bounceHP
    
class SkillEffect():
    
    def __init__(self, effID, values, triggerWay=0, triggerSrc=0):
        self._effID = effID
        self._values = values
        self._triggerWay = triggerWay
        self._triggerSrc = triggerSrc
        #self._triggerParams = triggerParams if triggerParams else []
        return
    
    def GetEffectID(self): return self._effID
    def GetEffectValue(self, index): return self._values[index] if len(self._values) > index else 0
    def GetEffectValueCount(self): return len(self._values)
    def GetTriggerWay(self): return self._triggerWay
    def GetTriggerSrc(self): return self._triggerSrc
    #def GetTriggerParams(self, index): return self._triggerParams[index] if len(self._triggerParams) > index else 0
    
EmptyEffect = SkillEffect(0, [])

class SklllData():
    
    def __init__(self, ipyData):
        self._ipyData = ipyData
        self._effList = [] # [Effect, ...]
        self._effDict = {} # {(effID, triggerWay):Effect, ...} £¬È·±£Î¨Ò»£¬Í¬¸ö¼¼ÄÜ¿ÉÄÜÅäÖÃÏàͬµÄЧ¹ûID
        for num in range(1, 1 + 3):
            effID = getattr(ipyData, "GetEffectID%s" % num)()
            values = getattr(ipyData, "GetEffectValues%s" % num)()
            triggerWay = getattr(ipyData, "GetTriggerWay%s" % num)()
            triggerSrc = getattr(ipyData, "GetTriggerSrc%s" % num)()
            #triggerParams = getattr(ipyData, "GetTriggerParams%s" % num)()
            effect = ObjPool.GetPoolMgr().acquire(SkillEffect, effID, values, triggerWay, triggerSrc)
            self._effList.append(effect)
            self._effDict[(effID, triggerWay)] = effect
        return
    
    def GetIpyData(self): return self._ipyData
    def GetSkillID(self): return self._ipyData.GetSkillID()
    def GetSkillTypeID(self): return self._ipyData.GetSkillTypeID()
    def GetSkillLV(self): return self._ipyData.GetSkillLV()
    def GetSkillMaxLV(self): return self._ipyData.GetSkillMaxLV()
    def GetSkillName(self): return self._ipyData.GetSkillName()
    def GetFuncType(self): return self._ipyData.GetFuncType()
    def GetSkillType(self): return self._ipyData.GetSkillType()
    def GetHurtType(self): return self._ipyData.GetHurtType()
    def GetAtkType(self): return self._ipyData.GetAtkType()
    def GetTagAim(self): return self._ipyData.GetTagAim() # Ãé׼λÖÃ
    def GetTagFriendly(self): return self._ipyData.GetTagFriendly() # µÐÎÒÄ¿±ê
    def GetTagSelf(self): return self._ipyData.GetTagSelf() # ÊÇ·ñº¬×Ô¼º
    def GetTagAffect(self): return self._ipyData.GetTagAffect() # Ä¿±êϸ·Ö
    def GetTagCount(self): return self._ipyData.GetTagCount() # Ä¿±ê¸öÊý
    def GetCalcType(self): return self._ipyData.GetCalcType()
    def GetSkillPer(self): return self._ipyData.GetSkillPer()
    def GetSkillValue(self): return self._ipyData.GetSkillValue()
    def GetHappenRate(self): return self._ipyData.GetHappenRate() # ´¥·¢¸ÅÂÊ
    def GetEffect(self, index): return self._effList[index] if len(self._effList) > index else 0
    def GetEffectCount(self): return len(self._effList)
    def GetEffectByID(self, effID, triggerWay=0): return self._effDict.get((effID, triggerWay), EmptyEffect)
    def GetConnSkill(self): return self._ipyData.GetConnSkill()
    def GetCoolDownTime(self): return self._ipyData.GetCoolDownTime()
    def GetIgnoreStates(self): return self._ipyData.GetIgnoreStates() # ÎÞÊÓÏÞÖÆÁбí
    def GetCurBuffState(self): return self._ipyData.GetCurBuffState()
    def GetLastTime(self): return self._ipyData.GetLastTime() # ³ÖÐøʱ¼ä
    def GetLayerCnt(self): return self._ipyData.GetLayerCnt()
    def GetLayerMax(self): return self._ipyData.GetLayerMax()
    def GetBuffRepeat(self): return self._ipyData.GetBuffRepeat() # Buffµþ¼Ó¹æÔò
    def GetDieContinue(self): return self._ipyData.GetDieContinue() # BuffËÀÍö´æÔÚ
    def GetFightPower(self): return self._ipyData.GetFightPower()
    def GetSkillMotionName(self): return self._ipyData.GetSkillMotionName()
    
class PyBuff():
    
    def __init__(self, ipyData):
        self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)
        self._buffID = 0
        self._ownerID = 0
        self._layer = 0
        self._calcTime = 0
        self._remainTime = 0
        self._value1 = 0 # ÖµÐèҪ֪ͨǰ¶Ë£¬¿ª·¢Ê±×¢Òâ20ÒÚÎÊÌâ
        self._value2 = 0
        self._value3 = 0
        return
    
    def GetSkillData(self): return self._skillData
    def GetSkillID(self): return self._skillData.GetSkillID()
    def GetBuffID(self): return self._buffID
    def SetBuffID(self, buffID): self._buffID = buffID
    def GetOwnerID(self): return self._ownerID
    def SetOwnerID(self, ownerID): self._ownerID = ownerID
    def GetLayer(self): return self._layer
    def SetLayer(self, layer): self._layer = layer
    def GetCalcTime(self): return self._calcTime
    def SetCalcTime(self, calcTime): self._calcTime = calcTime
    def GetRemainTime(self): return self._remainTime
    def SetRemainTime(self, remainTime): self._remainTime = remainTime
    def SetBuffValueList(self, valueList):
        for index, value in enumerate(valueList):
            if index == 0:
                self.SetValue1(value)
            elif index == 1:
                self.SetValue2(value)
            elif index == 2:
                self.SetValue3(value)
    def GetValue1(self): return self._value1
    def SetValue1(self, value): self._value1 = value
    def GetValue2(self): return self._value2
    def SetValue2(self, value): self._value2 = value
    def GetValue3(self): return self._value3
    def SetValue3(self, value): self._value3 = value
    
class BuffManager():
    ## Õ½¶·¶ÔÏóbuff¹ÜÀíÆ÷
    
    def __init__(self, batObj):
        self._batObj = batObj
        self._buffList = [] # [PyBuff, ...]
        self._buffIDDict = {} # {buffID:PyBuff, ...}
        self._skillTypeIDBuffIDs = {} # ¼¼ÄÜTypeID¶ÔÓ¦µÄbuff {skillTypeID:[buffID, ...], ...}
        self._buffStateDict = {} # buffÓ°ÏìµÄ״̬ {state:[buffID, ...], ...}
        self._buffID = 0 # ¸Ã¶ÔÏóµÄΨһbuffID£¬µÝÔö£¬²»Í¬¶ÔÏóbuffID¿ÉÖظ´£¬buffID·ÇskillID£¬²»Í¬buffIDµÄskillID¿ÉÄÜÒ»Ñù
        # ¸ÃÏîÄ¿É趨ͬһ¸ö¶ÔÏó¿ÉÄÜͬʱ´æÔÚ¶à¸öÏàͬskillIDµÄbuff£¬¶ÀÁ¢ËãCD
        return
    
    def ClearBuff(self):
        poolMgr = ObjPool.GetPoolMgr()
        for buff in self._buffList:
            poolMgr.release(buff)
        self._buffList = []
        self._buffIDDict = {}
        self._skillTypeIDBuffIDs = {}
        self._buffID = 0
        return
    
    def GetBuffCount(self): return len(self._buffList)
    def GetBuffByIndex(self, index): return self._buffList[index]
    
    def AddBuff(self, skillID):
        buff = None
        ipyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
        if not ipyData:
            return buff
        skillTypeID = ipyData.GetSkillTypeID()
        self._buffID += 1
        
        buffID = self._buffID
        buff = ObjPool.GetPoolMgr().acquire(PyBuff, ipyData)
        buff.SetBuffID(buffID)
        
        self._buffList.append(buff)
        self._buffIDDict[buffID] = buff
        #GameWorld.DebugLog("ObjBuff:%s, AddBuff buffID=%s, %s, %s, %s, %s, %s" % (self._batObj.GetID(), buffID, buff, len(self._buffList), len(self._buffIDDict), self._buffList, self._buffIDDict))
        if skillTypeID not in self._skillTypeIDBuffIDs:
            self._skillTypeIDBuffIDs[skillTypeID] = []
        buffIDs = self._skillTypeIDBuffIDs[skillTypeID]
        if buffID not in buffIDs:
            buffIDs.append(buffID)
            
        return buff
    
    def DelBuff(self, buffID, release=True):
        if buffID not in self._buffIDDict:
            #GameWorld.DebugLog("ObjBuff:%s, DelBuff not in self._buffIDDict, buffID=%s, %s" % (self._batObj.GetID(), buffID, self._buffIDDict.keys()))
            return
        #GameWorld.DebugLog("ObjBuff:%s, DelBuff %s, buffID=%s, dict:%s, len:%s, list:%s" % (self._batObj.GetID(), release, buffID, self._buffIDDict, len(self._buffList), self._buffList))
        buff = self._buffIDDict.pop(buffID)
        if buff in self._buffList:
            self._buffList.remove(buff)
        else:
            # ·À·¶ÏÂÕÒ²»µ½µÄÇé¿ö
            for lBuff in self._buffList[::-1]:
                if lBuff.GetBuffID() == buffID:
                    self._buffList.remove(lBuff)
                    GameWorld.ErrLog("ɾ³ýbuffÒì³£²»ÔÚÁбíÀï! buffID=%s,lBuff=%s,buff=%s" % (buffID, lBuff, buff))
        #GameWorld.DebugLog("    ObjBuff:%s, buffID=%s, dict:%s, len:%s, dictKeys:%s, list:%s" % (self._batObj.GetID(), buffID, len(self._buffIDDict), len(self._buffList), self._buffIDDict.keys(), self._buffList))
        for skillTypeID, buffIDList in self._skillTypeIDBuffIDs.items():
            if buffID not in buffIDList:
                continue
            buffIDList.remove(buffID)
            if not buffIDList:
                self._skillTypeIDBuffIDs.pop(skillTypeID)
            break
        if release:
            ObjPool.GetPoolMgr().release(buff)
        return
    
    def GetBuff(self, buffID): return self._buffIDDict.get(buffID, None)
    def FindBuffBySkillID(self, skillID):
        ## ·µ»Ø¸Ã¼¼ÄÜIDµÄËùÓÐbuffÁбí
        skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
        if not skillData:
            return []
        return self.FindBuffBySkillTypeID(skillData.GetSkillTypeID())
    def FindBuffBySkillTypeID(self, skillTypeID):
        ## ·µ»Ø¸Ã¼¼ÄÜTypeIDµÄËùÓÐbuffÁбí
        if skillTypeID not in self._skillTypeIDBuffIDs:
            return []
        buffs = []
        for buffID in self._skillTypeIDBuffIDs[skillTypeID]:
            if buffID not in self._buffIDDict:
                continue
            buffs.append(self._buffIDDict[buffID])
        return buffs
    
    def AddBuffState(self, state, buffID):
        ## Ìí¼ÓbuffÓ°ÏìµÄ״̬£¬ChConfig.BatObjStateList
        if state not in self._buffStateDict:
            self._buffStateDict[state] = []
        buffIDList = self._buffStateDict[state]
        if buffID not in buffIDList:
            buffIDList.append(buffID)
        GameWorld.DebugLog("    AddBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))
        return
    
    def DelBuffState(self, state, buffID):
        ## ɾ³ýbuffÓ°ÏìµÄ״̬
        if state not in self._buffStateDict: return
        buffIDList = self._buffStateDict[state]
        if buffID not in buffIDList:
            return
        buffIDList.remove(buffID)
        if not buffIDList:
            self._buffStateDict.pop(state)
        GameWorld.DebugLog("    DelBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))
        return
    
    def IsInBuffState(self, state): return state in self._buffStateDict ## ÊÇ·ñ´¦ÓÚijÖÖ״̬ÏÂ
    def GetStateBuffIDList(self, state): return self._buffStateDict.get(state, []) # »ñȡijÖÖ״̬µÄËùÓÐbuffIDÁбí
    
class PySkill():
    
    def __init__(self, ipyData):
        self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)
        self._calcTime = 0
        self._remainTime = 0
        self._batType = 0 # Õ½¶·ÀàÐÍ£¬ÆÕͨ¡¢Á¬»÷¡¢·´»÷¡¢×·»÷µÈ
        self._tagObjList = [] # ±¾´Î¼¼ÄÜÄ¿±êÁбí [BatObj, ...]
        self._hurtList = [] # ±¾´ÎÉËѪÁÐ±í£¬¿ÉÄÜͬһ¸ö¶ÔÏóÓжà¸öÉ˺¦£¬È絯ÉäµÈ [HurtObj, ...]
        self._bySkill = None # ÓÉÄĸö¼¼ÄÜ´¥·¢µÄ
        self._afterLogicList = [] # ¼¼ÄÜÊͷźóÐèÒª´¦ÀíÂß¼­ [[logicType, logicParams], ...]
        return
    
    def ResetUseRec(self):
        self._batType = 0
        self._tagObjList = []
        self._bySkill = None
        self._afterLogicList = []
        self.ClearHurtObj()
        return
    
    def GetSkillID(self): return self._skillData.GetSkillID()
    def GetSkillTypeID(self): return self._skillData.GetSkillTypeID()
    def GetSkillLV(self): return self._skillData.GetSkillLV()
    def GetSkillMaxLV(self): return self._skillData.GetSkillMaxLV()
    def GetSkillName(self): return self._skillData.GetSkillName()
    def GetFuncType(self): return self._skillData.GetFuncType()
    def GetSkillType(self): return self._skillData.GetSkillType()
    def GetHurtType(self): return self._skillData.GetHurtType()
    def GetAtkType(self): return self._skillData.GetAtkType()
    def GetTagAim(self): return self._skillData.GetTagAim() # Ãé׼λÖÃ
    def GetTagFriendly(self): return self._skillData.GetTagFriendly() # µÐÎÒÄ¿±ê
    def GetTagSelf(self): return self._skillData.GetTagSelf() # ÊÇ·ñº¬×Ô¼º
    def GetTagAffect(self): return self._skillData.GetTagAffect() # Ä¿±êϸ·Ö
    def GetTagCount(self): return self._skillData.GetTagCount() # Ä¿±ê¸öÊý
    def GetCalcType(self): return self._skillData.GetCalcType()
    def GetSkillPer(self): return self._skillData.GetSkillPer()
    def GetSkillValue(self): return self._skillData.GetSkillValue()
    def GetHappenRate(self): return self._skillData.GetHappenRate() # ´¥·¢¸ÅÂÊ
    def GetEffect(self, index): return self._skillData.GetEffect(index)
    def GetEffectCount(self): return self._skillData.GetEffectCount()
    def GetEffectByID(self, effID, triggerWay=0): return self._skillData.GetEffectByID(effID, triggerWay)
    def GetConnSkill(self): return self._skillData.GetConnSkill()
    def GetCoolDownTime(self): return self._skillData.GetCoolDownTime()
    def GetIgnoreStates(self): return self._skillData.GetIgnoreStates() # ÎÞÊÓÏÞÖÆÁбí
    def GetCurBuffState(self): return self._skillData.GetCurBuffState()
    def GetLastTime(self): return self._skillData.GetLastTime() # ³ÖÐøʱ¼ä
    def GetLayerCnt(self): return self._skillData.GetLayerCnt()
    def GetLayerMax(self): return self._skillData.GetLayerMax()
    def GetBuffRepeat(self): return self._skillData.GetBuffRepeat() # Buffµþ¼Ó¹æÔò
    def GetDieContinue(self): return self._skillData.GetDieContinue() # BuffËÀÍö´æÔÚ
    def GetFightPower(self): return self._skillData.GetFightPower()
    def GetSkillMotionName(self): return self._skillData.GetSkillMotionName()
    
    ## ---------------------------------- ·Ç¼¼ÄܱíÄÚÈÝ ----------------------------------
    def GetCalcTime(self): return self._calcTime
    def SetCalcTime(self, calcTime): self._calcTime = calcTime
    def GetRemainTime(self): return self._remainTime
    def SetRemainTime(self, remainTime): self._remainTime = remainTime
    def GetBatType(self): return self._batType
    def SetBatType(self, batType): self._batType = batType
    def GetBySkill(self): return self._bySkill
    def SetBySkill(self, bySkill): self._bySkill = bySkill
    def GetTagObjList(self): return self._tagObjList # ¼¼ÄÜÄ¿±êÁбí
    def SetTagObjList(self, tagObjList): self._tagObjList = tagObjList
    def GetAfterLogicList(self): return self._afterLogicList
    def AddAfterLogic(self, logicType, logicData):
        '''Ìí¼Ó¼¼ÄÜÊͷźóÐèÒª´¦Àí¶îÍâÂß¼­
        @param logicType: Âß¼­ÀàÐÍ
        @param logicData: Âß¼­¶ÔÓ¦µÄÊý¾Ý
        '''
        self._afterLogicList.append([logicType, logicData])
        return
    def ClearHurtObj(self):
        ## Çå¿ÕÉËѪͳ¼Æ
        poolMgr = ObjPool.GetPoolMgr()
        for hurtObj in self._hurtList:
            poolMgr.release(hurtObj)
        self._hurtList = []
        return
    def AddHurtObj(self, tagID):
        ## Ìí¼Óij¸öÉËѪ
        hurtObj = ObjPool.GetPoolMgr().acquire(HurtObj)
        hurtObj.SetObjID(tagID)
        self._hurtList.append(hurtObj)
        return hurtObj
    def GetHurtObjList(self): return self._hurtList
    
class SkillManager():
    ## Õ½¶·¶ÔÏó¼¼ÄܹÜÀíÆ÷
    
    def __init__(self):
        self._skillList = [] # ¼¼ÄÜÁбí [PySkill, ...]
        self._skillDict = {} # {skillID:PySkill, ...}
        return
    
    def SkillReset(self):
        poolMgr = ObjPool.GetPoolMgr()
        for skill in self._skillList:
            poolMgr.release(skill)
        self._skillList = []
        self._skillDict = {}
        return
    
    def GetSkillCount(self): return len(self._skillList)
    def GetSkillByIndex(self, index): return self._skillList[index]
    def GetSkillIDList(self): return self._skillDict.keys()
    def FindSkillByID(self, skillID): return self._skillDict.get(skillID, None)
    def FindSkillByTypeID(self, skillTypeID):
        skill = None
        for s in self._skillList:
            if s.GetSkillTypeID() == skillTypeID:
                skill = s
                break
        return skill
    
    def LearnSkillByID(self, skillID):
        ipyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
        if not ipyData:
            return
        if skillID in self._skillDict:
            return
        skillTypeID = ipyData.GetSkillTypeID()
        curSkill = self.FindSkillByTypeID(skillTypeID)
        if curSkill:
            if curSkill.GetSkillID() >= skillID:
                return
            self.__deleteSkill(curSkill)
            
        # ѧм¼ÄÜ
        curSkill = ObjPool.GetPoolMgr().acquire(PySkill, ipyData)
        self._skillDict[skillID] = curSkill
        self._skillList.append(curSkill)
        return curSkill
    
    def __deleteSkill(self, curSkill):
        skillID = curSkill.GetSkillID()
        self._skillDict.pop(skillID, None)
        if curSkill in self._skillList:
            self._skillList.remove(curSkill)
        ObjPool.GetPoolMgr().release(curSkill)
        return
    
class BatObj():
    ## Õ½¶·ÊµÌå¶ÔÏóÊý¾Ý£¬Ä¿Ç°Óëij¸öNPCObj°ó¶¨
    
    def __init__(self):
        self.tfGUID = "" # ËùÊôµÄij³¡»ØºÏÕ½¶·µÄguid
        self.ownerID = 0 # ËùÊôÍæ¼ÒID£¬¿ÉÄÜΪ0£¬0´ú±í·ÇÍæ¼ÒµÄÕ½¶·ÊµÌå
        self.objID = 0
        self.objName = ""
        self.npcID = 0
        self.heroID = 0
        self.skinID = 0
        self.country = 0
        self.atkDistType = 0
        self.sex = 0
        self.lv = 1
        self.fightPower = 0
        self.faction = 0 # ËùÊôÕóÓª£¬Ò»°ãÖ»ÓÐË«·½ÕóÓª£¬ 1 »ò 2£¬·¢Æð·½Ä¬ÈÏ1
        self.lineupNum = 1 # ÕóÈÝλÖñàºÅ£¬Ò»°ã¶àV¶àʱÓÐÓã¬Í¨³£Ä¬ÈÏ1
        self.posNum = 0 # ËùÔÚÕóÈÝվλ
        self._hp = 0 # µ±Ç°ÉúÃüÖµ
        self._xp = 0 # µ±Ç°Å­ÆøÖµ
        self._isAlive = True # ÊÇ·ñ»î×Å
        self._initAttrDict = {} # ³õʼ»¯Ê±µÄÊôÐÔ£¬¹Ì¶¨²»±ä£¬³õʼ»¯Ê±ÒѾ­ËãºÃµÄÊôÐÔ  {attrID:value, ...}
        self._batAttrDict = {} # ʵ¼ÊÕ½¶·ÊôÐÔ£¬°üº¬buff²ã¼¶µÄʵ¼ÊÊôÐÔ
        self._skillTempAttrDict = {} # ij´Î¼¼ÄÜÊÍ·ÅÖÐÁÙʱµÄÊôÐÔÔö¼õ {attrID:+-value, ...}
        self._kvDict = {} # ×Ô¶¨Òåkv×Öµä
        self._skillUseCntDict = {} # ¼¼ÄÜÀÛ¼ÆʹÓôÎÊý {skillID:useCnt, ...}
        self._skillTurnUseCntDict = {} # ¼¼Äܵ¥»ØºÏÀÛ¼ÆʹÓôÎÊý {skillID:useCnt, ...}
        self._skillMgr = ObjPool.GetPoolMgr().acquire(SkillManager)
        self._buffMgr = ObjPool.GetPoolMgr().acquire(BuffManager, self)
        self._passiveEffMgr = ObjPool.GetPoolMgr().acquire(PassiveEffManager, self)
        
        # ͳ¼Æ
        self.hurtStat = 0 # Êä³öͳ¼Æ
        self.defStat = 0 # ³ÐÉËͳ¼Æ
        self.cureStat = 0 # ÖÎÁÆͳ¼Æ
        return
    
    def InitBatAttr(self, initAttrDict, initXP=0):
        '''³õʼ»¯Õ½¶·ÊôÐÔ
        @param initAttrDict: ÒѾ­ËãºÃµÄÔÚÕóÈÝÖеÄÊôÐÔ£¬°üº¬î¿°í¡¢ÕóÈÝÊôÐԵȣ¬Õ½¶·ÖÐÖ»Òª¼ÆËãbuffÊôÐÔ¼´¿É
        @param initXP: ³õʼ»¯µÄÅ­ÆøÖµ
        '''
        self._initAttrDict = initAttrDict
        self._batAttrDict = {}
        self._batAttrDict.update(initAttrDict)
        self._skillTempAttrDict = {}
        self._xp = initXP
        self._hp = initAttrDict.get(ChConfig.AttrID_MaxHP, 1)
        TurnBuff.RefreshBuffAttr(self)
        TurnPassive.RefreshPassive(self)
        return
    
    def UpdInitBatAttr(self, initAttrDict, skillIDList):
        ## ¸üÐÂÕ½¶·ÊôÐÔ£¬Ò»°ãÖ»ÓÐÖ÷ÕóÈÝÐèÒª¸üУ¬Õ½¶·ÖÐÑø³É¡¢×°±¸±ä»¯µÈÒýÆðµÄÖ÷ÕóÈÝÊôÐÔ±ä¸üʱÐèҪʵʱ¸üÐÂ
        self._initAttrDict = initAttrDict
        learnNewSkill = False
        for skillID in skillIDList:
            if self._skillMgr.LearnSkillByID(skillID):
                learnNewSkill = True
        TurnBuff.RefreshBuffAttr(self)
        if learnNewSkill: # ÓÐѧм¼ÄÜʱÖØË¢¼¼Äܱ»¶¯
            self._passiveEffMgr.RefreshSkillPassiveEffect()
        return
    
    def ResetBattleEffect(self):
        self._batAttrDict = {}
        self._batAttrDict.update(self._initAttrDict)
        return self._batAttrDict
    
    def GetTFGUID(self): return self.tfGUID # ËùÊôµÄij³¡Õ½¶·
    def SetTFGUID(self, tfGUID): self.tfGUID = tfGUID
    def GetTurnFight(self): return TurnAttack.GetTurnFightMgr().getTurnFight(self.tfGUID)
    def GetOwnerID(self): return self.ownerID # Èç¹ûÊÇÍæ¼ÒÕ½¶·µ¥Î»£¬Ôò¸ÃÖµ·Ç0£¬ÎªËùÊôÍæ¼ÒID
    def SetOwnerID(self, ownerID): self.ownerID = ownerID
    def GetID(self): return self.objID
    def GetName(self): return self.objName
    def SetName(self, name): self.objName = name
    def GetCountry(self): return self.country
    def SetCountry(self, country): self.country = country
    def GetAtkDistType(self): return self.atkDistType
    def SetAtkDistType(self, atkDistType): self.atkDistType = atkDistType
    def GetSex(self): return self.sex
    def SetSex(self, sex): self.sex = sex
    def GetNPCID(self): return self.npcID # Èç¹ûÊÇNPCÕ½¶·µ¥Î»£¬Ôò¸ÃÖµ·Ç0
    def SetNPCID(self, npcID): self.npcID = npcID # ÉèÖÃËùÊôµÄNPCID
    def GetHeroID(self): return self.heroID
    def GetSkinID(self): return self.skinID # ½öÍæ¼ÒÓÐÖµ£¬Î佫Ƥ·ô
    def SetHero(self, heroID, skinID=0): # ÉèÖÃËùÊôÎ佫
        self.heroID = heroID
        self.skinID = skinID
    def SetLineupPos(self, posNum, lineupNum=1):
        ## ÉèÖÃÕóÈÝËùÔÚλÖÃ
        # @param posNum: ÔÚ±¾ÕóÈÝÖеÄվλ
        # @param lineupNum: ±¾ÕóÈÝÔÚ±¾ÕóÓªÖеÄվ룬һ°ã¶àV¶àʱÓÐÓã¬Ä¬ÈÏ1
        self.posNum = posNum
        self.lineupNum = lineupNum
    def GetLineupNum(self): return self.lineupNum
    def GetPosNum(self): return self.posNum
    def GetFaction(self): return self.faction
    def SetFaction(self, faction): self.faction = faction
    def GetFightPower(self): return self.fightPower
    def SetFightPower(self, fightPower): self.fightPower = fightPower
    def GetLV(self): return self.lv
    def SetLV(self, lv): self.lv = lv
    def GetDictByKey(self, key): return self._kvDict.get(key, 0)
    def SetDict(self, key, value): self._kvDict[key] = value
    
    def GetSkillManager(self): return self._skillMgr
    def GetBuffManager(self):return self._buffMgr
    def GetPassiveEffManager(self):return self._passiveEffMgr
    
    def GetCanAttack(self):
        ## ¿É·ñ±»¹¥»÷
        # ÎÞµÐbuff
        #if ÎÞµÐ:
        #    return False
        return True
    
    def IsInState(self, state):
        ## ÊÇ·ñ´¦ÓÚijÖÖ״̬ÏÂ
        return self._buffMgr.IsInBuffState(state)
    
    def IsInControlled(self):
        ## ÊÇ·ñ±»¿ØÖÆÖÐ
        for state in ChConfig.InControlledStateList:
            if self.IsInState(state):
                return True
        return False
    
    def CanAction(self):
        ## ÊÇ·ñ¿ÉÒÔÐж¯
        if not self.IsAlive():
            return False
        if self.IsInControlled():
            return False
        return True
    
    def GetSneerTagObj(self):
        ## »ñÈ¡±»³°·íµÄÄ¿±ê£¬Èç¹û´æÔÚÔòÒ»¶¨ÊÇ»î×ŵÄÄ¿±ê
        buffIDList = self._buffMgr.GetStateBuffIDList(ChConfig.BatObjState_Sneer)
        if not buffIDList:
            return
        objMgr = GetBatObjMgr()
        for buffID in buffIDList:
            buff = self._buffMgr.GetBuff(buffID)
            if not buff:
                continue
            tagObj = objMgr.getBatObj(buff.GetOwnerID())
            if tagObj and tagObj.IsAlive(): # »î×ŲÅÓÐЧ
                return tagObj
        return
    
    # Õ½¶·ÊôÐÔ
    def IsAlive(self): return self._isAlive # ÊÇ·ñ»î×Å
    def SetDead(self):
        self._isAlive = False
        self._hp = 0
    def GetMaxHP(self): return self._batAttrDict.get(ChConfig.AttrID_MaxHP, 0)
    def SetMaxHP(self, maxHP, isNotify=False):
        self._batAttrDict[ChConfig.AttrID_MaxHP] = maxHP
        if isNotify:
            NotifyObjInfoRefresh(self, ChConfig.AttrID_MaxHP, maxHP)
        return
    def GetHP(self): return self._hp
    def SetHP(self, hp, isNotify=False):
        self._hp = hp
        if isNotify:
            NotifyObjInfoRefresh(self, ChConfig.AttrID_HP, hp)
        return
    def SetHPFull(self, isNotify=True): self.SetHP(self.GetMaxHP(), isNotify)
    def GetXP(self): return self._xp
    def SetXP(self, xp, isNotify=True):
        self._xp = xp
        if isNotify:
            NotifyObjInfoRefresh(self, ChConfig.AttrID_XP, xp)
        return
    def GetAtk(self): return self.GetBatAttrValue(ChConfig.AttrID_Atk)
    def GetDef(self): return self.GetBatAttrValue(ChConfig.AttrID_Def)
    
    def GetBatAttrValue(self, attrID, includeTemp=True):
        #ChConfig.AttrID_HP ChConfig.AttrID_XP
        value = self._batAttrDict.get(attrID, 0)
        if includeTemp and attrID in self._skillTempAttrDict:
            value += self._skillTempAttrDict[attrID] # Ö§³ÖÕý¸ºÖµ
            value = max(1, value)
        return value
    def SetBatAttrValue(self, attrID, value): self._batAttrDict[attrID] = value
    def AddSkillTempAttr(self, attrID, value):
        ## Ôö¼Ó¼¼ÄÜÁÙʱÊôÐÔ£¬Ö§³ÖÕý¸ºÖµ
        # @param value: ÕýÖµ-¼ÓÊôÐÔ£»¸ºÖµ-¼õÊôÐÔ
        self._skillTempAttrDict[attrID] = self._skillTempAttrDict.get(attrID, 0) + value
    def ClearSkillTempAttr(self): self._skillTempAttrDict = {}
    
    def GetSkillUseCnt(self, skillID): return self._skillUseCntDict.get(skillID, 0)
    def GetSkillTurnUseCnt(self, skillID): return self._skillTurnUseCntDict.get(skillID, 0)
    def AddSkillUseCnt(self, skillID):
        self._skillUseCntDict[skillID] = self._skillUseCntDict.get(skillID, 0) + 1
        self._skillTurnUseCntDict[skillID] = self._skillTurnUseCntDict.get(skillID, 0) + 1
        
    def StatHurtValue(self, hurtValue):
        ## ͳ¼ÆÊä³ö
        self.hurtStat += hurtValue
        return self.hurtStat
    
    def StatDefValue(self, lostHP):
        ## ͳ¼Æ³ÐÉË
        self.defStat += lostHP
        return self.defStat
    
    def StatCureValue(self, cureValue):
        ## ͳ¼ÆÖÎÁÆ
        self.cureStat += cureValue
        return self.cureStat
    
    def TurnReset(self):
        ## »ØºÏÖØÖÃ
        self._skillTurnUseCntDict = {}
    
class BattleObjMgr():
    ## Õ½¶·¶ÔÏó¹ÜÀíÆ÷
    
    def __init__(self):
        self._newID = 0 # ¹ÜÀí´´½¨ÐµÄʵÀýID
        self._freeIDList = []
        self.batObjDict = {} # Õ½¶·µ¥Î» {objID:BatObj, ...}
        return
    
    def __getNewObjID(self):
        while self._freeIDList:
            objID = self._freeIDList.pop(0)
            if objID not in self.batObjDict:
                return objID
            
        maxID = 100000
        if self._newID >= maxID:
            self._newID = 0
        while self._newID < maxID:
            self._newID += 1
            if self._newID not in self.batObjDict:
                return self._newID
        GameWorld.ErrLog("__getNewObjID error.")
        return 0
    
    def addBatObj(self):
        ## Ìí¼ÓÕ½¶·µ¥Î»
        newBatObj = None
        newObjID = self.__getNewObjID()
        if not newObjID:
            return newBatObj
        newBatObj = ObjPool.GetPoolMgr().acquire(BatObj)
        newBatObj.objID = newObjID
        self.batObjDict[newObjID] = newBatObj
        GameWorld.DebugLog("Ìí¼ÓÕ½¶·µ¥Î»: objID=%s" % (newObjID))
        if False:
            newBatObj = BatObj(None, 0)
        return newBatObj
    
    def getBatObj(self, objID):
        batObj = None
        if objID in self.batObjDict:
            batObj = self.batObjDict[objID]
        elif False:
            batObj = BatObj(None, 0)
        return batObj
    
    def delBatObj(self, objID):
        if objID not in self.batObjDict:
            return
        batObj = self.batObjDict.pop(objID)
        if not batObj:
            return
        objID = batObj.objID
        GameWorld.DebugLog("»ØÊÕÕ½¶·µ¥Î»: objID=%s" % (objID))
        turnFight = batObj.GetTurnFight()
        if turnFight:
            # //04 07 NPCÏûʧ#tagNPCDisappear ´Ë´¦Í¨ÖªÏûʧ£¬Óë»ØºÏÖÆËÀÍöÇø·Ö
            clientPack = ChNetSendPack.tagNPCDisappear()
            clientPack.NPCID = [objID]
            clientPack.Count = len(clientPack.NPCID)
            turnFight.addBatPack(clientPack)
            
        # ×îºó»ØÊÕ¶ÔÏó
        ObjPool.GetPoolMgr().release(batObj)
        if objID not in self._freeIDList: # »ØÊÕID£¬Öظ´ÀûÓÃ
            self._freeIDList.append(objID)
        return
    
def GetBatObjMgr():
    batObjMgr = PyGameData.g_batObjMgr
    if not batObjMgr:
        batObjMgr = BattleObjMgr()
        PyGameData.g_batObjMgr = batObjMgr
    return batObjMgr

def OnMinute():
    GameWorld.Log("Õ½¶·µ¥Î»ÊýÁ¿: %s" % len(GetBatObjMgr().batObjDict))
    return

def NotifyObjInfoRefresh(batObj, attrID, value):
    ##0418֪ͨ¶ÔÏóÊôÐÔË¢ÐÂ
    if attrID not in ChConfig.CDBRefresh_AttrIDDict:
        return
    refreshType, isBig = ChConfig.CDBRefresh_AttrIDDict[attrID]
    turnFight = TurnAttack.GetTurnFightMgr().getTurnFight(batObj.GetTFGUID())
    if not turnFight:
        return
    clientPack = ObjPool.GetPoolMgr().acquire(ChNetSendPack.tagObjInfoRefresh)
    clientPack.ObjID = batObj.GetID()
    clientPack.RefreshType = refreshType
    if isBig:
        clientPack.Value = value % ShareDefine.Def_PerPointValue
        clientPack.ValueEx = value / ShareDefine.Def_PerPointValue
    else:
        clientPack.Value = value
        clientPack.ValueEx = 0
    turnFight.addBatPack(clientPack)
    return