#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package TurnAttack
#
# @todo:»ØºÏÖƹ¥»÷Âß¼­
# @author hxp
# @date 2023-11-30
# @version 1.0
#
# ÏêϸÃèÊö: »ØºÏÖƹ¥»÷Âß¼­£¬¾ùʹÓÃNPCʵÀý×÷Ϊս¶·Ö÷Ìå
#        ʵʱս¶·£º  ½öÓÃÓÚÖ÷Ïߣ¬Ã¿¸öÍæ¼Ò×î¶à½öÔÊÐí´æÔÚÒ»¸öʵʱս¶·
#                    ÓÉÇ°¶Ë¿ØÖÆÕ½¶·Á÷³Ì£¬ºó¶Ë½øÐмÆËã
#        ˲ʱս¶·£º  ÓÃÓÚ·ÇÖ÷ÏßÍâµÄ¸÷ÖÖÕ½¶·£¬È縱±¾PVEÌôÕ½£¬PVPÌôÕ½µÈ£¬Ò»Ñù½öÓÐÒ»¸ö˲ʱս¶·£¬
#                    Ò»´ÎÐÔ´¦ÀíÍ꣬ºó¶Ë¿ØÖÆÕûÌåÕ½¶·Á÷³Ì¼°¼ÆË㣬ǰ¶Ë½ö×öÕ½±¨½âÎö±íÏÖÕ½¶·¹ý³Ì
#
#-------------------------------------------------------------------------------
#"""Version = 2023-11-30 15:30"""
#-------------------------------------------------------------------------------

import ChConfig
import ChPyNetSendPack
import NetPackCommon
import PlayerControl
import GameWorld
import GameObj
import FBCommon
import IpyGameDataPY
import PlayerOnline
import NPCCommon
import ShareDefine
import PyGameData
import ItemControler
import SkillCommon
import AttackCommon
import BattleObj
import TurnSkill
import TurnBuff
import ObjPool

import random
import time
import json

FighterNPCID = 100 # Õ½¶·NPCID£¬½öºó¶ËÓ㬳ý¹ÖÎïÍ⣬ËùÓÐÍæ¼ÒÎ佫¾ùʹÓøÃNPCID
PosNumMax = 10 # ×î´óվλ±àºÅ
ActionNumStart = -1 # ÆðʼÐж¯Î»ÖñàºÅ£¬Ò»°ãÊÇ´Ó1¿ªÊ¼£¬Èç¹ûÓмÓÖ÷¹«¡¢ºìÑÕµÈÔò¿Û³ýÏàӦλÖÃÖµ£¬Èç´Ó0»ò-1¿ªÊ¼

# »ØºÏÕ½¶·Á÷³Ì״̬
(
FightState_Start, # 0 Æðʼ״̬£¬ÎÞÌØÊâÒâÒ壬½ö´ú±í¿ªÊ¼ÁË£¬ÓëOver¶ÔÓ¦
FightState_PrepareOK, # 1 ×¼±¸Íê±Ï£¬°üº¬¶ÔÕ½NPCÕÙ»½OK¡¢ÆäËûµÈ
FightState_Fighting, # 2 Õ½¶·ÖÐ
FightState_FightEnd, # 3 Õ½¶·½áÊø
FightState_Award, # 4 ½áËã½±Àø
FightState_Over, # 5 ½áÊø״̬£¬ÎÞÌØÊâÒâÒ壬½ö´ú±íËùÓд¦Àí½áÊøÁË£¬ÓëStart¶ÔÓ¦
) = range(6)
    
class BatLineup():
    ## Õ½¶·ÕóÈÝ
    
    def __init__(self, faction, num, turnFight):
        self.turnFight = turnFight # TurnFight
        self.faction = faction # ËùÊôÕóÓª
        self.num = num # ¸ÃÕóÈÝËùÔÚÕóÓªÖеıàºÅ£¬²»Í¬ÕóÓª¿ÉÖظ´£¬¶àV¶à
        self.ownerID = 0 # ÕóÈÝËùÊôÍæ¼ÒID£¬¿ÉÄÜΪ0£¬0´ú±í·ÇÍæ¼ÒÕóÈÝ
        self.shapeType = 0 # ÕóÐÍ
        self.fightPower = 0 # ÕóÈÝ×ÜÕ½Á¦
        self.posObjIDDict = {} # վλ¶ÔÓ¦Õ½¶·ÊµÌå {վλ±àºÅ:batObjID, ...}, վλ±àºÅСÓÚ0Ϊ·ÇÖ÷Õ½µ¥Î»£¬ÈçÖ÷¹«¡¢ºìÑÕµÈ
        self.actionNum = ActionNumStart # Ðж¯Î»Ö㬴Ó1¿ªÊ¼
        return
    
    def getPlayerID(self): return self.turnFight.playerID # ·¢ÆðµÄÍæ¼ÒID
    
    def isEmpty(self): return not self.posObjIDDict
    
    def setLineup(self, lineupInfo):
        ## ÉèÖÃÕóÈÝ
        # @param lineupInfo: ÕóÈÝÐÅÏ¢
        self.clearLineup()
        self.ownerID = lineupInfo.get("PlayerID", 0) # ÕóÈÝËùÊôµÄÍæ¼ÒID
        self.shapeType = lineupInfo.get("ShapeType", 0)
        self.fightPower = lineupInfo.get("FightPower", 0)
        SummonLineupObjs(self, self.faction, self.num, lineupInfo, self.getPlayerID())
        return
    
    def resetLineup(self, isReborn=True):
        ## ÖØÖÃÕóÈÝ
        batObjMgr = BattleObj.GetBatObjMgr()
        for objID in self.posObjIDDict.values():
            batObj = batObjMgr.getBatObj(objID)
            if not batObj:
                continue
            batObj.ResetBatObj(isReborn)
        return
    
    def clearLineup(self):
        ## Çå³ýÕóÈÝ
        if not self.posObjIDDict:
            return
        batObjMgr = BattleObj.GetBatObjMgr()
        for objID in self.posObjIDDict.values():
            batObjMgr.delBatObj(objID)
        self.posObjIDDict = {}
        self.fightPower = 0
        return
    
class BatFaction():
    ## Õ½¶·ÕóÓª
    
    def __init__(self, faction, turnFight):
        self.turnFight = turnFight # TurnFight
        self.faction = faction
        self.lineupDict = {} # ¸ÃÕóÓªËùÓÐÕóÈÝÐÅÏ¢ {±àºÅ:BatLineup, ...}
        return
    
    def getBatlineup(self, num=1):
        ## »ñÈ¡Õ½¶·ÕóÈÝ
        lineup = None
        if num in self.lineupDict:
            lineup = self.lineupDict[num]
        else:
            lineup = BatLineup(self.faction, num, self.turnFight)
            self.lineupDict[num] = lineup
        return lineup
    
    def resetLineups(self):
        ## ÖØÖÃËùÓÐÕ½¶·ÕóÈÝ
        for lineup in self.lineupDict.values():
            lineup.resetLineup()
        return
    
    def clearLineups(self):
        ## Çå³ýËùÓÐÕ½¶·ÕóÈÝ
        for lineup in self.lineupDict.values():
            lineup.clearLineup()
        return
    
class TurnFight():
    '''ij³¡»ØºÏÕ½¶·£¬Ö§³Ö¶àV¶à£¬ËùÓÐÕ½¶·Í¨Óã¬Ö÷Ïß¡¢ÅÀËþ¡¢PVPµÈ
    ¿ÉÄÜΪϵͳºǫ́·¢ÆðµÄ£¬Ôò¹¥»÷·½¡¢·ÀÊØ·½ÕóÈÝÒÔÍæ¼ÒËù±£´æµÄÕóÈݾµÏñ½øÐÐÕ½¶·
    Èç¹ûÍæ¼Ò·¢ÆðµÄ£¬Ôò¹¥»÷·½Îª·¢Æð·½Íæ¼Ò£¬Ä¿±êΪ·ÀÊØ·½£¬Ö§³Ö¶àV¶à£¬Èç×é¶ÓPK
    ¶àV¶àµÄÇé¿öÒ²ÊÇij¸ö¶ÓÔ±¸÷×Ô·¢ÆðÕ½¶·£¬Ö»ÊÇÓõ½¶ÓÓѵľµÏñÕóÈÝÒ»ÆðÕ½¶·£¬¶ÓÓÑÎÞ¸ÐÖª
    
    ¶àV¶à¿ÉʹÓÃÁ½ÖÖģʽ£º
    1. ¶à¸öÕóÈÝÒ»Æð³ö³¡£¬ÔÚÒ»³¡Õ½¶·ÖÐÍê³É
    2. ÒÔµ¥ÕóÈÝ·½Ê½ÂÖÁ÷³ö³¡Õ½¶·£¬¸Ã·½Ê½Í¬Ñù¿ÉÒÔʹÓ÷½Ê½1µÄÂß¼­ÊµÏÖ£¬¹ÌÓÅÏÈʹÓ÷½Ê½1Õ½¶·Âß¼­£¬·½±ãÀ©Õ¹
    '''
    
    def __init__(self, mapID=0, funcLineID=0, playerID=0, isNeedReport=False):
        self.guid = GameWorld.GetGUID() # ij³¡Õ½¶·µÄΨһguid£¬¿ÉÓÃÓÚ´æ´¢¼Ç¼ÈçÕ½±¨µÈ
        self.playerID = playerID # ¿ÉÄÜΪ0£¬ÏµÍ³ºǫ́×Ô¶¯´¦ÀíµÄÕ½¶·Ê±Îª0£¬Ä³¸öÍæ¼Ò·¢ÆðÔòΪ·¢ÆðÍæ¼ÒID£¬Í¬¸öÍæ¼ÒID¿ÉÄÜͬʱ´æÔڶೡս¶·£¬ÈçÖ÷Ïß+ÆäËû
        self.curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID) if playerID else None
        self.mapID = mapID
        self.funcLineID = funcLineID
        self.turnNum = 1 # µ±Ç°µÚx»ØºÏ£¬Ä¬ÈϵÚ1»ØºÏ¿ªÊ¼
        self.turnMax = 15 # ×î´ó»ØºÏÊý
        self.enterLogic = False # ÊÇ·ñÒÑÖ´Ðнø³¡Âß¼­
        self.turnStart = 0 # ÒÑÖ´ÐлغϿªÊ¼Öµ£¬ÈçµÚ1»ØºÏ¿ªÊ¼ÒÑÖ´ÐÐÔòΪ1£¬µÚ2»ØºÏΪ2
        self.turnEnd = 0 # ÒÑÖ´ÐлغϽáÊøÖµ£¬ÈçµÚ1»ØºÏ½áÊøÒÑÖ´ÐÐÔòΪ1£¬µÚ2»ØºÏΪ2
        self.winFaction = 0 # ±¾³¡Õ½¶·½áÊø±ê¼Ç£¬»ñʤÕóÓª£¬Îª0ʱ´ú±íδ½áÊø£¬ËùÓÐС¶Ó´òÍê»òʧ°Ü²ÅÓнá¹û£¬0-δ½áÊø£¬>0-»ñʤµÄÕóÓª
        self.batBuffer = "" # Õ½±¨buffer£¬Õ½±¨ÔÝʱֻ±£Áô×îºóÒ»¸öС¶ÓµÄ
        self.isNeedReport = isNeedReport # ÊÇ·ñÐèÒªÕ½±¨
        self.msgDict = {} # À©Õ¹ÐÅÏ¢×ֵ䣬һ°ãÓÉMapID°ó¶¨µÄ¹¦Äܾö¶¨ÐÅÏ¢ÄÚÈÝ  {k:v, ...}
        
        self.factionDict = {} # Õ½¶·ÕóÓª {faction:BatFaction, ...}£¬Ò»°ãÊÇÖ»ÓÐÁ½¸öÕóÓª£¬factionΪ1»ò2£¬Ã¿¸öÕóÓªÖ§³Ö¶à¸öÕóÈÝ
        self.actionSortList = [] # ÕóÈÝÐж¯Ë³Ðò [[faction, num], ...]
        self.actionIndex = 0 # Ðж¯Ë³ÐòË÷Òý
        
        self.startTime = 0 # ¿ªÊ¼Ê±¼ä´Á£¬Ö§³ÖºÁÃëСÊý
        self.costTime = 0 # µ¥³¡Õ½¶·×ܺÄʱ£¬Ö§³ÖºÁÃëСÊý
        return
    
    def setTurn(self, mapID, funcLineID, turnMax, isNeedReport=False, msgDict={}):
        ## ÉèÖñ¾³¡»ØºÏÕ½¶·É趨
        self.mapID = mapID
        self.funcLineID = funcLineID
        self.turnMax = turnMax # ×î´ó»ØºÏÊý
        self.isNeedReport = isNeedReport
        self.msgDict = {}
        self.resetTurn(msgDict)
        return
    
    def resetTurn(self, msgDict):
        ## Ò»°ãÓÃÓÚÍæ¼Ò·¢ÆðµÄÕ½¶·£¬ÔÚÐèÒª±£ÁôÍæ¼ÒÕóÈÝÊôÐÔ¼°×´Ì¬µÄÇé¿öÏ£¬ÖØÖûغϽøÈëÏÂÒ»³¡Õ½¶·
        self.turnNum = 1
        self.enterLogic = False
        self.turnStart = 0
        self.turnEnd = 0
        self.winFaction = 0
        self.batBuffer = "" # Õ½±¨buffer
        self.msgDict.update(msgDict)
        self.startTime = time.time()
        self.costTime = 0
        return
    
    def setFactionLineup(self, faction, lineupDict, onlyReset=False):
        ## ÉèÖÃÕóÓªÕóÈÝ
        # @param lineupDict: {ÕóÈݱàºÅ:ÕóÈÝÐÅÏ¢, ...} ÿ¸öÕóÓªÖ§³Ö¶à¸öÕóÈÝ£¬¼´Ö§³Ö¶àV¶à
        # @param onlyReset: ÊÇ·ñ½öÖØÖã¬Ò»°ãÓÃÓÚÍæ¼ÒµÄÕóÈÝ£¬Öظ´ÀûÓÃÕóÈÝʵÀý£¬
        batFaction = self.getBatFaction(faction)
        if onlyReset:
            batFaction.resetLineups()
        else:
            batFaction.clearLineups()
        for num, lineupInfo in lineupDict.items():
            batLineup = batFaction.getBatlineup(num)
            if onlyReset and not batLineup.isEmpty():
                continue
            if not lineupInfo:
                continue
            batLineup.setLineup(lineupInfo)
        return
    
    def sortActionQueue(self):
        ## ˢгöÊÖ˳Ðò¶ÓÁÐ
        sortList = []
        for batFaction in self.factionDict.values():
            faction = batFaction.faction
            for num, batLineup in batFaction.lineupDict.items():
                fightPower = batLineup.fightPower
                sortValue = -(faction * 10 + num)
                sortList.append([fightPower, sortValue, faction, num])
        sortList.sort(reverse=True) # Õ½Á¦¸ßµÄÏÈÊÖ
        
        self.actionIndex = 0
        self.actionSortList = []
        for _, _, faction, num in sortList:
            self.actionSortList.append([faction, num])
            
        GameWorld.DebugLog("ÕóÈÝÕ½Á¦ÅÅÐò[fp, sortV, f, n]: %s" % sortList)
        GameWorld.DebugLog("ÕóÈÝÐж¯Ë³Ðò[f, n]: %s" % self.actionSortList)
        return
    
    def getBatFaction(self, faction=ChConfig.Def_FactionA):
        ## ĬÈÏÕóÓª1
        batFaction = None
        if faction in self.factionDict:
            batFaction = self.factionDict[faction]
        else:
            batFaction = BatFaction(faction, self)
            self.factionDict[faction] = batFaction
        return batFaction
    
    def checkOverByKilled(self):
        ##¼ì²éÊÇ·ñ»÷ɱ½áÊø
        # @return: 0-ÎÞ»ñʤÕóÓª£¬Í¬Ê±Ò²´ú±íÕ½¶·Î´½áÊø£»>0-»ñʤµÄÕóÓªID£¬Í¬Ê±Ò²´ú±íÕ½¶·ÒÑÈ«²¿½áÊø
        
        if self.winFaction:
            return self.winFaction
        
        batObjMgr = BattleObj.GetBatObjMgr()
        for faction, batFaction in self.factionDict.items():
            allKilled = True
            for batLineup in batFaction.lineupDict.values():
                if not allKilled:
                    break
                for posNum, objID in batLineup.posObjIDDict.items():
                    if posNum <= 0:
                        # ·ÇÖ÷սλÖò»ÅжÏ
                        continue
                    batObj = batObjMgr.getBatObj(objID)
                    if not batObj:
                        continue
                    if batObj.GetHP() > 0:
                        allKilled = False
                        break
                    
            if allKilled:
                self.winFaction = ChConfig.Def_FactionA if faction == ChConfig.Def_FactionB else ChConfig.Def_FactionA
                DoTurnFightOver(self.guid)
                return self.winFaction
            
        return 0
    
    def clearBatFaction(self, faction):
        batFaction = self.getBatFaction(faction)
        batFaction.clearLineups()
        return
    
    def clearFight(self):
        self.syncState(FightState_Over)
        for batFaction in self.factionDict.values():
            batFaction.clearLineups()
        return
    
    def syncInit(self):
        ## ³õʼ»¯Í¨Öª
        msg = json.dumps(self.msgDict, ensure_ascii=False)
        msg = msg.replace(" ", "")
        clientPack = ChPyNetSendPack.tagSCTurnFightInit()
        clientPack.MapID = self.mapID
        clientPack.FuncLineID = self.funcLineID
        clientPack.TurnMax = self.turnMax
        clientPack.Msg = msg
        clientPack.Len = len(clientPack.Msg)
        clientPack.FactionList = []
        
        batObjMgr = BattleObj.GetBatObjMgr()
        for faction in self.factionDict.keys():
            batFaction = self.getBatFaction(faction)
            tfFaction = ChPyNetSendPack.tagSCTurnFightFaction()
            tfFaction.Faction = faction
            tfFaction.LineupList = []
            for num in batFaction.lineupDict.keys():
                batLineup = batFaction.getBatlineup(num)
                tfLineup = ChPyNetSendPack.tagSCTurnFightLineup()
                tfLineup.Num = num
                tfLineup.OwnerID = batLineup.ownerID
                tfLineup.ShapeType = batLineup.shapeType
                tfLineup.ObjList = []
                for posNum, objID in batLineup.posObjIDDict.items():
                    batObj = batObjMgr.getBatObj(objID)
                    if not batObj:
                        continue
                    tfObj = ChPyNetSendPack.tagSCTurnFightObj()
                    tfObj.ObjID = batObj.GetID()
                    tfObj.NPCID = batObj.GetNPCID()
                    tfObj.HeroID = batObj.GetHeroID()
                    tfObj.SkinID = batObj.GetSkinID()
                    tfObj.HP = batObj.GetHP() % ChConfig.Def_PerPointValue
                    tfObj.HPEx = batObj.GetHP() / ChConfig.Def_PerPointValue
                    tfObj.MaxHP = batObj.GetMaxHP() % ChConfig.Def_PerPointValue
                    tfObj.MaxHPEx = batObj.GetMaxHP() / ChConfig.Def_PerPointValue
                    tfObj.LV = batObj.GetLV()
                    tfObj.PosNum = posNum
                    tfObj.AngreXP = batObj.GetXP()
                    tfLineup.ObjList.append(tfObj)
                tfLineup.ObjCnt = len(tfLineup.ObjList)
                tfFaction.LineupList.append(tfLineup)
            tfFaction.LineupCnt = len(tfFaction.LineupList)
            clientPack.FactionList.append(tfFaction)
        clientPack.FactionCnt = len(clientPack.FactionList)
        self.addBatPack(clientPack)
        return
    
    def syncState(self, state, msgDict={}):
        msg = json.dumps(msgDict, ensure_ascii=False)
        msg = msg.replace(" ", "")
        clientPack = ChPyNetSendPack.tagMCTurnFightState()
        clientPack.Clear()
        clientPack.MapID = self.mapID
        clientPack.FuncLineID = self.funcLineID
        clientPack.State = state
        clientPack.TurnNum = self.turnNum
        clientPack.Msg = msg
        clientPack.Len = len(clientPack.Msg)
        self.addBatPack(clientPack)
        return
    
    def syncObjAction(self, turnNum, objID):
        clientPack = ChPyNetSendPack.tagMCTurnFightObjAction()
        clientPack.Clear()
        clientPack.TurnNum = turnNum
        clientPack.ObjID = objID
        self.addBatPack(clientPack)
        return
    
    def addBatPack(self, clientPack):
        ## Ìí¼ÓÕ½¶·¹ý³Ì·â°ü£¬·ÇÕ½¶·Ïà¹ØµÄ·â°ü¿ÉÒÔ²»Ê¹Óøú¯Êý·¢ËÍ£¬Èç¼Ó¾­Ñé¡¢µôÂäµÈ
        ## ×¢£ºÕ½¶·Ïà¹ØµÄ·â°üÐèµ÷Óñ¾º¯Êý·½±ãͳһ¹ÜÀíÕ½±¨
        if hasattr(clientPack, "Head"):
            headStr = "%02x%02x" % (clientPack.Head.Cmd, clientPack.Head.SubCmd)
        else:
            headStr = "%02x%02x" % (clientPack.Cmd, clientPack.SubCmd)
        GameWorld.DebugLog("»ØºÏÕ½¶·¹ý³Ì·â°ü: %s, isNeedReport=%s,%s" % (headStr, self.isNeedReport, self.guid))
        if self.isNeedReport:
            self.batBuffer += clientPack.GetBuffer()
        # ÓÐÍæ¼ÒµÄͳһÿ¸ö°üµ¥¶À·¢ËÍ£¬Í¬ÑùÒ²Ö§³ÖÕ½±¨Í³¼Æ
        if self.curPlayer:
            NetPackCommon.SendFakePack(self.curPlayer, clientPack)
        else:
            ObjPool.GetPoolMgr().release(clientPack)
        return
    
class TurnFightMgr():
    ## »ØºÏÕ½¶·¹ÜÀíÆ÷
    
    def __init__(self):
        self.turnFightDict = {} # {guid:TurnFight, ...}
        return
    
    def addTurnFight(self, mapID, funcLineID=0, playerID=0):
        tf = TurnFight(mapID, funcLineID, playerID, False)
        self.turnFightDict[tf.guid] = tf
        return tf
    
    def delTurnFight(self, guid):
        turnFight = self.getTurnFight(guid)
        if not turnFight:
            return
        turnFight.clearFight()
        self.turnFightDict.pop(guid, None)
        return
    
    def getTurnFight(self, guid):
        tf = None
        if guid in self.turnFightDict:
            tf = self.turnFightDict[guid]
        elif False:
            tf = TurnFight()
        return tf
    
def GetTurnFightMgr():
    tfMgr = None
    if PyGameData.g_turnFightMgr:
        tfMgr = PyGameData.g_turnFightMgr
    else:
        tfMgr = TurnFightMgr()
        PyGameData.g_turnFightMgr = tfMgr
    return tfMgr
    
class MainFight():
    ## Ö÷ÏßÕ½¶·¹ÜÀí
    
    def __init__(self, playerID):
        self.playerID = playerID
        self.chapterID = 0 # Õ½ÚID
        self.levelNum = 0 # ¹Ø¿¨±àºÅ
        self.waveMax = 6 # ±¾¹Ø×î´ó²¨Êý£¬Ã¿²¨Óжà¸öС¶Ó£¬Ã¿¸öС¶Ó¼´ÎªÒ»ÕÅÕ½¶· TurnFight
        self.wave = 0 # µ±Ç°Ë¢¹Ö²¨£¬×¢Òâ²»ÊÇÍæ¼Òµ±Ç°½ø¶È²¨£¬±ÈÈç±»»÷ɱ»á»ØÍËÒ»²¨
        self.teamNum = 1 # µ±Ç°Ð¡¶Ó
        self.teamMax = 1 # µ±Ç°²¨×î´óС¶Ó£¬Ä³³¡Õ½¶·¿ÉÄÜ°üº¬¶à¸öС¶Ó£¬ËùÓÐС¶Ó»ìÁ÷»÷ɱÍê²ÅËã¹ýÁ˱¾²¨
        self.nextTeam = False # Ï´ÎÇ°¶ËÇëÇóÕ½¶·ÊÇ·ñÊÇÏÂһС¶Ó£¬·ñÔò¶¼ÊÇÖØÐÂˢе±Ç°½ø¶È¹Ö
        self.waveLineupList = [] # С¶ÓÁбí
        self.turnFight = GetTurnFightMgr().addTurnFight(ChConfig.Def_FBMapID_Main, 0, playerID)
        return
    
    def isLevelBoss(self):
        ## µ±Ç°Õ½¶·ÊÇ·ñ¹Ø¿¨boss
        return self.turnFight.mapID == ChConfig.Def_FBMapID_MainBoss
    
def GetMainFightMgr(curPlayer):
    ## »ñÈ¡Ö÷ÏßÕ½¶·¹ÜÀí
    olPlayer = PlayerOnline.GetOnlineMgr().GetOnlinePlayer(curPlayer)
    return olPlayer.mainFight

def OnPlayerLogin(curPlayer):
    chapterID, levelNum, _ = PlayerControl.GetMainLevelPassInfo(curPlayer)
    nowChapterID, _, _ = PlayerControl.GetMainLevelNowInfo(curPlayer)
    if chapterID != nowChapterID:
        if IpyGameDataPY.GetIpyGameDataNotLog("MainChapter", chapterID) and IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID, levelNum):
            fixNowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, 1)
            GameWorld.Log("µ±Ç°Ö÷Ï߹ؿ¨Õ½ÚÓë¹ý¹ØÕ½ڲ»Ò»ÖÂʱ£¬ÇÒ¹ý¹Ø½ø¶ÈÕ½ÚÒѾ­´æÔÚ£¬Ç¿ÖÆÐÞÕýµ±Ç°Ë¢¹Ö½ø¶ÈΪ¹ý¹ØÕ½ڽø¶È! passChapterID-LV=%s-%s,nowChapterID=%s,fixNowValue=%s" 
                          % (chapterID, levelNum, nowChapterID, fixNowValue), curPlayer.GetPlayerID())
    return

def GetPlayerLineupInfoByCache(playerID, lineupID):
    ## »ñÈ¡Íæ¼ÒÕóÈÝÐÅÏ¢ - ¸ù¾ÝÍæ¼Ò²é¿´»º´æ
    lineupInfo = {}
    return lineupInfo

def GetPlayerLineupInfo(curPlayer, lineupID):
    ## »ñÈ¡Íæ¼ÒÕóÈÝÐÅÏ¢£¬¿ÉÓÃÓÚÕ½¶·»ò²é¿´»º´æ£¬ÒòΪ¿ÉÄÜÈ¡Íæ¼ÒµÄ»º´æ½øÐжÔÕ½£¬ËùÒÔͳһʹÓÃjson¸ñʽ£¬Ç°¶ËͨÓÃ
    # @param lineupID: ÕóÈÝID
    # @return: ÕóÈÝÈ«²¿ÐÅÏ¢json×ֵ䣬ǰ¶ËͨÓøñʽ
    
    playerID = curPlayer.GetPlayerID()
    lineup = PlayerOnline.GetOnlinePlayer(curPlayer).GetLineup(lineupID)
    
    lineupInfo = {"PlayerID":playerID, "FightPower":lineup.fightPower, "ShapeType":lineup.shapeType}
    heroDict = {}
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    for posNum in lineup.lineupHeroDict.keys():
        hero = lineup.GetLineupHero(posNum)
        heroID = hero.heroID
        itemIndex = hero.itemIndex
        userData = ""
        heroLV = 1
        if itemIndex >= 0 and itemIndex < curPack.GetCount():
            heroItem = curPack.GetAt(itemIndex)
            if heroItem and not heroItem.IsEmpty():
                userData = heroItem.GetUserData()
                heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
                
        skillIDlist = []
        skillIDlist += hero.heroSkillIDList
        heroDict[str(posNum)] = {
                                 "HeroID":heroID,
                                 "SkinID":hero.skinID,
                                 "LV":heroLV,
                                 "Data":userData,
                                 "FightPower":hero.fightPower,
                                 "AttrDict":{str(k):v for k, v in hero.heroBatAttrDict.items() if v > 0},
                                 "SkillIDList":skillIDlist,
                                 }
    lineupInfo.update({"Hero":heroDict})
    
    return lineupInfo

def GetNPCLineupInfo(lineupID):
    ## »ñÈ¡NPCÕóÈÝÐÅÏ¢
    # @param lineupID: ÕóÈÝID
    # @return: ÕóÈÝÈ«²¿ÐÅÏ¢json×ֵ䣬ǰ¶ËͨÓøñʽ
    ipyData = IpyGameDataPY.GetIpyGameData("NPCLineup", lineupID)
    if not ipyData:
        return {}
    
    heroDict = {}
    for posNum in range(1, 1 + 10):
        if not hasattr(ipyData, "GetPosNPCID%s" % posNum):
            break
        npcID = getattr(ipyData, "GetPosNPCID%s" % posNum)()
        if not npcID:
            continue
        npcData = NPCCommon.GetNPCDataPy(npcID)
        if not npcData:
            continue
        batAttrDict = {ChConfig.AttrID_Atk:npcData.GetAtk(), ChConfig.AttrID_Def:npcData.GetDef(), ChConfig.AttrID_MaxHP:npcData.GetMaxHP(), 
                       ChConfig.AttrID_FinalDamPer:npcData.GetFinalDamPer(), ChConfig.AttrID_FinalDamPerDef:npcData.GetFinalDamPerDef(), 
                       ChConfig.AttrID_MissRate:npcData.GetMissRate(), ChConfig.AttrID_MissRateDef:npcData.GetMissRateDef(), 
                       ChConfig.AttrID_SuperHitRate:npcData.GetSuperHitRate(), ChConfig.AttrID_SuperHitRateDef:npcData.GetSuperHitRateDef(), 
                       ChConfig.AttrID_StunRate:npcData.GetStunRate(), ChConfig.AttrID_StunRateDef:npcData.GetStunRateDef(), 
                       ChConfig.AttrID_ComboRate:npcData.GetComboRate(), ChConfig.AttrID_ComboRateDef:npcData.GetComboRateDef(), 
                       ChConfig.AttrID_ParryRate:npcData.GetParryRate(), ChConfig.AttrID_ParryRateDef:npcData.GetParryRateDef(), 
                       ChConfig.AttrID_SuckHPPer:npcData.GetSuckHPPer(), ChConfig.AttrID_SuckHPPerDef:npcData.GetSuckHPPerDef(), 
                       }
        batAttrDict.update(npcData.GetSpecAttrInfo())
        skillIDList = [] + npcData.GetSkillIDList()
        heroDict[str(posNum)] = {"NPCID":npcID, 
                                 "AttrDict":{str(k):v for k, v in batAttrDict.items() if v > 0},
                                 "SkillIDList":skillIDList
                                 }
        
    lineupInfo = {"NPCLineupID":lineupID, "Hero":heroDict}
    return lineupInfo

def SummonLineupObjs(batLineup, faction, num, lineupInfo, playerID=0):
    '''ÕÙ»½ÕóÈÝÕ½¶·ÊµÀý
    @param faction: ËùÊôÕóÓª£¬Ä¿Ç°Ö§³ÖÁ½¸öÕóÓª£¬1»ò2
    @param num: Õ½¶·ÕóÈÝÔÚ¸ÃÕóÓªÉϵıàºÅ£¬1V1ʱĬÈÏ1£¬¶à¶Ô¶àʱ1~n
    @param lineupInfo: ÕóÈÝÐÅÏ¢
    @param playerID: ·¢ÆðµÄÍæ¼ÒID£¬ÏµÍ³³¡´ÎΪ0
    '''
    GameWorld.DebugLog("SummonLineupObjs faction:%s,num:%s,lineupInfo=%s" % (faction, num, lineupInfo), playerID)
    if playerID:
        curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
        if not curPlayer:
            return
        
    tfGUID = batLineup.turnFight.guid
    lineupPlayerID = lineupInfo.get("PlayerID", 0) # ÕóÈÝËùÊôÍæ¼ÒID
    heroDict = lineupInfo.get("Hero", {})
    
    batObjMgr = BattleObj.GetBatObjMgr()
    initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
    atkBackSkillIDList = IpyGameDataPY.GetFuncEvalCfg("ParryCfg", 3)
    for posNumKey, heroInfo in heroDict.items():
        posNum = int(posNumKey)
        
        npcID, heroID, skinID = 0, 0, 0
        atkBackSkillID = 0 # ·´»÷¼¼ÄÜID
        fightPower = 0
        skillIDList = [] # Õ½¶·¶ÔÏó¿ÉÄܸıäÊôÐÔ»ò¼¼ÄÜ£¬ÖØд´½¨£¬·ÀÖ¹ÎóÐÞ¸ÄÀ´Ô´Öµ
        attrDict = {}
        skillIDList += heroInfo.get("SkillIDList", [])
        attrDict.update(heroInfo.get("AttrDict", {}))
        objName = ""
        if lineupPlayerID:
            heroID = heroInfo.get("HeroID", 0)
            skinID = heroInfo.get("SkinID", 0)
            lv = heroInfo.get("LV", 1)
            fightPower = heroInfo.get("FightPower", 0)
            heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
            if not heroIpyData:
                continue
            atkDistType = heroIpyData.GetAtkDistType()
            objName = heroIpyData.GetName()
        else:
            npcID = heroInfo.get("NPCID", 0)
            npcDataEx = NPCCommon.GetNPCDataPy(npcID)
            if not npcDataEx:
                continue
            objName = npcDataEx.GetNPCName()
            atkDistType = npcDataEx.GetAtkDistType()
            lv = npcDataEx.GetLV()
            
        batObj = batObjMgr.addBatObj()
        if not batObj:
            break
        objID = batObj.GetID()
        batObj.SetTFGUID(tfGUID)
        batObj.SetName(objName)
        batObj.SetFaction(faction)
        batObj.SetLineupPos(posNum, num)
        batObj.SetFightPower(fightPower)
        batObj.SetLV(lv)
        if npcID:
            batObj.SetNPCID(npcID)
        elif lineupPlayerID:
            batObj.SetOwnerHero(lineupPlayerID, heroID, skinID)
        batObj.InitBatAttr({int(k):v for k, v in attrDict.items()}, initXP)
        
        if atkDistType == ChConfig.AtkDistType_Short:
            atkBackSkillID = atkBackSkillIDList[0] if len(atkBackSkillIDList) > 0 else 0
        elif atkDistType == ChConfig.AtkDistType_Long:
            atkBackSkillID = atkBackSkillIDList[1] if len(atkBackSkillIDList) > 1 else 0
        if atkBackSkillID:
            skillIDList.append(atkBackSkillID)
        skillManager = batObj.GetSkillManager()
        skillManager.SkillReset()
        for skillID in skillIDList:
            skillManager.LearnSkillByID(skillID)
            
        batLineup.posObjIDDict[posNum] = objID
        GameWorld.DebugLog("AddBatObj ID:%s,faction:%s,num=%s,posNum=%s,skill=%s,atk=%s,def=%s,hp=%s" 
                           % (objID, faction, num, posNum, skillIDList, batObj.GetAtk(), batObj.GetDef(), batObj.GetHP()))
        
    return

#// B4 13 Ö÷ÏßÕ½¶·ÇëÇó #tagCSMainFightReq
#
#struct    tagCSMainFightReq
#{
#    tagHead        Head;
#    BYTE        ReqType;        // 0-Í£Ö¹Õ½¶·»Ø³Ç£»1-ÉèÖÃÏûºÄ±¶Öµ£»2-ÌôÕ½¹Ø¿¨Ð¡¹Ö£»3-ÌôÕ½¹Ø¿¨boss£»4-¼ÌÐøÕ½¶·£»
#    DWORD        ReqValue;    // ÇëÇóÖµ£¬ReqTypeΪ1ʱ·¢ËÍÏûºÄ±¶Öµ
#};
def OnMainFightReq(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    reqType = clientData.ReqType
    reqValue = clientData.ReqValue
    
    if reqType == 0:
        __doExitMainFight(curPlayer)
        return
    elif reqType == 1:
        __doSetFightPoint(curPlayer, reqValue)
        return
    
    clientPack = ChPyNetSendPack.tagSCTurnFightReportSign()
    clientPack.Sign = 0
    NetPackCommon.SendFakePack(curPlayer, clientPack) # ±ê¼Ç¿ªÊ¼
    
    if reqType == 2: # Ç°¶ËÖ÷¶¯ÇëÇó¿ªÊ¼¹Ø¿¨Ð¡¹ÖµÄÊÓΪ´ÓÐÝÏ¢ÖпªÊ¼
        __doMainLevelWave(curPlayer, True)
    elif reqType == 3:
        __doMainBossStart(curPlayer, tick)
    elif reqType == 4:
        __doMainFight(curPlayer, tick)
    else:
        pass
    
    # ±ê¼Ç½áÊø
    clientPack.Sign = 1
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def __doExitMainFight(curPlayer):
    ## Ö÷ÏßÍ˳öÕ½¶· - »Ø³ÇÐÝÏ¢
    mainFightMgr = GetMainFightMgr(curPlayer)
    turnFight = mainFightMgr.turnFight
    if turnFight:
        turnFight.clearFight()
    return

def __doSetFightPoint(curPlayer, fightPoint):
    ## ÉèÖÃÏûºÄ±¶Öµ
    GameWorld.DebugLog("ÉèÖÃÕ½´¸ÏûºÄ±¶Öµ: %s" % fightPoint)
    if fightPoint == 1:
        pass
    elif fightPoint == 2:
        # Ìõ¼þÑéÖ¤
        pass
    elif fightPoint == 3:
        # Ìõ¼þÑéÖ¤
        pass
    else:
        return
    curPlayer.SetFightPoint(fightPoint)
    return

def __doMainLevelWave(curPlayer, isRestStart=False):
    ## ¿ªÊ¼ÐµĹؿ¨²¨
    # @param isRestStart: ÊÇ·ñ´ÓÐÝϢ״̬ÖØпªÊ¼µÄ
    playerID = curPlayer.GetPlayerID()
    chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)
    if not chapterID and not levelNum:
        PlayerControl.SetMainLevelNowInfo(curPlayer, 1, 1, 1)
        chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)
    GameWorld.DebugLog("ÇëÇó¹Ø¿¨²¨Õ½¶·: chapterID=%s,levelNum=%s,wave=%s,isRestStart=%s" % (chapterID, levelNum, wave, isRestStart), playerID)
    fightPoint = max(curPlayer.GetFightPoint(), 1)
    if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
        GameWorld.DebugLog("Õ½´¸²»×㣬ÎÞ·¨¿ªÊ¼!")
        return
    chapterIpyData = IpyGameDataPY.GetIpyGameData("MainChapter", chapterID)
    if not chapterIpyData:
        return
    levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
    if not levelIpyData:
        # ÈçÉÏÏߺó¼õÉÙij¸öÕ½ڹؿ¨ÊýµÄÇé¿ö£¬µ¼ÖÂÕÒ²»µ½£¬Ôò´Ó¸ÃÕ½ڻØÍ˵½´æÔڵĹؿ¨¿ªÊ¼
        while levelNum > 1:
            levelNum -= 1 
            levelIpyData = IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID, levelNum)
            if levelIpyData:
                break
    if not levelIpyData:
        return
    
    # ±¾¹Ø¿¨×î´ó²¨Êý£¬ÔÝʱ֧³Ö×î´ó6²¨
    waveMax = 6
    while waveMax >= 1 and (not hasattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax) or not getattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax)()):
        waveMax -= 1
    if waveMax < 1:
        return
    if wave > waveMax:
        wave = waveMax
        
    waveLineupList = getattr(levelIpyData, "GetWaveLineupIDList%s" % wave)() # С¶Ó1ÕóÈÝID|С¶Ó2ÕóÈÝID|...
    if not waveLineupList:
        return
    teamMax = len(waveLineupList)
    teamNum = 1
    lineupID = waveLineupList[teamNum - 1] # NPCÕóÈÝID
    
    lineupMainInfo = GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)
    if not lineupMainInfo:
        GameWorld.DebugLog("ûÓÐÉèÖÃÖ÷ÕóÈÝ!", playerID)
        return
    
    mainFightMgr = GetMainFightMgr(curPlayer)
    mainFightMgr.nextTeam = False
    mainFightMgr.chapterID = chapterID
    mainFightMgr.levelNum = levelNum
    mainFightMgr.waveMax = waveMax
    mainFightMgr.wave = wave
    mainFightMgr.waveLineupList = waveLineupList
    mainFightMgr.teamNum = teamNum
    mainFightMgr.teamMax = teamMax
    turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 2)
    mapID, funcLineID = ChConfig.Def_FBMapID_Main, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
    GameWorld.DebugLog("ÉèÖÃÆðʼ¹Ø¿¨²¨: ¹Ø¿¨%s-%s,²¨=%s/%s,teamMax=%s,mapID=%s,funcLineID=%s,lineupID=%s" 
                       % (chapterID, levelNum, wave, waveMax, teamMax, mapID, funcLineID, lineupID), playerID)
    
    turnFight = mainFightMgr.turnFight
    turnFight.setTurn(mapID, funcLineID, turnMax, False, {"teamNum":teamNum, "teamMax":teamMax})
    turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo}, True)
    turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID)})
    turnFight.sortActionQueue()
    turnFight.syncInit()
    return

def __doMainBossStart(curPlayer, tick):
    ## ¿ªÊ¼ÌôÕ½¹Ø¿¨boss
    playerID = curPlayer.GetPlayerID()
    chapterID, levelNum, wave = PlayerControl.GetMainLevelPassInfo(curPlayer)
    if not chapterID:
        chapterID = 1
    if not levelNum:
        levelNum = 1
    GameWorld.DebugLog("ÇëÇóÌôÕ½¹Ø¿¨Boss! passInfo: chapterID=%s,levelNum=%s,wave=%s" % (chapterID, levelNum, wave), playerID)
    chapterIpyData = IpyGameDataPY.GetIpyGameData("MainChapter", chapterID)
    if not chapterIpyData:
        return
    levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
    if not levelIpyData:
        return
    
    nowChapterID, nowLevelNum, _ = PlayerControl.GetMainLevelNowInfo(curPlayer)
    if chapterID != nowChapterID or levelNum != nowLevelNum:
        '''Ò»°ãÓÐÁ½ÖÖÇé¿ö»áµ¼ÖÂ
        1. ÀíÂÛÉÏÍæ¼Òµ±Ç°Ë¢¹ÖµÄÕ½ڹؿ¨Ò»¶¨ÊÇÓë¹ý¹ØµÄÕ½ڹؿ¨ÊÇÒ»Öµģ¬³ýÁËÈ«²¿Õ½ÚÒÑͨ¹Ø
                                µ±Í¨¹Øʱ£¬Òѹý¹ØµÄ¼Ç¼»á±»ÉèÖÃΪÏÂÒ»Õ½ڵÚ1¹Ø£¨°æ±¾¹Ø¿¨±íʵ¼Ê²»´æÔڸùؿ¨£©
                                µ«Êǵ±Ç°Ë¢¹ÖµÄ»¹ÊÇ°æ±¾µÄ×îºóÒ»¹Ø£¬¹Ì»á³öÏÖ²»Ò»ÖµÄÇé¿ö
                                ÔÚÔö¼ÓÕ½ڹؿ¨Ð°汾¸üкóÍæ¼ÒÖصǻá×Ô¶¯½øÐÐÐÞ¸´µ±Ç°Ë¢¹Ö½ø¶ÈΪ×îÐÂÕ½ڵÚ1¹Ø
        2. ÕæµÄ³öÏÖÎÊÌâÁË£¬¿ÉÄÜÊÇbugÒýÆð£¬ÕâÖÖÇé¿öÖ»ÄܽøÐÐbugÐÞ¸´¼°Õë¶ÔÒì³£Õ˺ÅÌØÊâ´¦Àí£¬»òÕßÖصǺóÒ²»á×Ô¶¯½øÐÐÐÞÕý
        '''
        GameWorld.ErrLog("µ±Ç°Ë¢¹ÖÕ½ڹؿ¨ÓëÌôÕ½µÄbossÕ½ڹؿ¨²»Ò»Ö£¬ÎÞ·¨ÌôÕ½! chapterID=%s,levelNum=%s,nowChapterID=%s,nowLevelNum=%s" 
                         % (chapterID, levelNum, nowChapterID, nowLevelNum), playerID)
        return
    
    # ±¾¹Ø¿¨×î´ó²¨Êý
    waveMax = 6
    while waveMax >= 1 and (not hasattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax) or not getattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax)()):
        waveMax -= 1
        
    if wave < waveMax:
        GameWorld.DebugLog("×îºóÒ»²¨Î´Í¨¹ý£¬ÎÞ·¨ÌôÕ½±¾¹Øboss! passWave=%s < %s" % (wave, waveMax))
        return
    
    waveLineupList = levelIpyData.GetBossLineupIDList() # Boss²¨ÕóÈÝIDÁÐ±í£¬Ð¡¶Ó1ÕóÈÝID|С¶Ó2ÕóÈÝID|...
    if not waveLineupList:
        return
    teamMax = len(waveLineupList)
    teamNum = 1
    lineupID = waveLineupList[teamNum - 1] # NPCÕóÈÝID
    
    wave = waveMax = 1 # ¹Ø¿¨boss¹Ì¶¨Ö»ÓÐÒ»²¨
    
    lineupMainInfo = GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)
    if not lineupMainInfo:
        GameWorld.DebugLog("ûÓÐÉèÖÃÖ÷ÕóÈÝ!", playerID)
        return
    
    mainFightMgr = GetMainFightMgr(curPlayer)
    mainFightMgr.nextTeam = False
    mainFightMgr.chapterID = chapterID
    mainFightMgr.levelNum = levelNum
    mainFightMgr.waveMax = waveMax
    mainFightMgr.wave = wave
    mainFightMgr.waveLineupList = waveLineupList
    mainFightMgr.teamNum = teamNum
    mainFightMgr.teamMax = teamMax
    turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 3)
    mapID, funcLineID = ChConfig.Def_FBMapID_MainBoss, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
    GameWorld.DebugLog("ÉèÖùؿ¨boss: ¹Ø¿¨%s-%s,²¨=%s/%s,teamMax=%s,mapID=%s,funcLineID=%s,lineupID=%s" 
                       % (chapterID, levelNum, wave, waveMax, teamMax, mapID, funcLineID, lineupID), playerID)
    
    turnFight = mainFightMgr.turnFight
    turnFight.setTurn(mapID, funcLineID, turnMax, False, {"teamNum":teamNum, "teamMax":teamMax})
    turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo}, True)
    turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID)})
    turnFight.sortActionQueue()
    turnFight.syncInit()
    
    # ÌôÕ½bossÎÞÖмä¹ý³Ì£¬Ã¿´ÎÖ´ÐÐÖ±½ÓÌôÕ½Ò»¶Ó½á¹û
    __processTurnFight(turnFight.guid, tick)
    return

def __doMainFight(curPlayer, tick):
    ## Ö÷ÏßÖ´ÐÐÕ½¶·
    mainFightMgr = GetMainFightMgr(curPlayer)
    turnFight = mainFightMgr.turnFight
    
    isLevelBoss = mainFightMgr.isLevelBoss()
    winFaction = turnFight.winFaction
    if winFaction:
        if mainFightMgr.nextTeam:
            # ×Ô¶¯¿ªÊ¼ÏÂһС¶Ó
            teamNum = mainFightMgr.teamNum = mainFightMgr.teamNum + 1
            GameWorld.DebugLog("¿ªÊ¼½øÈëÏÂһС¶Ó: teamNum=%s" % teamNum)
            if teamNum < 1 or teamNum > len(mainFightMgr.waveLineupList):
                return
            lineupID = mainFightMgr.waveLineupList[teamNum - 1] # NPCÕóÈÝID
            GameWorld.DebugLog("teamNum=%s,lineupID=%s" % (teamNum, lineupID))
            
            mainFightMgr.nextTeam = False
            turnFight.resetTurn({"teamNum":teamNum})
            # Çл»Ð¡¶Óʱ£¬Íæ¼ÒÕóÈݲ»ÐèÒª´¦Àí£¬±£Áô״̬
            turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID)})
            turnFight.sortActionQueue()
            turnFight.syncInit()
            
            if mainFightMgr.isLevelBoss():
                # ÿ´Î´¦ÀíһС¶ÓµÄÍêÕûÕ½¶·£¬Ï൱ÓÚÒ»´ÎÍêÕûÕ½±¨
                __processTurnFight(turnFight.guid, tick)
                return
        else:
            __doMainLevelWave(curPlayer, False)
        return
    
    if isLevelBoss:
        ## ¹Ø¿¨bossÊÇÒ»´ÎÐÔ´¦ÀíÍêµÄ£¬Ò»°ã²»¿ÉÄÜ×ßµ½ÕâÀÕâ±ß×öÏ·À·¶
        return
    
    # ÒÔϾùÊÇ´¦Àí¹Ø¿¨Ð¡¹Ö·Ö¶Îʵʱս¶·
    
    EntryLogic(turnFight)
    
    # С¹ÖÕ½¶·£¬Ã¿´ÎÏûºÄ1¸öÕ½´¸
    fightPoint = max(curPlayer.GetFightPoint(), 1) # Ö÷ÏßÕ½¶·ÏûºÄ±¶Öµ£¬Ä¬ÈÏ1
    
    # °´ÕóÓªÕóÈÝÖ´ÐÐ˳Ðò£¬Öð¸ö±éÀú
    doCnt = 0
    doMax = (PosNumMax + 2) * len(turnFight.actionSortList) # ·ÀÖ¹ËÀÑ­»·£¬×ö×î´óÑ­»·´ÎÊýÏÞÖÆ = (×î´óλÖÃÊý + Ö÷¹«¡¢ºìÑÕλÖÃ)*Ðж¯ÕóÈÝÊý
    overLineupList = [] # ±¾»ØºÏÒѾ­½áÊøÐж¯µÄÕóÈÝÁбí [(faction, num), ...]£¬ ËùÓÐÕóÈÝÈ«²¿½áÊø´ú±í±¾»ØºÏ½áÊø
    
    batObjMgr = BattleObj.GetBatObjMgr()
    turnNum = turnFight.turnNum
    GameWorld.DebugLog("turnNum=%s,doMax=%s,actionIndex=%s,%s" % (turnNum, doMax, turnFight.actionIndex, turnFight.actionSortList))
    while doCnt < doMax and len(overLineupList) < len(turnFight.actionSortList):
        doCnt += 1
        turnNum = turnFight.turnNum
        # Ö´ÐлغϿªÊ¼Âß¼­
        if turnFight.turnStart < turnNum:
            GameWorld.DebugLog("Ö´ÐÐÐж¯: turnNum=%s, »ØºÏ¿ªÊ¼" % (turnFight.turnNum))
            turnFight.syncState(FightState_Fighting)
            if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
                GameWorld.DebugLog("»ØºÏ¿ªÊ¼Ê±Õ½´¸²»×ã!")
                return
            turnFight.turnStart = turnNum
            turnFight.actionIndex = 0
            for faction, num in turnFight.actionSortList:
                batFaction = turnFight.getBatFaction(faction)
                batLineup = batFaction.getBatlineup(num)
                batLineup.actionNum = ActionNumStart
                for objID in batLineup.posObjIDDict.values():
                    batObj = batObjMgr.getBatObj(objID)
                    TurnFightObjPerTurnStart(turnFight, batObj, turnNum)
                    
        if turnFight.actionIndex >= len(turnFight.actionSortList):
            turnFight.actionIndex = 0
            
        playerHeroAtk = False # Íæ¼ÒÕóÈÝÐж¯±ê¼Ç
        faction, num = turnFight.actionSortList[turnFight.actionIndex]
        batFaction = turnFight.getBatFaction(faction)
        batLineup = batFaction.getBatlineup(num)
        if batLineup.actionNum > max(batLineup.posObjIDDict):
            if (faction, num) not in overLineupList:
                overLineupList.append((faction, num))
                
            turnFight.actionIndex += 1
            continue
        
        if faction == ChConfig.Def_FactionA:
            if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
                GameWorld.DebugLog("Õ½´¸²»×ã!")
                return
        GameWorld.DebugLog("Ö´ÐÐÐж¯: turnNum=%s,faction=%s,num=%s,actionNum=%s" % (turnFight.turnNum, faction, num, batLineup.actionNum))
        
        # Ö÷¹«
        if batLineup.actionNum == -1:
            pass
        
        # ºìÑÕ
        elif batLineup.actionNum == 0:
            pass
        
        # Î佫
        elif batLineup.actionNum > 0:
            for posNum in range(batLineup.actionNum, PosNumMax + 1):
                batLineup.actionNum = posNum
                if posNum not in batLineup.posObjIDDict:
                    continue
                objID = batLineup.posObjIDDict[posNum]
                batObj = batObjMgr.getBatObj(objID)
                if not OnObjAction(turnFight, batObj):
                    continue
                
                if faction == ChConfig.Def_FactionA:
                    playerHeroAtk = True
                    
                break
            
        turnFight.actionIndex += 1
        batLineup.actionNum += 1
        if batLineup.actionNum > max(batLineup.posObjIDDict):
            GameWorld.DebugLog("¸ÃÕóÈݱ¾»ØºÏÒѾ­È«²¿Ðж¯ÍêÁË: turnNum=%s,faction=%s,num=%s,actionNum=%s" % (turnFight.turnNum, faction, num, batLineup.actionNum))
            if (faction, num) not in overLineupList:
                overLineupList.append((faction, num))
                
        if turnFight.checkOverByKilled():
            break
        
        if playerHeroAtk:
            # Íæ¼ÒÎ佫ÓÐÐж¯ÔòÍ£Ö¹£¬Ò»¶Î¶ÎÖ´ÐÐ
            GameWorld.DebugLog("Íæ¼ÒÎ佫ÓÐÐж¯ÔòÍ£Ö¹£¡")
            break
        
    if turnFight.winFaction:
        return
    
    GameWorld.DebugLog("turnNum=%s,doCnt=%s,overLineupList=%s" % (turnNum, doCnt, overLineupList))
    if len(overLineupList) >= len(turnFight.actionSortList):
        GameWorld.DebugLog("Ö´ÐÐÐж¯: turnNum=%s, »ØºÏ½áÊø" % (turnFight.turnNum))
        if turnFight.turnEnd < turnNum:
            if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
                GameWorld.DebugLog("»ØºÏ½áÊøʱս´¸²»×ã!")
                return
            turnFight.turnEnd = turnNum
            for faction, num in turnFight.actionSortList:
                batFaction = turnFight.getBatFaction(faction)
                batLineup = batFaction.getBatlineup(num)
                for objID in batLineup.posObjIDDict.values():
                    pass
                
            if turnFight.checkOverByKilled():
                return
            
        if turnNum < turnFight.turnMax:
            turnFight.turnNum += 1
        else:
            OnTurnAllOver(turnFight.guid)
            
    return

def __processTurnFight(guid, tick):
    ## Ò»´ÎÐÔ´¦ÀíÍêÒ»¸öС¶ÓµÄÕ½¶·
    turnFight = GetTurnFightMgr().getTurnFight(guid)
    curPlayer = turnFight.curPlayer
    turnMax = turnFight.turnMax
    EntryLogic(turnFight)
    batObjMgr = BattleObj.GetBatObjMgr()
    for turnNum in range(1, turnMax + 1):
        turnFight.turnNum = turnNum
        GameWorld.DebugLog("¡¾----- »ØºÏÖÆÕ½¶·ÂÖ´Î: %s -----¡¿" % turnNum)
        if curPlayer:
            turnFight.syncState(FightState_Fighting)
            
        # »ØºÏ¿ªÊ¼
        for faction, num in turnFight.actionSortList:
            GameWorld.DebugLog("»ØºÏ¿ªÊ¼Âß¼­: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
            batFaction = turnFight.getBatFaction(faction)
            batLineup = batFaction.getBatlineup(num)
            batLineup.actionNum = 1
            for objID in batLineup.posObjIDDict.values():
                batObj = batObjMgr.getBatObj(objID)
                TurnFightObjPerTurnStart(turnFight, batObj, turnNum)
                
        # Ö÷¹«
        for faction, num in turnFight.actionSortList:
            GameWorld.DebugLog("Ö÷¹«Âß¼­: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
            batFaction = turnFight.getBatFaction(faction)
            batLineup = batFaction.getBatlineup(num)
            
        # ºìÑÕ
        for faction, num in turnFight.actionSortList:
            GameWorld.DebugLog("ºìÑÕÂß¼­: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
            batFaction = turnFight.getBatFaction(faction)
            batLineup = batFaction.getBatlineup(num)
            
        if turnFight.checkOverByKilled():
            break
        
        # Î佫
        doMax = PosNumMax * len(turnFight.actionSortList)
        doCnt = 0
        while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList):
            doCnt += 1
            faction, num = turnFight.actionSortList[turnFight.actionIndex]
            batFaction = turnFight.getBatFaction(faction)
            batLineup = batFaction.getBatlineup(num)
            for posNum in range(batLineup.actionNum, PosNumMax + 1):
                batLineup.actionNum = posNum + 1
                if posNum not in batLineup.posObjIDDict:
                    continue
                objID = batLineup.posObjIDDict[posNum]
                batObj = batObjMgr.getBatObj(objID)
                if not OnObjAction(turnFight, batObj):
                    continue
                
                break
            
            if turnFight.actionIndex >= len(turnFight.actionSortList) - 1:
                turnFight.actionIndex = 0
            else:
                turnFight.actionIndex += 1
                
        # »ØºÏ½áÊø
        for faction, num in turnFight.actionSortList:
            GameWorld.DebugLog("»ØºÏ½áÊøÂß¼­: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
            batFaction = turnFight.getBatFaction(faction)
            batLineup = batFaction.getBatlineup(num)
            for objID in batLineup.posObjIDDict.values():
                pass
            
        if turnFight.checkOverByKilled():
            break
        
    if not turnFight.winFaction:
        OnTurnAllOver(turnFight.guid)
    return

#// B4 10 »ØºÏÖÆÕ½¶· #tagCMTurnFight
#
#struct    tagCMTurnFight
#{
#    tagHead        Head;
#    DWORD        MapID;        // ×Ô¶¨ÒåµØͼID£¬¿ÉÓÃÓÚ°ó¶¨Õ½¶·µØͼ³¡¾°¹¦ÄÜ£¨ÈçÖ÷Ï߹ؿ¨¡¢Ö÷Ïßboss¡¢ÅÀËþ¡¢¾º¼¼³¡µÈ£©
#    DWORD        FuncLineID;    // MapID¶ÔÓ¦µÄÀ©Õ¹Öµ£¬Èç¾ßÌåij¸ö¹Ø¿¨µÈ
#    BYTE        TagType;    // Ä¿±êÀàÐÍ£¬0-NPCÕóÈÝ£¬1-Íæ¼Ò
#    DWORD        TagID;    // Ä¿±êÀàÐͶÔÓ¦µÄID£¬ÈçÕóÈÝID»òÍæ¼ÒID
#    BYTE        ValueCount;
#    DWORD        ValueList[ValueCount]; // ¸½¼ÓÖµÁÐ±í£¬¿ÉÑ¡£¬¾ßÌ庬ÒåÓÉMapID¾ö¶¨
#};
def OnTurnFight(index, clientData, tick):
    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    #mapID = clientData.MapID
    #funcLineID = clientData.FuncLineID
    return

def GetObjName(batObj):
    faction = batObj.faction
    num = batObj.lineupNum
    posNum = batObj.posNum
    heroID = batObj.heroID
    if not heroID:
        heroID = batObj.npcID
    objName = GameWorld.CodeToGbk(batObj.GetName())
    return "%s%s-%s [%s-%s] %s" % ("A" if faction == ChConfig.Def_FactionA else "B", num, posNum, batObj.GetID(), heroID, objName)

def EntryLogic(turnFight):
    ## Ö´Ðнø³¡Âß¼­
    if turnFight.enterLogic:
        return
    GameWorld.DebugLog("Ö´Ðнø³¡Âß¼­...")
    
    turnFight.enterLogic = True
    return

def TurnFightObjPerTurnStart(turnFight, batObj, turnNum):
    ## »ØºÏÖÆÕ½¶·ÊµÀý - ÿ»ØºÏ¿ªÊ¼Ê±´¦Àí
    if not batObj:
        return
    
    if batObj.GetHP() <= 0:
        return
    
    curID = batObj.GetID()
    buffMgr = batObj.GetBuffManager()
    GameWorld.DebugLog("¸üÐÂbuff: curID=%s,buffCount=%s" % (curID, buffMgr.GetBuffCount()))
    for index in range(buffMgr.GetBuffCount()):
        buff = buffMgr.GetBuffByIndex(index)
        curRemainTime = buff.GetRemainTime()
        if not curRemainTime:
            # ÓÀ¾Ãbuff²»´¦Àí
            continue
        buffID = buff.GetBuffID()
        updRemainTime = curRemainTime - 1
        GameWorld.DebugLog("    ¸üÐÂbuffÊ£Óà»ØºÏÊý: buffID=%s,updRemainTime=%s" % (buffID, updRemainTime))
        if updRemainTime > 0:
            buff.SetRemainTime(curRemainTime - 1)
            TurnBuff.SyncBuffRefresh(turnFight, batObj, buff)
        else:
            TurnBuff.SyncBuffDel(turnFight, batObj, buffID)
            
#    SetTimeline(gameObj, turnNum, 0)
#    # ÖØÖÃÁ¬»÷¡¢·´»÷Êý
#    gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnComboNum, 0)
#    gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnAtkBackNum, 0)
#    gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnParryNum, 0)
#    gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnMissNum, 0)
#    gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnAtkAddXPCount, 0)
#    gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnXPUseState, 0)
#    gameObj.SetDict(ChConfig.Def_PlayerKey_AttrFaintCD, 0) # »÷ÔÎCD
#    
#    objType = gameObj.GetGameObjType()
#    objID = gameObj.GetID()
#    objName = GetObjName(gameObj)
#    GameWorld.DebugLog("ObjPerTurnStart: »ØºÏ%s, %s objType-ID-HP(%s-%s-%s)" % (turnNum, objName, objType, objID, GameObj.GetHP(gameObj)))
#    
#    # ÿ»ØºÏ¿ªÊ¼¼õ¼¼ÄÜCD
#    skillManager = gameObj.GetSkillManager()
#    for i in range(skillManager.GetSkillCount()):
#        skill = skillManager.GetSkillByIndex(i)
#        remainTime = skill.GetRemainTime()
#        if not remainTime:
#            continue
#        skillID = skill.GetSkillID()
#        updRemainTime = max(0, remainTime - ChConfig.Def_PerTurnTick)
#        skill.SetRemainTime(updRemainTime)
#        GameWorld.DebugLog("    skillID=%s,remainTime=%s,updRemainTime=%s" % (skillID, remainTime, updRemainTime))
#        
#    # ˢж¨Ê±´¦ÀíµÄbuffЧ¹û
#    SkillShell.ProcessPersistBuff(gameObj, tick)
#    
#    PassiveBuffEffMng.OnPassiveSkillTrigger(gameObj, tagObj, None, ChConfig.TriggerType_TurnNum, tick)
#    
#    __logGameObjAttr(gameObj)
    return

def AddTurnObjCureHP(curObj, srcObj, addValue, cureHP, skillID=0):
    ## »ØºÏ¶ÔÏóÌí¼ÓÖÎÁÆÖµ
    # @param curObj: »ñµÃÖÎÁƵĶÔÏó
    # @param srcObj: À´×ÔË­µÄÖÎÁÆ
    # @param addValue: ÖÎÁÆÖµ
    # @param cureHP: ʵ¼Ê»ØѪÁ¿
    if not srcObj:
        return
    curID = curObj.GetID()
    srcID = srcObj.GetID()
    updStatValue = srcObj.StatCureValue(cureHP)
    GameWorld.DebugLog("        ͳ¼ÆÖÎÁÆ: curID=%s,srcID=%s,skillID=%s,addValue=%s,cureHP=%s,updStatValue=%s" 
                   % (curID, srcID, skillID, addValue, cureHP, updStatValue))
        
    return

def AddTurnObjHurtValue(curBatObj, tagBatObj, hurtValue, lostHP, curSkill=None, isBounce=False):
    ## »ØºÏ¶ÔÏóÌí¼ÓÉ˺¦Öµ
    # @param isBounce: ÊÇ·ñ·´µ¯É˺¦
    curID = curBatObj.GetID()
    tagID = tagBatObj.GetID()
    skillID = curSkill.GetSkillID() if curSkill else 0
    if curID != tagID:
        updStatValue = curBatObj.StatHurtValue(hurtValue)
        GameWorld.DebugLog("        ͳ¼ÆÉËѪ: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,tagHP=%s,isBounce=%s" 
                       % (curID, tagID, skillID, hurtValue, lostHP, updStatValue, tagBatObj.GetHP(), isBounce))
        
        if tagBatObj:
            updStatValue = tagBatObj.StatDefValue(lostHP)
            GameWorld.DebugLog("        ͳ¼Æ³ÐÉË: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,curHP=%s,isBounce=%s" 
                           % (tagID, curID, skillID, hurtValue, lostHP, updStatValue, tagBatObj.GetHP(), isBounce))
            
    else:
        # È绻ѪÀ༼ÄÜ£¬×ԲеÄÉ˺¦²»ËãÊä³ö
        GameWorld.DebugLog("        ×Ô²Ð: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,curHP=%s" 
                           % (curID, tagID, skillID, hurtValue, lostHP, curBatObj.GetHP()))
    return

def OnObjAction(turnFight, curBatObj):
    ## Õ½¶·µ¥Î»Ðж¯
    if not curBatObj:
        return
    
    curHP = curBatObj.GetHP()
    objID = curBatObj.GetID()
    if curHP <= 0:
        return
    
    turnNum = turnFight.turnNum
    objName = GetObjName(curBatObj)
    
    # ÊÇ·ñ¿ÉÐж¯×´Ì¬ÅжÏ
    canAction = True
    
    if not canAction:
        GameWorld.DebugLog("¡ï»ØºÏ%s %s µ±Ç°×´Ì¬²»¿ÉÐж¯!" % (turnNum, objName))
        return
    
    GameWorld.DebugLog("¡ï»ØºÏ%s %s Ðж¯ : curHP=%s" % (turnNum, objName, curHP))
    turnFight.syncObjAction(turnNum, objID)
    
    curXP = curBatObj.GetXP()
    xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2) 
    skillManager = curBatObj.GetSkillManager()
    useSkillList = []
    #GameWorld.DebugLog('skillCount=%s' % skillManager.GetSkillCount(), npcID)
    for index in range(0, skillManager.GetSkillCount()):
        useSkill = skillManager.GetSkillByIndex(index)
        if not useSkill:
            continue
        if useSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_AtkbackSkill]:
            #»ù´¡ÆÕ¹¥²»ÄÜÖ÷¶¯ÊÍ·Å£¬Ä¿Ç°½öÓÃÓÚ·´»÷
            continue
        #±»¶¯¼¼ÄÜÎÞ·¨Ê¹ÓÃ
        if SkillCommon.isPassiveSkill(useSkill):
            continue
        #»¹ÔÚÀäȴʱ¼äÄÚÎÞ·¨ÊÍ·Å
        if useSkill.GetRemainTime():
            continue
        skillID = useSkill.GetSkillID()
        # ³£¹æ¹¥»÷ÓÅÏÈxp
        if SkillCommon.isAngerSkill(useSkill):
            if curXP < xpMax:
                continue
            useCnt = -1 # xp¼¼ÄÜÓÅÏÈÊÍ·Å
        else:
            useCnt = curBatObj.GetSkillUseCnt(skillID)
        useSkillList.append([useCnt, skillID, useSkill])
        
    useSkillList.sort() # °´Ê¹ÓôÎÊýÓÅÏÈÉýÐòÅÅ£¬Ê¹ÓôÎÊýµÍµÄÓÅÏÈÅжÏʹÓÃ
    #GameWorld.DebugLog('    ¼¼ÄÜʹÓÃ˳Ðò = useSkillList%s' % str(useSkillList), npcID)
    
    for useInfo in useSkillList:
        useSkill = useInfo[-1]
        if TurnSkill.OnUseSkill(turnFight, curBatObj, useSkill):
            return True
        
    return

def DoAttack(curBatObj, tagBatObj, tick, turnBattleType=ChConfig.TurnBattleType_Normal, useSkill=None):
#    curID = curBatObj.GetID()
#    npcID = curBatObj.GetNPCID()
#    objName = GetObjName(curBatObj)
#    GameWorld.DebugLog("    ¡ñ %s DoAttack: curID=%s,,turnBattleType=%s" % (objName, curID, turnBattleType))
#    
#    atkOK = False
#    curBatObj.SetDict(ChConfig.Def_Obj_Dict_TurnBattleType, turnBattleType)
#    
#    if turnBattleType == ChConfig.TurnBattleType_AtkBack:
#        if not tagBatObj:
#            return
#        skillManager = curBatObj.GetSkillManager()
#        for index in range(0, skillManager.GetSkillCount()):
#            skill = skillManager.GetSkillByIndex(index)
#            if not skill:
#                continue
#            if skill.GetFuncType() == ChConfig.Def_SkillFuncType_AtkbackSkill:
#                useSkill = skill
#                break
#        atkOK = SkillShell.DoLogic_UseSkill(curBatObj, tagBatObj, useSkill, tick)
#    elif turnBattleType == ChConfig.TurnBattleType_Combo:
#        if not tagBatObj:
#            return
#        atkOK = SkillShell.DoLogic_UseSkill(curBatObj, tagBatObj, useSkill, tick)
#    else:
#        curXP = GameObj.GetXP(curBatObj)
#        xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2) 
#        skillManager = curBatObj.GetSkillManager()
#        useSkillList = []
#        #GameWorld.DebugLog('skillCount=%s' % skillManager.GetSkillCount(), npcID)
#        for index in range(0, skillManager.GetSkillCount()):
#            useSkill = skillManager.GetSkillByIndex(index)
#            if not useSkill:
#                continue
#            if useSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_AtkbackSkill]:
#                #»ù´¡ÆÕ¹¥²»ÄÜÖ÷¶¯ÊÍ·Å£¬Ä¿Ç°½öÓÃÓÚ·´»÷
#                continue
#            #±»¶¯¼¼ÄÜÎÞ·¨Ê¹ÓÃ
#            if SkillCommon.isPassiveSkill(useSkill):
#                continue
#            #»¹ÔÚÀäȴʱ¼äÄÚÎÞ·¨ÊÍ·Å
#            if useSkill.GetRemainTime():
#                continue
#            skillID = useSkill.GetSkillID()
#            # ³£¹æ¹¥»÷ÓÅÏÈxp
#            if SkillCommon.isAngerSkill(useSkill) and turnBattleType == ChConfig.TurnBattleType_Normal:
#                if curXP < xpMax:
#                    continue
#                useCnt = -1 # xp¼¼ÄÜÓÅÏÈÊÍ·Å
#            else:
#                useCnt = curBatObj.GetDictByKey(ChConfig.Def_NPC_Dict_SkillUseCnt % skillID) # ¸Ã¼¼ÄÜÒÑʹÓôÎÊý
#            useSkillList.append([useCnt, index, skillID, useSkill])
#            
#        useSkillList.sort() # °´Ê¹ÓôÎÊýÓÅÏÈÉýÐòÅÅ£¬Ê¹ÓôÎÊýµÍµÄÓÅÏÈÅжÏʹÓÃ
#        #GameWorld.DebugLog('    ¼¼ÄÜʹÓÃ˳Ðò = useSkillList%s' % str(useSkillList), npcID)
#        
#        for useInfo in useSkillList:
#            useSkill = useInfo[-1]
#            #skillID = useSkill.GetSkillID()
#            atkOK, tagBatObj = OnUseSkill(curBatObj, useSkill, tick)
#            if atkOK:
#                break
#            
#    curBatObj.SetDict(ChConfig.Def_Obj_Dict_TurnBattleType, 0) # ÎÞÂÛ¹¥»÷³É¹¦Óë·ñ¶¼ÖØÖÃÕ½¶·ÀàÐÍ
#    
#    tagID = 0
#    tagHP = 0
#    if tagObj:
#        tagID = tagObj.GetID()
#        tagHP = GameObj.GetHP(tagObj)
#    GameWorld.DebugLog('        atkOK=%s,tagID=%s,tagHP=%s' % (atkOK, tagID, tagHP), npcID)
#    if not atkOK:
#        return
#    
#    if not tagObj:
#        return
#    
#    if GameObj.GetFaction(curNPC) == GameObj.GetFaction(tagObj):
#        # ͬÕóÓªÖ±½Ó·µ»Ø£¬²»´¦ÀíÁ¬»÷¡¢·´»÷
#        return True
#    
#    curHP = GameObj.GetHP(curNPC)
#    tagHP = GameObj.GetHP(tagObj)
#    tagID = tagObj.GetID()
#    GameWorld.DebugLog("            curID-HP=(%s-%s),tagID-HP=(%s-%s)" % (curID, curHP, tagID, tagHP))
#    if tagHP <= 0 or curHP <= 0:
#        return True
#    
#    # ·´»÷£¬·´»÷¿É´ò¶ÏÁ¬»÷£¬ËùÒÔÓÅÏÈÅжÏ
#    if CanAtkBack(curNPC, tagObj):
#        DoAttack(tagObj, curNPC, tick, ChConfig.TurnBattleType_AtkBack)
#        return True
#    
#    # Á¬»÷
#    if CanCombo(curNPC, tagObj):
#        DoAttack(curNPC, tagObj, tick, ChConfig.TurnBattleType_Combo, useSkill)
#        
    return True

def CanAtkBack(atkObj, defObj):
    ## ¿É·ñ·´»÷
    posNum = atkObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) % 100
    if posNum <= 0:
        GameWorld.DebugLog("            ±»·ÇÖ÷Õ½µ¥Î»¹¥»÷ʱÎÞ·¨´¥·¢·´»÷: atkID=%s,posNum=%s" % (atkObj.GetID(), posNum))
        return False
    atkDistType = AttackCommon.GetAtkDistType(defObj)
    if atkDistType == ChConfig.AtkDistType_Long:
        if not IpyGameDataPY.GetFuncCfg("ParryCfg", 2):
            GameWorld.DebugLog("            Ô¶³Ìµ¥Î»²»¿É·´»÷: defID=%s" % (defObj.GetID()))
            return False
    defAtkBackRate = GameObj.GetAtkBackRate(defObj) # ·À·½·´»÷ÂÊ
    atkBackNum = defObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnAtkBackNum) # ÒÑ·´»÷´ÎÊý
    if atkBackNum > 10:
        # ÄÚÖÃ×î¸ß·´»÷Êý·À·¶
        return False
    if atkBackNum > 0:
        validPerList = IpyGameDataPY.GetFuncEvalCfg("TurnFight", 4)
        vaildPer = validPerList[atkBackNum - 1] if len(validPerList) >= atkBackNum else 0
        defAtkBackRate = int(defAtkBackRate * vaildPer / 100.0)
        
    atkAtkBackDefRate = GameObj.GetAtkBackDefRate(atkObj) # ¹¥·½µÖ¿¹·´»÷ÂÊ
    atkBackRate = max(0, defAtkBackRate - atkAtkBackDefRate)
    if atkBackRate <= 0 or not GameWorld.CanHappen(atkBackRate):
        GameWorld.DebugLog("            ÎÞ·¨·´»÷: defID=%s,atkBackNum=%s,atkBackRate=%s=(defAtkBackRate=%s - atkAtkBackDefRate=%s)" 
                           % (defObj.GetID(), atkBackNum, atkBackRate, defAtkBackRate, atkAtkBackDefRate))
        return False
    GameWorld.DebugLog("            ¿ÉÒÔ·´»÷: defID=%s,atkBackNum=%s,atkBackRate=%s=(defAtkBackRate=%s - atkAtkBackDefRate=%s)" 
                       % (defObj.GetID(), atkBackNum, atkBackRate, defAtkBackRate, atkAtkBackDefRate))
    return True

def CanCombo(atkObj, defObj):
    ## ¿É·ñÁ¬»÷
    
    atkComboRate = GameObj.GetComboRate(atkObj) # ¹¥·½Á¬»÷ÂÊ
    comboNum = atkObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnComboNum) # ÒÑÁ¬»÷´ÎÊý
    if comboNum > 10:
        # ÄÚÖÃ×î¸ßÁ¬»÷Êý·À·¶
        return False
    if comboNum > 0:
        validPerList = IpyGameDataPY.GetFuncEvalCfg("TurnFight", 3)
        vaildPer = validPerList[comboNum - 1] if len(validPerList) >= comboNum else 0
        atkComboRate = int(atkComboRate * vaildPer / 100.0)
        
    defComboReduce = GameObj.GetComboDefRate(defObj) # ·À·½µÖ¿¹Á¬»÷ÂÊ
    comboRate = max(0, atkComboRate - defComboReduce)
    if comboRate <= 0 or not GameWorld.CanHappen(comboRate):
        GameWorld.DebugLog("            ÎÞ·¨Á¬»÷: atkID=%s,comboNum=%s,comboRate=%s=(atkComboRate=%s - defComboReduce=%s)" 
                           % (atkObj.GetID(), comboNum, comboRate, atkComboRate, defComboReduce))
        return False
    GameWorld.DebugLog("            ¿ÉÒÔÁ¬»÷: atkID=%s,comboNum=%s,comboRate=%s=(atkComboRate=%s - defComboReduce=%s)" 
                       % (atkObj.GetID(), comboNum, comboRate, atkComboRate, defComboReduce))
    return True

#def GetEnemyObj(curNPC, ruleType=0):
#    ## »ñÈ¡Ò»¸öµÐ¶Ôµ¥Î»£¬Õë¶ÔËùÓежÔÕóÈÝÖ÷Õ½µ¥Î»£¬ÓÅÏÈÑ¡Ôñ¶ÔλÕóÈݵ¥Î»£¬½öÏÞ»î×ŵĵ¥Î»
#    # @param ruleType: Ñ¡Ôñ¹æÔò£¬Ä¬ÈÏ0ÈÎÒ⣬1-×îµÍѪÁ¿£»2-×î¸ßѪÁ¿
#    objID = curNPC.GetID()
#    faction = GameObj.GetFaction(curNPC)
#    posInfo = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo)
#    num = posInfo / 100 # ÕóÈݱàºÅ
#    posNum = posInfo % 100 # ËùÔÚÕóÈÝվλ
#    turnFight = GetTurnFightMgr().getTurnFight(curNPC.GetTFGUID())
#    if not turnFight:
#        return
#    
#    tagBatFaction = turnFight.getBatFaction(Def_FactionB if faction == Def_FactionA else Def_FactionA)
#    
#    tagLineupNumList = [num] # Ä¿±êÕóÈÝÑ¡Ôñ˳Ðò£¬ÓÅÏȶÔλÕóÈÝ£¬ÔÙÆäËûÕóÈÝ
#    if num in tagBatFaction.lineupDict:
#        tagLineupNumList = [num]
#    for tagNum in tagBatFaction.lineupDict.keys():
#        if tagNum not in tagLineupNumList:
#            tagLineupNumList.append(tagNum)
#            
#    batObjMgr = BattleObj.GetBatObjMgr()
#    for tagNum in tagLineupNumList:
#        tagLineup = tagBatFaction.getBatlineup(tagNum)
#        tagPosNumList = [posNum] # ÓÅÏȶÔλλÖã¬ÔÙÆäËûλÖð´Ë³Ðò±éÀú
#        pNumList = tagLineup.posObjIDDict.keys()
#        pNumList.sort()
#        for pNum in pNumList:
#            if pNum > 0 and pNum not in tagPosNumList:
#                tagPosNumList.append(pNum)
#        for pNum in tagPosNumList:
#            batObj = batObjMgr.getBatObj(objID)
#            if not batObj:
#                continue
#            if batObj.GetHP( )<= 0:
#                continue
#            return batObj
#    return

def SetObjKilled(turnFight, gameObj, killer=None, useSkill=None):
    objID = gameObj.GetID()
    GameWorld.DebugLog("        %s »ØºÏÕ½¶·Ö÷Ìå±»»÷ɱ: curID=%s" % (GetObjName(gameObj), objID))
    gameObj.SetHP(0)
    killerObjID = killer.GetID() if killer else 0
    skillID = useSkill.GetSkillID() if useSkill else 0
    
    clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagMCTurnFightObjDead)
    clientPack.ObjID = objID
    clientPack.KillerObjID = killerObjID
    clientPack.SkillID = skillID
    turnFight.addBatPack(clientPack)        
    return True

def OnTurnAllOver(guid):
    ## ËùÓлغÏÒѾ­È«²¿Ö´ÐÐÍê±Ï
    GameWorld.DebugLog("ËùÓлغϽáÊø")
    turnFight = GetTurnFightMgr().getTurnFight(guid)
    if not turnFight:
        return
    
    if turnFight.winFaction:
        return
    
    if turnFight.playerID:
        # Íæ¼Ò·¢ÆðµÄ£¬Î´»÷ɱ¶Ô·½£¬ËãÍæ¼ÒÊä
        turnFight.winFaction = ChConfig.Def_FactionB
    else:
        # ϵͳ³¡´Î£¬°´Ò»¶¨¹æÔòÀ´£¬ÕâÀïÏÈËæ»ú
        turnFight.winFaction = random.choice([ChConfig.Def_FactionA, ChConfig.Def_FactionB])
        
    DoTurnFightOver(guid)
    return

def DoTurnFightOver(guid):
    ## Ö´ÐлغÏÕ½¶·½áËãÂß¼­
    tfMgr = GetTurnFightMgr()
    turnFight = tfMgr.getTurnFight(guid)
    if not turnFight:
        return
    
    turnFight.costTime = time.time() - turnFight.startTime
    winFaction = turnFight.winFaction
    GameWorld.DebugLog("--- Õ½¶·½áÊø´¦Àí --- %s, winFaction=%s, costTime=%ss" % (guid, winFaction, turnFight.costTime))
    
    # ͳ¼ÆÃ÷ϸ
    batObjMgr = BattleObj.GetBatObjMgr()
    statInfo = {}
    for faction in turnFight.factionDict.keys():
        if str(faction) not in statInfo:
            statInfo[str(faction)] = {}
        facStatInfo = statInfo[str(faction)]
        batFaction = turnFight.getBatFaction(faction)
        for num in batFaction.lineupDict.keys():
            if str(num) not in facStatInfo:
                facStatInfo[str(num)] = {}
            lineupStatInfo = facStatInfo[str(num)]
            batLineup = batFaction.getBatlineup(num)
            GameWorld.DebugLog("ÕóÈÝÃ÷ϸ: faction=%s,num=%s" % (faction, num))
            for posNum, objID in batLineup.posObjIDDict.items():
                batObj = batObjMgr.getBatObj(objID)
                if not batObj:
                    continue
                objID = batObj.GetID()
                npcID = batObj.GetNPCID()
                heroID = batObj.GetHeroID()
                atkHurt = batObj.hurtStat
                defHurt = batObj.defStat
                cureHP = batObj.cureStat
                GameWorld.DebugLog("    Pos:%s ID=%s-%s-%s,,HP=%s/%s, Êä³ö=%s,³ÐÉË=%s,ÖÎÁÆ=%s" 
                                   % (posNum, objID, npcID, heroID, batObj.GetHP(), batObj.GetMaxHP(), atkHurt, defHurt, cureHP))
                lineupStatInfo[str(posNum)] = {"ObjID":objID, "HeroID":heroID, "NPCID":npcID, "AtkHurt":atkHurt, "DefHurt":defHurt, "CureHP":cureHP}
                
    awardItemList = []
    playerID = turnFight.playerID
    if playerID:
        curPlayer = turnFight.curPlayer
        isWin = (winFaction == ChConfig.Def_FactionA)
        # Ö÷ÏßС¹Ö
        if turnFight.mapID == ChConfig.Def_FBMapID_Main:
            OnOver_MainLevel(curPlayer, isWin, awardItemList)
        # Ö÷Ïßboss
        elif turnFight.mapID == ChConfig.Def_FBMapID_MainBoss:
            OnOver_MainLevelBoss(curPlayer, isWin, awardItemList)    
        else:
            pass
        
    overMsg = {"winFaction":winFaction, "statInfo":statInfo, FBCommon.Over_itemInfo:FBCommon.GetJsonItemList(awardItemList)}
    turnFight.syncState(FightState_Award, overMsg)
    
    # ³ýÁËÖ÷ÏßÍ⣬ÆäÓàÕ½¶·½áÊøºó¾ùÖ±½Óɾ³ý
    if not turnFight.playerID:
        tfMgr.delTurnFight(guid)
    return

def OnOver_MainLevel(curPlayer, isWin, awardItemList):
    ## Õ½¶·½áÊø¶îÍâ´¦Àí - Ö÷Ï߹ؿ¨
    if not curPlayer:
        return
    playerID = curPlayer.GetPlayerID()
    mainFightMgr = GetMainFightMgr(curPlayer)
    mainFightMgr.nextTeam = False
    chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)
    
    if not isWin:
        nextWave = max(1, wave - 1)
        nowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, nextWave)
        GameWorld.DebugLog("Ö÷ÏßС¹ÖÕ½¶·Ê§°Ü£¬½µÒ»²¨! chapterID=%s,levelNum=%s,wave=%s,nextWave=%s,nowValue=%s" 
                           % (chapterID, levelNum, wave, nextWave, nowValue), playerID)
        return
    
    if mainFightMgr.teamNum < mainFightMgr.teamMax:
        mainFightMgr.nextTeam = True
        GameWorld.DebugLog("Ö÷ÏßС¹ÖÕ½¶·Ê¤Àû£¬ÏÂһС¶Ó! chapterID=%s,levelNum=%s,wave=%s,teamNum=%s/%s" 
                           % (chapterID, levelNum, wave, mainFightMgr.teamNum, mainFightMgr.teamMax), playerID)
        return
    
    # »ñʤ¹ý²¨
    if wave < mainFightMgr.waveMax:
        nextWave = min(mainFightMgr.waveMax, wave + 1)
        nowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, nextWave)
        GameWorld.DebugLog("Ö÷ÏßС¹Ö²¨Õ½¶·Ê¤Àû£¬ÏÂÒ»²¨! chapterID=%s,levelNum=%s,wave=%s,nextWave=%s,nowValue=%s" 
                           % (chapterID, levelNum, wave, nextWave, nowValue), playerID)
    else:
        GameWorld.DebugLog("Ö÷ÏßС¹Ö²¨Õ½¶·Ê¤Àû£¬×îºóÒ»²¨Ñ­»·Ë¢! chapterID=%s,levelNum=%s,wave=%s" % (chapterID, levelNum, wave), playerID)
        
    # С¹Ö¿ÉÄÜ»áÍ˲¨£¬ËùÒÔÖ»ÔÚÓг¬¹ýÒѹý¹Ø¿¨½ø¶Èʱ²Å¸üÐÂÖµ
    hisPassValue = PlayerControl.GetMainLevelPassValue(curPlayer)
    curPassValue = PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
    if curPassValue > hisPassValue:
        GameWorld.DebugLog("¸üе±Ç°¹ý¹Ø½ø¶È! curPassValue=%s,hisPassValue=%s" % (curPassValue, hisPassValue), playerID)
        PlayerControl.SetMainLevelPassValue(curPlayer, curPassValue)
    else:
        GameWorld.DebugLog("䳬¹ýµ±Ç°¹ý¹Ø½ø¶È£¬²»¸üÐÂ! curPassValue=%s <= hisPassValue=%s" % (curPassValue, hisPassValue), playerID)
        
    return

def OnOver_MainLevelBoss(curPlayer, isWin, awardItemList):
    ## Õ½¶·½áÊø¶îÍâ´¦Àí - Ö÷Ï߹ؿ¨boss
    if not curPlayer:
        return
    playerID = curPlayer.GetPlayerID()
    mainFightMgr = GetMainFightMgr(curPlayer)
    mainFightMgr.nextTeam = False
    chapterID, levelNum, _ = PlayerControl.GetMainLevelPassInfo(curPlayer)
    if not isWin:
        nowValue = PlayerControl.GetMainLevelNowValue(curPlayer)
        GameWorld.DebugLog("Ö÷ÏßbossÕ½¶·Ê§°Ü£¡±£³Öµ±Ç°Ë¢¹Ö²¨½ø¶È²»±ä! nowValue=%s" % nowValue, playerID)
        return
    
    if mainFightMgr.teamNum < mainFightMgr.teamMax:
        mainFightMgr.nextTeam = True
        GameWorld.DebugLog("Ö÷ÏßbossС¶ÓÕ½¶·Ê¤Àû£¬ÏÂһС¶Ó! chapterID=%s,levelNum=%s,teamNum=%s/%s" 
                           % (chapterID, levelNum, mainFightMgr.teamNum, mainFightMgr.teamMax), playerID)
        return
    
    isAllPass = False # ÊÇ·ñͨ¹Ø
    if IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID, levelNum + 1):
        nextChapterID, nextLevelNum = chapterID, levelNum + 1
        GameWorld.DebugLog("Ö÷Ïßboss²¨Õ½¶·Ê¤Àû£¡ÏÂÒ»¹Ø! chapterID=%s,levelNum=%s,nextLevelNum=%s" 
                           % (chapterID, levelNum, nextLevelNum), playerID)
    elif IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID + 1, 1):
        nextChapterID, nextLevelNum = chapterID + 1, 1
        GameWorld.DebugLog("Ö÷Ïßboss²¨Õ½¶·Ê¤Àû£¡ÏÂÒ»ÕÂ! chapterID=%s,levelNum=%s,nextChapterID=%s,nextLevelNum=%s" 
                           % (chapterID, levelNum, nextChapterID, nextLevelNum), playerID)
    else:
        # ÒÑͨ¹ØµÄÔÝʱÏȱ£³Ö²»±ä
        # ×¢Òâ·À·¶×îºóÒ»¹Ø½±ÀøÖظ´»ñµÃ
        nextChapterID, nextLevelNum = chapterID + 1, 1
        GameWorld.DebugLog("Ö÷Ïßboss²¨Õ½¶·Ê¤Àû£¡ÒÑͨ¹Ø! chapterID=%s,levelNum=%s,nextChapterID=%s,nextLevelNum=%s" 
                            % (chapterID, levelNum, nextChapterID, nextLevelNum), playerID)
        isAllPass = True
        
    updPassValue = PlayerControl.SetMainLevelPassInfo(curPlayer, nextChapterID, nextLevelNum, 0)
    if isAllPass:
        # ÒÑͨ¹ØµÄË¢¹Ö½ø¶È±£³Ö²»±ä
        updNowValue = PlayerControl.GetMainLevelNowValue(curPlayer)
        GameWorld.DebugLog("ÒÑͨ¹ØµÄË¢¹Ö½ø¶È±£³Ö²»±ä: updNowValue=%s" % updNowValue, playerID)
    else:
        updNowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, nextChapterID, nextLevelNum, 1)
        GameWorld.DebugLog("Ϊͨ¹ØµÄË¢¹Ö½ø¶ÈÉèÖÃΪÏÂÒ»¹ØµÄµÚ1²¨: updNowValue=%s" % updNowValue, playerID)
    GameWorld.DebugLog("updPassValue=%s,updNowValue=%s" % (updPassValue, updNowValue), playerID)
    
    # ·¢·Å¹ý¹Ø½±Àø
    levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
    if not levelIpyData:
        return
    itemList = levelIpyData.GetAwardItemList()
    GameWorld.DebugLog("¹ý¹Ø½±Àø: chapterID=%s,levelNum=%s,itemList=%s" % (chapterID, levelNum, itemList), playerID)
    
    ItemControler.GivePlayerItemOrMail(curPlayer, itemList, event=["MainLevelBoss", False, {}], isNotifyAward=False)
    
    awardItemList += itemList
    return


#// B4 14 ²é¿´Õ½±¨ #tagCSTurnFightReportView
#
#struct    tagCSTurnFightReportView
#{
#    tagHead        Head;
#    char        GUID[40];    //Õ½±¨guid
#};
def OnTurnFightReportView(index, clientData, tick):
    return