389 流向记录（增加GM工具命令：重读配置 GMT_ReloadConfig）

hxp

7 天以前 acebf38b40565a700efeecddb2e3f6e2b2e183a6

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Attack/TurnAttack.py

@@ -21,11 +21,17 @@


import ChConfig

import PlayerTask

import PlayerActivity

import PlayerViewCache

import ChPyNetSendPack

import NetPackCommon

import PlayerControl

import GameWorld

import PlayerLLMJ

import PlayerPrestigeSys

import CrossServerPackLogic

import DataRecordPack

import PlayerSuccess

import IpyGameDataPY

import PlayerOnline

import NPCCommon

@@ -36,15 +42,17 @@
import TurnPassive

import TurnSkill

import TurnBuff

import FBCommon

import CommFunc

import ObjPool

import FBLogic



import random

import time

import json

import os



TimelineSet = 10000 # 单回合最大时间轴

g_gmTestFightReq = []



PosNumMax = 7 # 最大站位编号

ActionNumStart = -1 # 起始行动位置编号，一般是从1开始，如果有加主公、红颜等则扣除相应位置值，如从0或-1开始



@@ -67,15 +75,22 @@
        self.faction = faction # 所属阵营

        self.num = num # 该阵容所在阵营中的编号，不同阵营可重复，多V多

        self.ownerID = 0 # 阵容所属玩家ID，可能为0，0代表非玩家阵容

        self.lineupInfo = {} # 传入初始化的阵容信息

        self.shapeType = 0 # 阵型

        self.fightPower = 0 # 阵容总战力

        self.posObjIDDict = {} # 站位对应战斗实体 {站位编号:batObjID, ...}, 站位编号小于0为非主战单位，如主公、红颜等

        self.heroObjIDDict = {} # 武将ID对应ObjID {heroID:batObjID, ...}

        self.lingshouObjIDDict = {} # 灵兽战斗单位 {位置编号:batObjID, ...}

        self.beautyObjIDDict = {} # 红颜战斗单位 {位置编号:batObjID, ...}

        self.actionNum = ActionNumStart # 行动位置，从1开始

        self.totalHurt = 0 # 阵容总输出

        
        #特殊

        self.bossID = 0

        self.bossPosView = 0

        return

    

    def getPlayerID(self): return self.turnFight.playerID # 发起的玩家ID

    def getReqPlayerID(self): return self.turnFight.getReqPlayerID() # 发起的玩家ID

    

    def isEmpty(self): return not self.posObjIDDict

    

@@ -83,10 +98,13 @@
        ## 设置阵容

        # @param lineupInfo: 阵容信息

        self.clearLineup()

        self.lineupInfo = lineupInfo

        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())

        self.bossID = lineupInfo.get("BossID", 0)

        self.bossPosView = lineupInfo.get("BossPosView", 0)

        SummonLineupObjs(self, self.faction, self.num, lineupInfo, self.getReqPlayerID())

        return

    

    def clearLineup(self):

@@ -98,11 +116,27 @@
            batObjMgr.delBatObj(objID)

        for objID in self.beautyObjIDDict.values():

            batObjMgr.delBatObj(objID)

        self.lineupInfo = {}

        self.posObjIDDict = {}

        self.heroObjIDDict = {}

        self.lingshouObjIDDict = {}

        self.beautyObjIDDict = {}

        self.fightPower = 0

        self.totalHurt = 0

        return

    
    def getDeadObjCnt(self):

        ## 获取本阵容目前死亡队员数

        deadCnt = 0

        batObjMgr = BattleObj.GetBatObjMgr()

        for objID in self.posObjIDDict.values():

            batObj = batObjMgr.getBatObj(objID)

            if not batObj:

                continue

            if batObj.IsAlive():

                continue

            deadCnt += 1

        return deadCnt

    

class BatFaction():

    ## 战斗阵营

@@ -111,6 +145,7 @@
        self.turnFight = turnFight # TurnFight

        self.faction = faction

        self.lineupDict = {} # 该阵营所有阵容信息 {编号:BatLineup, ...}

        self.totalHurt = 0 # 阵营总输出

        return

    

    def getBatlineup(self, num=1):

@@ -122,6 +157,8 @@
            lineup = BatLineup(self.faction, num, self.turnFight)

            self.lineupDict[num] = lineup

        return lineup

    
    def getTotalHurt(self): return self.totalHurt # 阵营总输出

    

    def clearLineups(self):

        ## 清除所有战斗阵容

@@ -140,26 +177,30 @@
    2. 以单阵容方式轮流出场战斗，该方式同样可以使用方式1的逻辑实现，固优先使用方式1战斗逻辑，方便扩展

    '''

    

    def __init__(self, mapID=0, funcLineID=0, playerID=0, isNeedReport=False):

        self.guid = GameWorld.GetGUID() # 某场战斗的唯一guid，可用于存储记录如战报等

        self.playerID = playerID # 可能为0，系统后台自动处理的战斗时为0，某个玩家发起则为发起玩家ID，同个玩家ID可能同时存在多场战斗，如主线+其他

        self.curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID) if playerID else None

    def __init__(self, guid, mapID=0, funcLineID=0, reqPlayerID=0, reqServerID=0):

        self.guid = guid # 某场战斗的唯一guid，可用于存储记录如战报等

        self._reqPlayerID = reqPlayerID # 可能为0，系统后台自动处理的战斗时为0，某个玩家发起则为发起玩家ID，同个玩家ID可能同时存在多场战斗，如主线+其他

        self._reqServerID = reqServerID # 可能是玩家的服务器ID，或者请求的ServerID

        self.curPlayer = None

        self.mapID = mapID

        self.funcLineID = funcLineID

        self.state = -1 # -1 代表未战斗

        self.turnNum = 1 # 当前第x回合，默认第1回合开始

        self.turnMax = 15 # 最大回合数

        self.turnNumStart = 0 # 已处理第x回合开始

        self.enterLogic = False # 是否已执行进场逻辑

        self.winFaction = 0 # 本场战斗结束标记，获胜阵营，为0时代表未结束，所有小队打完或失败才有结果，0-未结束，>0-获胜的阵营

        self.isWin = False

        self.batBuffer = "" # 战报buffer，战报暂时只保留最后一个小队的

        self.isNeedReport = isNeedReport # 是否需要战报

        self.dateStr = "" # 战报所在文件夹日期

        self._isNeedReport = False # 是否需要战报

        self.statMsg = {} # 战斗结果统计信息

        self.msgDict = {} # 扩展信息字典，一般由MapID绑定的功能决定信息内容  {k:v, ...}

        self._kvDict = {} # 自定义信息字典，不会被重置  {k:v, ...}

        

        self.factionDict = {} # 战斗阵营 {faction:BatFaction, ...}，一般是只有两个阵营，faction为1或2，每个阵营支持多个阵容

        self.actionSortList = [] # 阵容行动顺序 [[faction, num], ...]

        self.actionIndex = 0 # 行动顺序索引        
        self.timeline = 0 # 时间轴节点  turnNum*1000+actionIndex*100++actionNum

        self.actionIndex = 0 # 行动顺序索引

        self.startTime = 0 # 开始时间戳，支持毫秒小数

        self.costTime = 0 # 单场战斗总耗时，支持毫秒小数

        self._oneActionUseSkillCntDict = {} # 某对象行动开始后所有对象累计使用技能次数，用于单对象单次行动中限制每个对象的最高触发技能次数 {objID:useCnt, ...}

@@ -170,50 +211,59 @@
        self.strongerLV = 0 # npc成长等级

        self.difficulty = 0 # npc难度

        

        # pvp 目标

        self.tagPlayerID = 0

        self.tagViewCache = None

        # pvp

        self._isPVP = False

        return

    

    def setTurnFight(self, mapID, funcLineID, turnMax, isNeedReport=False, msgDict={}):

    def setTurnFight(self, mapID, funcLineID, turnMax, isNeedReport=False, curPlayer=None, msgDict={}):

        ## 设置本场回合战斗设定

        self.mapID = mapID

        self.funcLineID = funcLineID

        self.turnMax = turnMax # 最大回合数

        self.isNeedReport = isNeedReport

        self._isNeedReport = isNeedReport

        self.curPlayer = curPlayer

        self.setPVE()

        self.setPVP()

        self.msgDict = {}

        self._kvDict = {}

        self.nextTurnFight(msgDict)

        return

    
    def getReqPlayerID(self): return self._reqPlayerID

    def getReqServerID(self): return self._reqServerID

    

    def setPVE(self, lineupIDList=[], strongerLV=0, difficulty=0):

        self.lineupIndex = 0

        self.lineupIDList = lineupIDList

        self.strongerLV = strongerLV

        self.difficulty = difficulty

        self._isPVP = False

        return

    

    def setPVP(self, tagPlayerID=0, tagViewCache=None):

        self.tagPlayerID = tagPlayerID

        self.tagViewCache = tagViewCache

    def setPVP(self):

        self._isPVP = True

        return

    

    #def setPVPTeam(self):

    #    return

    def isPVP(self): return self._isPVP

    

    def nextTurnFight(self, msgDict={}, resetByNextTeam=False):

    def isFBMap(self):

        ## 是否副本地图中，非主线的均视为副本

        return self.mapID not in [ChConfig.Def_FBMapID_Main, ChConfig.Def_FBMapID_MainBoss]

    
    def GetDictByKey(self, key): return self._kvDict.get(key, 0)

    def SetDict(self, key, value): self._kvDict[key] = value

    
    def nextTurnFight(self, msgDict={}):

        ## 一般用于玩家发起的战斗，在需要保留玩家阵容属性及状态的情况下，重置回合进入下一场战斗

        self.turnNum = 1

        self.turnNumStart = 0

        self.enterLogic = False

        self.winFaction = 0

        self.isWin = False

        self.msgDict.update(msgDict)

        self.timeline = 0

        self.startTime = time.time()

        self.costTime = 0

        if resetByNextTeam:

            ResetByNextTeam(self)

        ResetByNextTeam(self)

        return

    

    def haveNextLineup(self):

@@ -255,24 +305,9 @@
        for _, _, _, faction, num in sortList:

            self.actionSortList.append([faction, num])

            

        GameWorld.DebugLog("阵容战力排序[isPlayer, fp, sortV, f, n]: %s" % sortList)

        GameWorld.DebugLog("阵容行动顺序[f, n]: %s" % self.actionSortList)

        GameWorld.DebugLogEx("阵容战力排序[isPlayer, fp, sortV, f, n]: %s", sortList)

        GameWorld.DebugLogEx("阵容行动顺序[f, n]: %s", self.actionSortList)

        return

    
    def getTurnNumStartTimelin(self, turnNum): return turnNum * TimelineSet + 0 # 每回合的时间节点起点

    def getTimeline(self): return self.timeline

    def setTimeline(self, timeline, isEmpty=False):

        '''回合战斗的时间轴节点 ，即第几回合开始，每个回合支持9999个行动节点

        @param turnNum: 第x回合

        '''

        self.timeline = timeline

        GameWorld.DebugLog("[时间节点更新]: %s" % self.timeline)

        if isEmpty:

            # 空位置的节点可直接跳过

            return timeline

        
        OnTimelineChange(self)

        return timeline

    

    def getBatFaction(self, faction=ChConfig.Def_FactionA):

        ## 默认阵营1

@@ -309,7 +344,10 @@
                        break

                    

            if allKilled:

                self.winFaction = ChConfig.Def_FactionA if faction == ChConfig.Def_FactionB else ChConfig.Def_FactionB

                if self.mapID in ChConfig.PlayerWinMapIDList:

                    self.winFaction = ChConfig.Def_FactionA

                else:

                    self.winFaction = ChConfig.Def_FactionA if faction == ChConfig.Def_FactionB else ChConfig.Def_FactionB

                DoTurnFightOver(self.guid)

                return self.winFaction

            

@@ -327,7 +365,7 @@
        ## 准备就绪，开始战斗

        self.state = FightState_Start

        self.turnNum = 1

        self.timeline = self.getTurnNumStartTimelin(self.turnNum)

        self.turnNumStart = 0

        self.syncInit()

        return

    

@@ -372,7 +410,10 @@
                    tfObj.MaxHP = batObj.GetMaxHP() % ChConfig.Def_PerPointValue

                    tfObj.MaxHPEx = batObj.GetMaxHP() / ChConfig.Def_PerPointValue

                    tfObj.LV = batObj.GetLV()

                    tfObj.PosNum = posNum

                    if batLineup.bossPosView and batLineup.bossID == batObj.GetNPCID():

                        tfObj.PosNum = batLineup.bossPosView

                    else:

                        tfObj.PosNum = posNum                        
                    tfObj.AngreXP = batObj.GetXP()

                    tfLineup.ObjList.append(tfObj)

                tfLineup.ObjCnt = len(tfLineup.ObjList)

@@ -383,8 +424,15 @@
        self.addBatPack(clientPack)

        return

    

    def syncHelp(self, msgDict):

        ## 通知帮助信息，一般是副本用

        self.syncState(self.state, msgDict)

        return

    
    def syncState(self, state, msgDict={}):

        self.state = state

        if state == FightState_Award:

            self.statMsg = msgDict

        msg = json.dumps(msgDict, ensure_ascii=False)

        msg = msg.replace(" ", "")

        clientPack = ChPyNetSendPack.tagMCTurnFightState()

@@ -413,20 +461,18 @@
            headStr = "%02x%02x" % (clientPack.Head.Cmd, clientPack.Head.SubCmd)

        else:

            headStr = "%02x%02x" % (clientPack.Cmd, clientPack.SubCmd)

        if self.isNeedReport:

        if self._isNeedReport:

            packBuff = clientPack.GetBuffer()

            buffLen = len(packBuff)

            GameWorld.DebugLog("回合战斗过程封包: %s, len:%s" % (headStr, buffLen))

            #GameWorld.DebugLogEx("回合战斗过程封包: %s, len:%s, %s", headStr, buffLen, CommFunc.B2Hex(packBuff))

            GameWorld.DebugLogEx("回合战斗过程封包: %s, len:%s", headStr, buffLen)

            self.batBuffer += CommFunc.WriteWORD("", buffLen)

            self.batBuffer += packBuff

            ObjPool.GetPoolMgr().release(clientPack)

        else:

            GameWorld.DebugLog("回合战斗过程封包: %s" % (headStr))

            GameWorld.DebugLogEx("回合战斗过程封包: %s", headStr)

            # 有玩家的统一每个包单独发送，同样也支持战报统计

            if self.curPlayer:

                NetPackCommon.SendFakePack(self.curPlayer, clientPack)

            else:

                ObjPool.GetPoolMgr().release(clientPack)

        return

    

    def ResetOneActionUseSkillCnt(self): self._oneActionUseSkillCntDict = {}

@@ -439,13 +485,14 @@
    ## 回合战斗管理器

    

    def __init__(self):

        self.lastRequestTick = 0

        self.turnFightDict = {} # {guid:TurnFight, ...}

        return

    

    def addTurnFight(self, mapID, funcLineID=0, playerID=0, isNeedReport=False):

        tf = ObjPool.GetPoolMgr().acquire(TurnFight, mapID, funcLineID, playerID, isNeedReport)

    def addTurnFight(self, guid, mapID, funcLineID=0, reqPlayerID=0, reqServerID=0):

        tf = TurnFight(guid, mapID, funcLineID, reqPlayerID, reqServerID)

        if not tf:

            tf = TurnFight(mapID, funcLineID, playerID, isNeedReport) # 一般是不可能，为了点出代码

            tf = TurnFight(guid, mapID, funcLineID, reqPlayerID, reqServerID) # 一般是不可能，为了点出代码

        self.turnFightDict[tf.guid] = tf

        return tf

    

@@ -455,7 +502,6 @@
            return

        turnFight.exitFight()

        self.turnFightDict.pop(guid, None)

        ObjPool.GetPoolMgr().release(turnFight)

        return

    

    def getTurnFight(self, guid):

@@ -484,7 +530,19 @@
        self.levelNum = 0 # 关卡编号

        self.waveMax = 6 # 本关最大波数，每波有多个小队，每个小队即为一张战斗 TurnFight

        self.wave = 0 # 当前刷怪波，注意不是玩家当前进度波，比如被击杀会回退一波

        self.turnFight = GetTurnFightMgr().addTurnFight(ChConfig.Def_FBMapID_Main, 0, playerID)

        self.turnFight = GetTurnFightMgr().addTurnFight(GameWorld.GetGUID(), ChConfig.Def_FBMapID_Main, 0, playerID)

        
        # 主线小怪战斗额外数据，一般用于分割与主线战斗表现无关的附加功能内容

        self.useZhanchui = 0

        self.mjExp = 0 # 历练秘笈额外经验

        self.killNPCCnt = 0

        return

    
    def resetMainFightExDataRec(self):

        ## 重置主线战斗相关的额外数据记录，每次前端请求主线小怪战斗处理后需要重置

        self.useZhanchui = 0

        self.mjExp = 0

        self.killNPCCnt = 0

        return

    

    def isLevelBoss(self):

@@ -526,8 +584,8 @@
    ## 获取玩家阵容

    olPlayer = PlayerOnline.GetOnlinePlayer(curPlayer)

    lineup = olPlayer.GetLineup(lineupID)

    if not lineup.lineupHeroDict:

        # 为空时默认取主阵容

    if lineup.IsEmpty():

        GameWorld.DebugLogEx("玩家没有目标阵容默认取主阵容! lineupID=%s", lineupID, curPlayer.GetPlayerID())

        lineup = olPlayer.GetLineup(ShareDefine.Lineup_Main)

    return lineup



@@ -538,22 +596,24 @@
    

    playerID = curPlayer.GetPlayerID()

    lineup = GetPlayerLineup(curPlayer, lineupID)

    if not lineup.lineupHeroDict:

    if lineup.IsEmpty():

        return {}

    

    heroDict = {}

    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)

    for posNum in lineup.lineupHeroDict.keys():

    for posNum in lineup.GetPosNumList():

        hero = lineup.GetLineupHero(posNum)

        heroID = hero.heroID

        itemIndex = hero.itemIndex

        userData = ""

        heroLV = 1

        star = 0

        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)

                star = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)

                #breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)

                #awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)

                

        skillIDlist = []

        skillIDlist += hero.heroSkillIDList

@@ -561,7 +621,9 @@
                                 "HeroID":heroID,

                                 "SkinID":hero.skinID,

                                 "LV":heroLV,

                                 "Data":userData,

                                 "Star":star,

                                 #"BreakLV":breakLV,

                                 #"AwakeLV":awakeLV,

                                 "FightPower":hero.fightPower,

                                 "AttrDict":{str(k):v for k, v in hero.heroBatAttrDict.items() if v > 0},

                                 "SkillIDList":skillIDlist,

@@ -578,13 +640,18 @@
    # @param lineupID: 阵容ID

    # @param npcLV: 成长NPC等级

    # @param difficulty: 成长NPC难度系数

    # @return: 阵容全部信息json字典，前端通用格式

    # @return: 阵容全部信息json字典，前端通用格式    
    lineupInfo = GetGMTestNPCLineupInfo(lineupID, strongerLV, difficulty)

    if lineupInfo:

        return lineupInfo

    ipyData = IpyGameDataPY.GetIpyGameData("NPCLineup", lineupID)

    if not ipyData:

        return {}

    bossID = ipyData.GetBossID()

    bossPosView = ipyData.GetBossPosView()

    

    heroDict = {}

    for posNum in range(1, 1 + 10):

    for posNum in range(1, 1 + 6):

        if not hasattr(ipyData, "GetPosNPCID%s" % posNum):

            break

        npcID = getattr(ipyData, "GetPosNPCID%s" % posNum)()

@@ -595,9 +662,114 @@
            continue

        heroDict[str(posNum)] = battleDict

        

    lineupInfo = {"NPCLineupID":lineupID, "Hero":heroDict}

    lineupInfo = {"NPCLineupID":lineupID, "Hero":heroDict, "BossID":bossID, "BossPosView":bossPosView}

    return lineupInfo



def GMTestPVP(curPlayer, tagPlayerID=0):

    ## GM测试PVP战斗

    if not tagPlayerID:

        tagPlayerID = curPlayer.GetPlayerID()

        
    guid = GameWorld.GetGUID()

    mapID, funcLineID = 0, 0

    
    tagViewCache = PlayerViewCache.FindBattleViewCache(tagPlayerID)

    if not tagViewCache:

        PlayerControl.NotifyCode(curPlayer, "TagNoViewCache")

        return

    defLineupInfo = GetCacheLineupInfo(tagViewCache, ShareDefine.Lineup_Main)

    lineupDictA = {1:GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)}

    lineupDictB = {1:defLineupInfo}

    turnFight = DoTurnFightPVP(guid, mapID, funcLineID, lineupDictA, lineupDictB)

    return turnFight.costTime if turnFight else None



def GMTestFight(curPlayer, heroIDList, isAllSkill):

    ## GM测试战斗，指定武将

    global g_gmTestFightReq

    g_gmTestFightReq = [heroIDList, isAllSkill]

    __doMainLevelWave(curPlayer, True)

    g_gmTestFightReq = []

    return



def GetGMTestNPCLineupInfo(lineupID, strongerLV=0, difficulty=0):

    ## 获取GM测试战斗阵容信息

    if not g_gmTestFightReq:

        return

    heroIDList, isAllSkill = g_gmTestFightReq

    
    lineupIpyData = IpyGameDataPY.GetIpyGameData("NPCLineup", lineupID)

    if not lineupIpyData:

        return

    
    npcDict = {}

    heroNPCIDDict = {}

    for posNum in range(1, 1 + 6):

        if not hasattr(lineupIpyData, "GetPosNPCID%s" % posNum):

            break

        npcID = getattr(lineupIpyData, "GetPosNPCID%s" % posNum)()

        if not npcID:

            continue

        battleDict = GetNPCBattleDict(lineupIpyData, npcID, strongerLV, difficulty)

        if not battleDict:

            continue

        npcDict[npcID] = battleDict

        heroID = battleDict["HeroID"]

        heroNPCIDDict[heroID] = npcID

        
    if not npcDict:

        return

    
    heroDict = {}

    # 原先阵容刚好有的直接用

    for posNum, heroID in enumerate(heroIDList, 1):

        if heroID not in heroNPCIDDict:

            continue

        npcID = heroNPCIDDict[heroID]

        heroDict[str(posNum)] = npcDict[npcID]

        heroIDList[posNum - 1] = 0

        
    lineupNPCID = npcDict.keys()[0]

    ipyNPCIDList = []

    ipyHeroIDList = []

    ipyDataMgr = IpyGameDataPY.IPY_Data()

    for index in xrange(ipyDataMgr.GetNPCCount()):

        ipyData = ipyDataMgr.GetNPCByIndex(index)

        heroID = ipyData.GetRelatedHeroID()

        npcID = ipyData.GetNPCID()

        ipyNPCIDList.append(npcID)

        ipyHeroIDList.append(heroID)

        
    lineupNPCIndex = ipyNPCIDList.index(lineupNPCID)

    # 从参考阵容先往前检索，再往后检索，还没有对应武将的NPC

    loopIndexList = range(lineupNPCIndex + 1)[::-1] + range(lineupNPCIndex + 1, ipyDataMgr.GetNPCCount())

    for index in loopIndexList:

        npcID = ipyNPCIDList[index]

        heroID = ipyHeroIDList[index]

        if heroID not in heroIDList:

            continue

        battleDict = GetNPCBattleDict(lineupIpyData, npcID, strongerLV, difficulty)

        if not battleDict:

            continue

        
        for posNum, posHeroID in enumerate(heroIDList, 1):

            if not posHeroID or heroID != posHeroID:

                continue

            heroIDList[posNum - 1] = 0

            heroDict[str(posNum)] = battleDict

        
        if heroIDList.count(0) == len(heroIDList):

            break

        
    if isAllSkill:

        for battleDict in heroDict.values():

            heroID = battleDict["HeroID"]

            heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID) if heroID else None

            skillIDList = GetNPCHeroSkillIDList(heroID, heroIpyData, 99999, 99999) # 默认取突破、觉醒都满级时的技能

            battleDict["SkillIDList"] = skillIDList

            
    lineupInfo = {"NPCLineupID":lineupID, "Hero":heroDict, "BossID":0, "BossPosView":0}

    return lineupInfo

    
def GetNPCBattleDict(lineupIpyData, npcID, strongerLV=0, difficulty=0):

    ## 获取NPC战斗相关字典，支持成长NPC

    # @param strongerLV: 成长等级

@@ -607,6 +779,7 @@
        return

    heroID = npcData.GetRelatedHeroID()

    npcLV = npcData.GetLV()

    star, breakLV, awakeLV = 0, 0, 0

    

    lvIpyData = None

    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID) if heroID else None

@@ -617,11 +790,14 @@
            npcLV = strongerLV

    if not lvIpyData:

        lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", npcLV)

        
    if heroIpyData and lvIpyData:

    if lvIpyData:

        star = lvIpyData.GetReHeroStar()

        breakLV = lvIpyData.GetReHeroBreakLV()

        awakeLV = lvIpyData.GetReHeroAwakeLV()

    if heroIpyData:

        skinIDList = heroIpyData.GetSkinIDList()

        skinID = skinIDList[0] if skinIDList else 0

        skillIDList = GetNPCHeroSkillIDList(heroID, heroIpyData, lvIpyData.GetReHeroBreakLV(), lvIpyData.GetReHeroAwakeLV())

        skillIDList = GetNPCHeroSkillIDList(heroID, heroIpyData, breakLV, awakeLV)

    else:

        heroID = 0

        skinID = 0

@@ -638,7 +814,7 @@
                random.shuffle(randSkillIDExList)

                randSkillIDExList = randSkillIDExList[:skillExCnt]

            skillIDList += randSkillIDExList

            GameWorld.DebugLog("阵容boss技能: %s, 随机附加技能: %s" % (skillIDList, randSkillIDExList))

            GameWorld.DebugLogEx("阵容boss技能: %s, 随机附加技能: %s", skillIDList, randSkillIDExList)

            

    # 成长怪属性

    batAttrDict = GetNPCStrongerAttrDict(npcID, lvIpyData, npcStronger, difficulty)

@@ -661,11 +837,14 @@
                  "HeroID":heroID,

                  "SkinID":skinID,

                  "LV":npcLV,

                  "Star":star,

                  #"BreakLV":breakLV,

                  #"AwakeLV":awakeLV,

                  "AttrDict":{str(k):v for k, v in batAttrDict.items() if v > 0},

                  "SkillIDList":skillIDList,

                  }

    

    GameWorld.DebugLog("GetNPCBattleDict npcID=%s,strongerLV=%s,difficulty=%s,%s" % (npcID, strongerLV, difficulty, battleDict))

    GameWorld.DebugLogEx("GetNPCBattleDict npcID=%s,strongerLV=%s,difficulty=%s,%s", npcID, strongerLV, difficulty, battleDict)

    return battleDict



def GetNPCHeroSkillIDList(heroID, heroIpyData, breakLV, awakeLV):

@@ -714,26 +893,24 @@
        ratio = getattr(npcStronger, "Get%sRatio" % attrName)() if hasattr(npcStronger, "Get%sRatio" % attrName) else 1 # 属性系数

        attrValue = int(reValue * ratio * difficulty)

        batAttrDict[attrID] = attrValue

        #GameWorld.DebugLog("    attrID=%s,attrValue=%s,reValue=%s,ratio=%s,difficulty=%s" % (attrID, attrValue, reValue, ratio, difficulty))

        #GameWorld.DebugLogEx("    attrID=%s,attrValue=%s,reValue=%s,ratio=%s,difficulty=%s", attrID, attrValue, reValue, ratio, difficulty)

        

    GameWorld.DebugLog("NPC成长属性: npcID=%s,lv=%s,difficulty=%s,%s" % (npcID, lv, difficulty, batAttrDict))

    GameWorld.DebugLogEx("NPC成长属性: npcID=%s,lv=%s,difficulty=%s,%s", npcID, lv, difficulty, batAttrDict)

    return batAttrDict



def SummonLineupObjs(batLineup, faction, num, lineupInfo, playerID=0):

def SummonLineupObjs(batLineup, faction, num, lineupInfo, reqPlayerID=0):

    '''召唤阵容战斗实例

    @param faction: 所属阵营，目前支持两个阵营，1或2

    @param num: 战斗阵容在该阵营上的编号，1V1时默认1，多对多时1~n

    @param lineupInfo: 阵容信息

    @param playerID: 发起的玩家ID，系统场次为0

    @param reqPlayerID: 发起的玩家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

    npcLineupID = lineupInfo.get("NPCLineupID", 0)

    GameWorld.DebugLogEx("SummonLineupObjs faction:%s,num:%s,npcLineupID=%s,lineupPlayerID=%s", faction, num, npcLineupID, lineupPlayerID)

    
    turnFight = batLineup.turnFight

    tfGUID = turnFight.guid

    heroDict = lineupInfo.get("Hero", {})

    

    batObjMgr = BattleObj.GetBatObjMgr()

@@ -750,6 +927,7 @@
        heroID = heroInfo.get("HeroID", 0)

        skinID = heroInfo.get("SkinID", 0)

        lv = heroInfo.get("LV", 1)

        star = heroInfo.get("Star", 0)

        specialty, atkDistType, country, sex, job = 0, 1, 0, 1, 0

        heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID) if heroID else None

        if heroIpyData:

@@ -786,6 +964,7 @@
        batObj.SetLineupPos(posNum, num)

        batObj.SetFightPower(fightPower)

        batObj.SetLV(lv)

        batObj.SetStar(star)

        batObj.SetAtkDistType(atkDistType)

        batObj.SetSpecialty(specialty)

        batObj.SetCountry(country)

@@ -799,7 +978,17 @@
            skillManager.LearnSkillByID(skillID)

            

        batLineup.posObjIDDict[posNum] = objID

        GameWorld.DebugLog("AddBatObj %s,skill=%s" % (GetObjName(batObj), skillManager.GetSkillIDList()))

        batLineup.heroObjIDDict[heroID] = objID

        GameWorld.DebugLogEx("AddBatObj %s,lv=%s,star=%s,skill=%s", GetObjName(batObj), lv, star, skillManager.GetSkillIDList())

        ResetObjSkill(batObj)

        
        if npcID:

            #副本指定NPC属性

            fbNPCInitAttrDict = FBLogic.GetFBNPCInitAttr(turnFight, batObj)

            if fbNPCInitAttrDict:

                GameWorld.DebugLogEx("副本指定NPC初始化属性: npcID=%s, %s", npcID, fbNPCInitAttrDict)

                attrDict = {str(k):v for k, v in fbNPCInitAttrDict.items()} # 统一格式

        #attrDict[str(ChConfig.AttrID_MaxHP)] = 10000000000

        batObj.InitBatAttr({int(k):v for k, v in attrDict.items()}, initXP)

        

    return

@@ -810,7 +999,7 @@
    batFaction = turnFight.getBatFaction(ChConfig.Def_FactionA)

    if not batFaction:

        return

    GameWorld.DebugLog("切换小队重置玩家阵容武将...")

    GameWorld.DebugLogEx("切换小队重置玩家阵容武将...")

    batLineup = batFaction.getBatlineup(1) # 只处理玩家阵容

    batObjMgr = BattleObj.GetBatObjMgr()

    for objID in batLineup.posObjIDDict.values():

@@ -819,23 +1008,46 @@
            continue

        objName = GetObjName(batObj)

        if not batObj.IsAlive():

            GameWorld.DebugLog("    已被击杀不处理! %s" % (objName))

            GameWorld.DebugLogEx("    已被击杀不处理! %s", objName)

            continue

        GameWorld.DebugLog("    重置武将: %s, HP:%s/%s, XP:%s" % (objName, batObj.GetHP(), batObj.GetMaxHP(), batObj.GetXP()))

        
        batObj.TurnReset()

        GameWorld.DebugLogEx("重置武将: %s, HP:%s/%s, XP:%s", objName, batObj.GetHP(), batObj.GetMaxHP(), batObj.GetXP())

        

        # 清除buff

        buffMgr = batObj.GetBuffManager()

        buffMgr.ClearBuff()

        

        # 重置CD

        # 重置技能

        ResetObjSkill(batObj)

        

        # 重刷属性、被动

        TurnBuff.RefreshBuffAttr(batObj)

        TurnPassive.RefreshPassive(batObj)

        

    return



def CheckFightCD(curPlayer, tick, selfKey):

    ## 是否战斗请求CD中

    
    # 所有玩家公共CD，待扩展

    tfMgr = GetTurnFightMgr()

    pubCD = IpyGameDataPY.GetFuncCfg("TurnFightCD", 1)

    if pubCD:

        if tfMgr.lastRequestTick and tick - tfMgr.lastRequestTick <= pubCD:

            GameWorld.DebugLogEx("回合制战斗请求服务器公共CD中!")

            PlayerControl.NotifyCode(curPlayer, "BattleCoolDown")

            return True

        
    # 个人CD

    selfCD = IpyGameDataPY.GetFuncCfg("TurnFightCD", 2)

    lastTick = curPlayer.GetDictByKey(selfKey)

    if selfCD and lastTick and tick - lastTick <= selfCD:

        GameWorld.DebugLogEx("回合制战斗请求CD中: %s", selfKey)

        PlayerControl.NotifyCode(curPlayer, "BattleCoolDown")

        return True

    
    tfMgr.lastRequestTick = tick

    curPlayer.SetDict(selfKey, tick)

    return False



#// B4 10 回合制战斗 #tagCMTurnFight

#

@@ -853,122 +1065,245 @@
    ''' 本战斗会一次性处理完所有小队战斗，以战报的形式下发，目前除了主线小怪分段战斗外，均使用该战斗

    '''

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    playerID = curPlayer.GetPlayerID()

    mapID = clientData.MapID

    funcLineID = clientData.FuncLineID

    tagType = clientData.TagType

    tagID = clientData.TagID

    valueList = clientData.ValueList

    

    GameWorld.DebugLog("回合制战斗请求: mapID=%s,funcLineID=%s,tagType=%s,tagID=%s,valueList=%s" 
                       % (mapID, funcLineID, tagType, tagID, valueList), curPlayer.GetPlayerID())

    GameWorld.DebugLogEx("----- 回合制战斗请求: mapID=%s,funcLineID=%s,tagType=%s,tagID=%s,valueList=%s", mapID, funcLineID, tagType, tagID, valueList, playerID)

    

    reqRet = FBLogic.OnTurnFightRequest(curPlayer, mapID, funcLineID, tagType, tagID, valueList)

    if not reqRet:

        return

    funcLineID = reqRet[1] if len(reqRet) > 1 else funcLineID

    

    fbIpyData = FBCommon.GetFBIpyData(mapID)

    fbLineIpyData = FBCommon.GetFBLineIpyData(mapID, funcLineID, False)

    if fbIpyData:

        if not fbLineIpyData:

            GameWorld.DebugLogEx("不存在该副本功能线路! mapID=%s,funcLineID=%s", mapID, funcLineID)

            return

        if FBCommon.CheckCanEnterFBComm(curPlayer, mapID, funcLineID, fbIpyData, fbLineIpyData) != ShareDefine.EntFBAskRet_OK:

            return

        
    # 攻防方所使用的阵容ID

    atkLineupID, defLineupID = FBLogic.GetFBPlayerLineupID(curPlayer, mapID, funcLineID)

    if atkLineupID not in ShareDefine.LineupList or defLineupID not in ShareDefine.LineupList:

        return

    

    if CheckFightCD(curPlayer, tick, "TurnFightReqTick"):

        return

    
    reqPlayerID = playerID

    playerServerID = GameWorld.GetPlayerServerID(curPlayer)

    guid = GameWorld.GetGUID()

    
    atkLineupInfo = GetPlayerLineupInfo(curPlayer, atkLineupID)

    if not atkLineupInfo:

        GameWorld.DebugLogEx("玩家没有该阵容数据! atkLineupID=%s", atkLineupID, playerID)

        return

    
    # 玩家

    if tagType == 1:

        OnTurnFightVSPlayer(curPlayer, mapID, funcLineID, atkLineupID, defLineupID, tagID)

        tagPlayerID = tagID

        tagViewCache = PlayerViewCache.FindBattleViewCache(tagPlayerID)

        if not tagViewCache:

            # 跨服玩家待扩展

            GameWorld.DebugLogEx("目标玩家没有缓存数据! tagPlayerID=%s", tagPlayerID, playerID)

            PlayerControl.NotifyCode(curPlayer, "TagNoViewCache")

            return

        
        defLineupInfo = GetCacheLineupInfo(tagViewCache, defLineupID)

        if not defLineupInfo:

            GameWorld.DebugLogEx("目标玩家没有该阵容数据! tagPlayerID=%s,defLineupID=%s", tagPlayerID, defLineupID, playerID)

            PlayerControl.NotifyCode(curPlayer, "TagNoLineup")

            return

        
        lineupDictA = {1:atkLineupInfo}

        lineupDictB = {1:defLineupInfo}

        AddToBattleQueue(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, playerServerID, reqData=[tagType, tagID, valueList])

        

    # NPC

    else:

        ret = FBLogic.GetFBNPCLineupInfo(curPlayer, mapID, funcLineID)

        if not ret:

        npcLineupIDList, strongerLV, difficulty = [], 0, 0

        if fbLineIpyData:

            npcLineupIDList = fbLineIpyData.GetLineupIDList()

            strongerLV = fbLineIpyData.GetNPCLV()

            difficulty = fbLineIpyData.GetDifficulty()

            
        if not npcLineupIDList:

            ret = FBLogic.GetFBNPCLineupInfo(curPlayer, mapID, funcLineID)

            if not ret:

                return

            npcLineupIDList, strongerLV, difficulty = ret

            
        if not npcLineupIDList:

            return

        npcLineupIDList, strongerLV, difficulty = ret

        OnTurnFightVSNPC(curPlayer, mapID, funcLineID, atkLineupID, npcLineupIDList, strongerLV, difficulty)

        
        #if mapID == ChConfig.Def_FBMapID_MainBoss:

        #    # 停止主线小怪战斗、清空

        #    mainFightMgr = GetMainFightMgr(curPlayer)

        #    mainTF = mainFightMgr.turnFight

        #    if mainTF.isInFight():

        #        mainTF.exitFight()

        
        lineupDictA = {1:atkLineupInfo}

        lineupDictB = None

        AddToBattleQueue(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, playerServerID, npcLineupIDList, strongerLV, difficulty)

        
    return True



def AddToBattleQueue(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID=0, playerServerID=0, npcLineupIDList=[], strongerLV=0, difficulty=0, reqData=None):

    '''添加进战斗请求队列，这里做战斗分发处理，由当前服务器根据当前服务器情况分配到本机子的其他战斗地图，或直接本地图处理

    @param lineupDictA: 阵营A所有阵容{阵容编号:{阵容信息}, ...}

    @param lineupDictB: 阵营B所有阵容{阵容编号:{阵容信息}, ...}，pvp时用

    @param reqPlayerID: 请求的玩家ID，如果是系统自动处理的战斗场次，则为0

    @param npcLineupIDList: pve时用，要对战的npc阵容ID列表

    @param strongerLV: pve时用，npc属性成长等级

    @param difficulty: pve时用，npc属性难度系数

    @param reqData: 每场战斗自定义的请求信息，由功能自己决定，任意结构，透传参数

    '''

    
    if not lineupDictA:

        return

    
    if not lineupDictB and not npcLineupIDList:

        # pvp 或 pve 必须要满足其中一种

        return

    
    fromServerID = GameWorld.GetGameWorld().GetServerID()

    reqInfo = [guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, playerServerID, npcLineupIDList, strongerLV, difficulty, reqData]

    multiMapSet = IpyGameDataPY.GetFuncCfg("TurnFightProcess", 1)

    #multiMapSet = 0

    # 多地图战斗 0-本地图处理；1-多地图处理；2-debug模式默认本地图处理，非debug默认多地图处理

    isMultiMap = False

    if multiMapSet == 1:

        isMultiMap = True

    elif multiMapSet == 2:

        if not GameWorld.GetGameWorld().GetDebugLevel():

            isMultiMap = True

            
    if isMultiMap:

        CrossServerPackLogic.SendToBattleServer(ShareDefine.SSMsg_BattleRequest, reqInfo, reqPlayerID)

    else:

        SSMsg_BattleRequest(reqInfo, fromServerID)

    return



def SSMsg_BattleRequest(reqInfo, fromServerID):

    ## 请求执行战斗，由本地图或其他服务器地图分配过来的战斗请求

    guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, playerServerID, npcLineupIDList, strongerLV, difficulty, reqData = reqInfo

    
    if npcLineupIDList:

        turnFight = DoTurnFightPVE(guid, mapID, funcLineID, reqPlayerID, playerServerID, lineupDictA, npcLineupIDList, strongerLV, difficulty)

    else:

        turnFight = DoTurnFightPVP(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, playerServerID)

        
    winFaction = None

    statMsg = {}

    dateStr = ""

    if turnFight:

        statMsg = turnFight.statMsg

        winFaction = turnFight.winFaction

        dateStr = turnFight.dateStr

        
    retInfo = [guid, mapID, funcLineID, reqPlayerID, winFaction, statMsg, dateStr, reqData]

    
    # 本地图自己处理的

    if fromServerID == GameWorld.GetGameWorld().GetServerID():

        SSMsg_BattleResult(retInfo, fromServerID)

        
    # 其他服务器地图请求的，发送战斗结果回去

    else:

        CrossServerPackLogic.SendToServer(ShareDefine.SSMsg_BattleResult, retInfo, [fromServerID], playerID=reqPlayerID)

    return



def SSMsg_BattleResult(retInfo, fromServerID):

    ## 收到战斗结果信息

    
    guid, mapID, funcLineID, reqPlayerID, winFaction, statMsg, dateStr, reqData = retInfo

    
    curPlayer = None

    if reqPlayerID:

        curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(reqPlayerID)

        if not curPlayer:

            # 收到战斗结果时玩家已离线，不处理，可视为该战斗无效，玩家重新请求

            return

        
    if winFaction == None:

        if curPlayer:

            PlayerControl.NotifyCode(curPlayer, "BattleFail")

        return

    
    # 根据战斗结果结算奖励

    awardDict = {}

    FBLogic.OnTurnFightAward(curPlayer, guid, mapID, funcLineID, winFaction, statMsg, dateStr, reqData, awardDict)

    
    if curPlayer:

        isWin = winFaction == ChConfig.Def_FactionA

        SyncTurnFightRet(curPlayer, guid, mapID, funcLineID, reqData, isWin, statMsg, dateStr, awardDict)

        

    return



def OnTurnFightVSNPC(curPlayer, mapID, funcLineID, atkLineupID, npcLineupIDList, strongerLV, difficulty):

    playerID = curPlayer.GetPlayerID()

    GameWorld.DebugLog("OnTurnFightVSNPC: mapID=%s,funcLineID=%s,atkLineupID=%s,npcLineupIDList=%s,strongerLV=%s,difficulty=%s" 
                       % (mapID, funcLineID, atkLineupID, npcLineupIDList, strongerLV, difficulty), playerID)

    if not npcLineupIDList:

        return

    
    lineupMainInfo = GetPlayerLineupInfo(curPlayer, atkLineupID)

    if not lineupMainInfo:

        GameWorld.DebugLog("玩家没有该阵容数据! atkLineupID=%s" % atkLineupID, playerID)

        return

def DoTurnFightPVE(guid, mapID, funcLineID, reqPlayerID, playerServerID, playerLineupDict, npcLineupIDList, strongerLV, difficulty):

    '''执行PVE战斗，支持多小队

    '''

    

    turnMax = GetTurnMax(mapID)

    if mapID == ChConfig.Def_FBMapID_MainBoss:

        # 停止主线小怪战斗、清空

        mainFightMgr = GetMainFightMgr(curPlayer)

        mainTF = mainFightMgr.turnFight

        if mainTF.isInFight():

            mainTF.exitFight()

            
    
    tfMgr = GetTurnFightMgr()

    turnFight = tfMgr.addTurnFight(mapID, funcLineID, playerID)

    turnFight = tfMgr.addTurnFight(guid, mapID, funcLineID, reqPlayerID, playerServerID)

    guid = turnFight.guid

    

    turnFight.setTurnFight(mapID, funcLineID, turnMax, True)

    turnFight.setPVE(npcLineupIDList, strongerLV, difficulty)

    turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo})

    turnFight.setFactionLineup(ChConfig.Def_FactionA, playerLineupDict)

    

    for index, lineupID in enumerate(npcLineupIDList):

        turnFight.lineupIndex = index

        GameWorld.DebugLog("对战NPC阵容: index=%s, lineupID=%s" % (index, lineupID))

        GameWorld.DebugLogEx("对战NPC阵容: index=%s, lineupID=%s", index, lineupID)

        if index > 0:

            turnFight.nextTurnFight(resetByNextTeam=True)

            turnFight.nextTurnFight()

        turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID, strongerLV, difficulty)})

        turnFight.sortActionQueue()

        turnFight.startFight()

        

        __processTurnFight(turnFight.guid)

        __processTurnFight(turnFight)

        

        if not turnFight.isWin:

            break

        

    PlayerOnline.GetOnlinePlayer(curPlayer).SetLastBatBuffer(guid, turnFight.batBuffer)

    SyncTurnFightReport(curPlayer, guid, turnFight.batBuffer)

    saveOK = __saveBatBuffer(turnFight)

    tfMgr.delTurnFight(guid)

    return

    return turnFight if saveOK else None



def OnTurnFightVSPlayer(curPlayer, mapID, funcLineID, atkLineupID, defLineupID, tagPlayerID):

    playerID = curPlayer.GetPlayerID()

    GameWorld.DebugLog("OnTurnFightVSPlayer: mapID=%s,funcLineID=%s,atkLineupID=%s,defLineupID=%s,tagPlayerID=%s" 
                       % (mapID, funcLineID, atkLineupID, defLineupID, tagPlayerID), playerID)

    atkLineupInfo = GetPlayerLineupInfo(curPlayer, atkLineupID)

    if not atkLineupInfo:

        GameWorld.DebugLog("玩家没有该阵容数据! atkLineupID=%s" % atkLineupID, playerID)

        return

    
    tagViewCache = PlayerViewCache.FindViewCache(tagPlayerID)

    if not tagViewCache:

        GameWorld.DebugLog("目标玩家没有缓存数据! tagPlayerID=%s" % tagPlayerID, playerID)

        return {}

    defLineupInfo = GetCacheLineupInfo(tagViewCache, defLineupID)

    if not defLineupInfo:

        GameWorld.DebugLog("目标玩家没有该阵容数据! tagPlayerID=%s,defLineupID=%s" % (tagPlayerID, defLineupID), playerID)

        return

#@CommFunc.DoCProfile

def DoTurnFightPVP(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID=0, playerServerID=0):

    '''执行PVP战斗，只处理战斗，不关心功能及curPlayer相关

    @param lineupDictA: 阵营A所有阵容{阵容编号:{阵容信息}, ...}

    @param lineupDictB: 阵营B所有阵容{阵容编号:{阵容信息}, ...}

    @param reqPlayerID: 请求的玩家ID，如果是系统自动处理的战斗场次，则为0

    '''

    

    turnMax = GetTurnMax(mapID)

    

    tfMgr = GetTurnFightMgr()

    turnFight = tfMgr.addTurnFight(mapID, funcLineID, playerID)

    turnFight = tfMgr.addTurnFight(guid, mapID, funcLineID, reqPlayerID, playerServerID)

    guid = turnFight.guid

    

    turnFight.setTurnFight(mapID, funcLineID, turnMax, True)

    turnFight.setPVP(tagPlayerID, tagViewCache)

    turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:atkLineupInfo})

    turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:defLineupInfo})

    turnFight.setPVP()

    turnFight.setFactionLineup(ChConfig.Def_FactionA, lineupDictA)

    turnFight.setFactionLineup(ChConfig.Def_FactionB, lineupDictB)

    turnFight.sortActionQueue()

    turnFight.startFight()

    

    __processTurnFight(turnFight.guid)

    __processTurnFight(turnFight)

    

    PlayerOnline.GetOnlinePlayer(curPlayer).SetLastBatBuffer(guid, turnFight.batBuffer)

    SyncTurnFightReport(curPlayer, guid, turnFight.batBuffer)

    saveOK = __saveBatBuffer(turnFight)

    tfMgr.delTurnFight(guid)

    return

    return turnFight if saveOK else None



def GetTurnMax(mapID):

    if mapID == ChConfig.Def_FBMapID_Main:

@@ -996,7 +1331,10 @@
        __doSetFightPoint(curPlayer, reqValue)

        return

    

    GameWorld.DebugLog("主线战斗请求: reqType=%s" % reqType, curPlayer.GetPlayerID())

    GameWorld.DebugLogEx("------------------- 主线战斗请求: reqType=%s", reqType, curPlayer.GetPlayerID())

    mainFightMgr = GetMainFightMgr(curPlayer)

    mainFightMgr.resetMainFightExDataRec() # 请求时补重置，防止异常时重复结算逻辑

    
    clientPack = ChPyNetSendPack.tagSCTurnFightReportSign()

    clientPack.Sign = 0

    NetPackCommon.SendFakePack(curPlayer, clientPack) # 标记开始

@@ -1011,6 +1349,36 @@
    # 标记结束

    clientPack.Sign = 1

    NetPackCommon.SendFakePack(curPlayer, clientPack)

    
    __doMainFightExDataFunc(curPlayer)

    return



def __doMainFightExDataFunc(curPlayer):

    mainFightMgr = GetMainFightMgr(curPlayer)

    
    # 本次消耗战锤数

    useZhanchui = mainFightMgr.useZhanchui

    if useZhanchui > 0:

        PlayerLLMJ.AddUseZhanchui(curPlayer, useZhanchui)

        PlayerPrestigeSys.AddRealmTaskValue(curPlayer, PlayerPrestigeSys.RealmTaskType_UseXiantao, useZhanchui)

        PlayerTask.AddTaskValue(curPlayer, ChConfig.TaskType_CutTree, useZhanchui)

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_OSACutTree, useZhanchui)

        PlayerActivity.AddDailyTaskValue(curPlayer, ChConfig.DailyTask_CutTree, useZhanchui)

        
    # 历练秘境额外经验

    mjExp = mainFightMgr.mjExp

    if mjExp > 0:

        PlayerLLMJ.AddExpEx(curPlayer, mjExp)

        
    # 击杀怪物

    killNPCCnt = mainFightMgr.killNPCCnt

    if killNPCCnt > 0:

        PlayerTask.AddTaskValue(curPlayer, ChConfig.TaskType_KillNPC, killNPCCnt)

        PlayerActivity.AddDailyTaskValue(curPlayer, ChConfig.DailyTask_KillNPC, killNPCCnt)

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_OSAKillNPC, killNPCCnt)

        
    # 结算逻辑最后重置数据

    mainFightMgr.resetMainFightExDataRec()

    return



def __doExitMainFight(curPlayer):

@@ -1023,16 +1391,14 @@


def __doSetFightPoint(curPlayer, fightPoint):

    ## 设置消耗倍值

    GameWorld.DebugLog("设置战锤消耗倍值: %s" % fightPoint)

    if fightPoint == 1:

        pass

    elif fightPoint == 2:

        # 条件验证

        pass

    elif fightPoint == 3:

        # 条件验证

        pass

    else:

    GameWorld.DebugLogEx("设置战锤消耗倍值: %s", fightPoint)

    needTreeLVList = IpyGameDataPY.GetFuncEvalCfg("AutoGuaji", 1)

    if fightPoint < 1 or fightPoint > len(needTreeLVList):

        return

    needTreeLV = needTreeLVList[fightPoint - 1]

    treeLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TreeLV)

    if treeLV < needTreeLV:

        GameWorld.DebugLogEx("祝福树等级不足: treeLV=%s < %s", treeLV, needTreeLV)

        return

    curPlayer.SetFightPoint(fightPoint)

    return

@@ -1042,10 +1408,10 @@
    # @param isRestStart: 是否从休息状态重新开始的

    playerID = curPlayer.GetPlayerID()

    chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)

    GameWorld.DebugLog("请求关卡波战斗: chapterID=%s,levelNum=%s,wave=%s,isRestStart=%s" % (chapterID, levelNum, wave, isRestStart), playerID)

    GameWorld.DebugLogEx("请求关卡波战斗: 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("战锤不足，无法开始!")

        GameWorld.DebugLogEx("战锤不足，无法开始!")

        return

    chapterIpyData = IpyGameDataPY.GetIpyGameData("MainChapter", chapterID)

    if not chapterIpyData:

@@ -1077,7 +1443,7 @@
    

    lineupMainInfo = GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)

    if not lineupMainInfo:

        GameWorld.DebugLog("没有设置主阵容!", playerID)

        GameWorld.DebugLogEx("没有设置主阵容!", playerID)

        return

    

    strongerLV = levelIpyData.GetNPCLV()

@@ -1089,11 +1455,11 @@
    mainFightMgr.wave = wave

    mapID, funcLineID = ChConfig.Def_FBMapID_Main, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)

    turnMax = GetTurnMax(mapID)

    GameWorld.DebugLog("设置起始关卡波: 关卡%s-%s,波=%s/%s,lineupIDList=%s,mapID=%s,funcLineID=%s,lineupID=%s,strongerLV=%s,difficulty=%s" 
                       % (chapterID, levelNum, wave, waveMax, lineupIDList, mapID, funcLineID, lineupID, strongerLV, difficulty), playerID)

    GameWorld.DebugLogEx("设置起始关卡波: 关卡%s-%s,波=%s/%s,lineupIDList=%s,mapID=%s,funcLineID=%s,lineupID=%s,strongerLV=%s,difficulty=%s", 
                         chapterID, levelNum, wave, waveMax, lineupIDList, mapID, funcLineID, lineupID, strongerLV, difficulty, playerID)

    

    turnFight = mainFightMgr.turnFight

    turnFight.setTurnFight(mapID, funcLineID, turnMax, False)

    turnFight.setTurnFight(mapID, funcLineID, turnMax, False, curPlayer)

    turnFight.setPVE(lineupIDList, strongerLV, difficulty)

    turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo})

    turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID, strongerLV, difficulty)})

@@ -1110,12 +1476,8 @@
    

    # 限制请求CD

    if tick:

        key = "MainFightReqTick"

        lastTick = curPlayer.GetDictByKey(key)

        if lastTick and tick - lastTick <= 1000:

            GameWorld.DebugLog("主线战斗请求CD中")

        if CheckFightCD(curPlayer, tick, "MainFightReqTick"):

            return

        curPlayer.SetDict(key, tick)

        

    mainFightMgr = GetMainFightMgr(curPlayer)

    turnFight = mainFightMgr.turnFight

@@ -1133,9 +1495,9 @@
    if winFaction:

        nextLineupID = turnFight.nextLineupID()

        if nextLineupID:

            GameWorld.DebugLog("---开始进入下一小队: lineupIndex=%s,nextLineupID=%s,%s" % (turnFight.lineupIndex, nextLineupID, turnFight.lineupIDList))

            GameWorld.DebugLogEx("---开始进入下一小队: lineupIndex=%s,nextLineupID=%s,%s", turnFight.lineupIndex, nextLineupID, turnFight.lineupIDList)

            

            turnFight.nextTurnFight(resetByNextTeam=True)

            turnFight.nextTurnFight()

            # 切换小队时，玩家阵容不需要处理，保留状态

            turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(nextLineupID, turnFight.strongerLV, turnFight.difficulty)})

            turnFight.sortActionQueue()

@@ -1149,7 +1511,7 @@
    # 小怪战斗，每次消耗1个战锤

    fightPoint = max(curPlayer.GetFightPoint(), 1) # 主线战斗消耗倍值，默认1

    if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):

        GameWorld.DebugLog("回合开始时战锤不足!")

        GameWorld.DebugLogEx("回合开始时战锤不足!")

        return

    

    # 以下均是处理关卡小怪分段实时战斗

@@ -1162,49 +1524,39 @@
    batObjMgr = BattleObj.GetBatObjMgr()

    turnNum = turnFight.turnNum

    turnMax = turnFight.turnMax

    turnNumStart = turnFight.turnNumStart

    for turnNum in range(turnNum, turnMax + 1):

        turnTimeline = turnFight.getTurnNumStartTimelin(turnNum) # 本回合起始时间节点

        curTimeline = turnFight.getTimeline()

        if turnFight.winFaction:

            break

        

        # 回合开始

        turnTimeline += 1 # 每回合开始算一个时间节点

        if curTimeline < turnTimeline:

            curTimeline = turnFight.setTimeline(turnTimeline)

            GameWorld.DebugLog("【----- 回合制战斗轮次: %s -----】 curTimeline=%s" % (turnNum, curTimeline))

        if turnNumStart < turnNum:

            GameWorld.DebugLogEx("【----- 回合制战斗轮次: %s -----】 ", turnNum)

            turnFight.turnNum = turnNum

            turnFight.turnNumStart = 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)

                    TurnFightPerTurnBigStart(turnFight, batObj, turnNum)

                    
            TurnFightPerTurnBigStart(turnFight, turnNum)

            
        # 红颜

        # 灵兽

        

        if turnFight.checkOverByKilled():

        if turnFight.winFaction:

            break

        

        # 武将

        doMax = PosNumMax * len(turnFight.actionSortList)

        doCnt = 0

        while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList):

        while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList) and not turnFight.winFaction:

            doCnt += 1

            faction, num = turnFight.actionSortList[turnFight.actionIndex]

            batFaction = turnFight.getBatFaction(faction)

            batLineup = batFaction.getBatlineup(num)

            for posNum in range(batLineup.actionNum, PosNumMax + 1):

                # 每个武将位算一个时间节点

                #GameWorld.DebugLog("武将节点: faction=%s,posNum=%s,curTimeline=%s" % (faction, posNum, curTimeline))

                #GameWorld.DebugLogEx("武将位置: faction=%s,posNum=%s", faction, posNum)

                if posNum not in batLineup.posObjIDDict:

                    batLineup.actionNum = posNum + 1

                    curTimeline = turnFight.setTimeline(curTimeline + 1, True)

                    #GameWorld.DebugLog("空位节点: faction=%s,posNum=%s,curTimeline=%s" % (faction, posNum, curTimeline))

                    #GameWorld.DebugLogEx("没有武将: faction=%s,posNum=%s", faction, posNum)

                    continue

                

                objID = batLineup.posObjIDDict[posNum]

@@ -1213,13 +1565,16 @@
                # 玩家自己阵营，预判可否行动

                if checkBreakpoint and faction == ChConfig.Def_FactionA and batObj:

                    if batObj.CanAction():

                        GameWorld.DebugLog("玩家阵容下一个可行动的武将，断点: curTimeline=%s,nextPosNum=%s" % (curTimeline, posNum))

                        GameWorld.DebugLogEx("玩家阵容下一个可行动的武将，断点: nextPosNum=%s", posNum)

                        return

                    

                batLineup.actionNum = posNum + 1

                curTimeline = turnFight.setTimeline(curTimeline + 1)

                
                TurnFightHeroTurnStart(turnFight, batObj, turnNum)

                if not OnObjAction(turnFight, batObj):

                isAction = OnObjAction(turnFight, batObj)

                TurnFightHeroTurnEnd(turnFight, batObj, turnNum)

                
                if not isAction:

                    continue

                

                if not checkBreakpoint and faction == ChConfig.Def_FactionA:

@@ -1232,60 +1587,41 @@
            else:

                turnFight.actionIndex += 1

                

        # 回合结束

        curTimeline = turnFight.setTimeline(curTimeline + 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():

                batObj = batObjMgr.getBatObj(objID)

                TurnFightPerTurnBigEnd(turnFight, batObj, turnNum)

                
        if turnFight.checkOverByKilled():

        if turnFight.winFaction:

            break

        
        # 回合结束

        TurnFightPerTurnBigEnd(turnFight, turnNum)

        

    if not turnFight.winFaction:

        OnTurnAllOver(turnFight.guid)

        

    return



def __processTurnFight(guid):

def __processTurnFight(turnFight):

    ## 一次性处理完一个小队的战斗

    turnFight = GetTurnFightMgr().getTurnFight(guid)

    curPlayer = turnFight.curPlayer

    turnMax = turnFight.turnMax

    EntryLogic(turnFight)

    batObjMgr = BattleObj.GetBatObjMgr()

    for turnNum in range(1, turnMax + 1):

        if turnFight.winFaction:

            break

        turnFight.turnNum = turnNum

        GameWorld.DebugLog("【----- 回合制战斗轮次: %s -----】" % turnNum)

        curTimeline = turnFight.getTurnNumStartTimelin(turnNum) # 本回合起始时间节点

        curTimeline = turnFight.setTimeline(curTimeline + 1)

        GameWorld.DebugLogEx("【----- 回合制战斗轮次: %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)

                TurnFightPerTurnBigStart(turnFight, batObj, turnNum)

                
                    
        # 红颜

        # 灵兽

            
        if turnFight.checkOverByKilled():

        TurnFightPerTurnBigStart(turnFight, turnNum)

        
        if turnFight.winFaction:

            break

        

        # 武将

        doMax = PosNumMax * len(turnFight.actionSortList)

        doCnt = 0

        while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList):

        while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList) and not turnFight.winFaction:

            doCnt += 1

            faction, num = turnFight.actionSortList[turnFight.actionIndex]

            batFaction = turnFight.getBatFaction(faction)

@@ -1293,15 +1629,14 @@
            for posNum in range(batLineup.actionNum, PosNumMax + 1):

                batLineup.actionNum = posNum + 1

                if posNum not in batLineup.posObjIDDict:

                    curTimeline = turnFight.setTimeline(curTimeline + 1, True)

                    continue

                curTimeline = turnFight.setTimeline(curTimeline + 1) # 每个武将位算一个时间节点

                objID = batLineup.posObjIDDict[posNum]

                batObj = batObjMgr.getBatObj(objID)

                TurnFightHeroTurnStart(turnFight, batObj, turnNum)

                if not OnObjAction(turnFight, batObj):

                isAction = OnObjAction(turnFight, batObj)

                TurnFightHeroTurnEnd(turnFight, batObj, turnNum)

                if not isAction:

                    continue

                
                break

            

            if turnFight.actionIndex >= len(turnFight.actionSortList) - 1:

@@ -1309,18 +1644,11 @@
            else:

                turnFight.actionIndex += 1

                

        # 回合结束

        curTimeline = turnFight.setTimeline(curTimeline + 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():

                batObj = batObjMgr.getBatObj(objID)

                TurnFightPerTurnBigEnd(turnFight, batObj, turnNum)

                
        if turnFight.checkOverByKilled():

        if turnFight.winFaction:

            break

        
        # 回合结束

        TurnFightPerTurnBigEnd(turnFight, turnNum)

        

    if not turnFight.winFaction:

        OnTurnAllOver(turnFight.guid)

@@ -1343,7 +1671,7 @@
    ## 执行进场逻辑

    if turnFight.enterLogic:

        return

    GameWorld.DebugLog("执行进场逻辑...")

    GameWorld.DebugLogEx("执行进场逻辑...")

    

    batObjMgr = BattleObj.GetBatObjMgr()

    for faction, num in turnFight.actionSortList:

@@ -1354,114 +1682,57 @@
            batObj = batObjMgr.getBatObj(objID)

            turnFight.ResetOneActionUseSkillCnt()

            TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_FightStart)

            TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_InBattlefield)

            

    turnFight.enterLogic = True

    return True



def OnTimelineChange(turnFight):

    ## 每个时间节点变化时处理

    
    nowTimeline = turnFight.getTimeline()

def TurnFightPerTurnBigStart(turnFight, turnNum):

    ## 大回合开始时

    

    batObjMgr = BattleObj.GetBatObjMgr()

    for batFaction in turnFight.factionDict.values():

        for batLineup in batFaction.lineupDict.values():

            for objID in batLineup.posObjIDDict.values():

                batObj = batObjMgr.getBatObj(objID)

                #GameWorld.DebugLog("OnTimelineChange! objID=%s" % (objID))

                if not batObj or not batObj.IsAlive():

                    continue

    for faction, num in turnFight.actionSortList:

        GameWorld.DebugLogEx("大回合开始逻辑: 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)

            if not batObj:

                continue

            
            turnFight.ResetOneActionUseSkillCnt()

            batObj.SetTiming(ChConfig.TurnTiming_Before) # 重置时机到回合前

            if turnNum > 1: # 第1回合不用刷新技能

                RefreshObjSkillByBigTurn(batObj)

                RefreshObjByBigTurn(turnFight, batObj)

            batObj.ResetBigTurn() # 每大回合重置

            
            if not batObj.IsAlive():

                TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_BigTurnStartByDead)

            else:

                TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_BigTurnStart)

                

                curID = batObj.GetID()

                skillManager = batObj.GetSkillManager()

                for index in range(0, skillManager.GetSkillCount()):

                    curSkill = skillManager.GetSkillByIndex(index)

                    if not curSkill:

                        continue

                    remainTime = curSkill.GetRemainTime()

                    if not remainTime:

                        continue

                    calcTimeline = curSkill.GetCalcTime()

                    passTurn = __calcPassturn(calcTimeline, nowTimeline, True)

                    if passTurn <= 0:

                        continue

                    skillID = curSkill.GetSkillID()

                    updRemainTime = max(0, remainTime - passTurn)

                    curSkill.SetRemainTime(updRemainTime)

                    curSkill.SetCalcTime(nowTimeline)

                    GameWorld.DebugLog("更新技能剩余回合数: curID=%s,skillID=%s,updRemainTime=%s,calcTimeline=%s,passTurn=%s" 
                                       % (curID, skillID, updRemainTime, calcTimeline, passTurn))

                    
                buffMgr = batObj.GetBuffManager()

                for index in range(buffMgr.GetBuffCount())[::-1]:

                    buff = buffMgr.GetBuffByIndex(index)

                    buffID = buff.GetBuffID()

                    skillID = buff.GetSkillID()

                    skillData = buff.GetSkillData()

                    if skillData.GetSkillType() in ChConfig.Def_LstBuff_List:

                        #GameWorld.DebugLog("    持续类buff由触发时机决定剩余时间! curID=%s,index=%s,skillID=%s,buffID=%s" % (curID, index, skillID, buffID))

                        continue

                    remainTime = buff.GetRemainTime()

                    if not remainTime:

                        # 永久buff不处理

                        #GameWorld.DebugLog("    永久buff不处理! curID=%s,index=%s,skillID=%s" % (curID, index, skillID))

                        continue

                    calcTimeline = buff.GetCalcTime()

                    passTurn = __calcPassturn(calcTimeline, nowTimeline, True)

                    if passTurn <= 0:

                        #GameWorld.DebugLog("    passTurn <= 0 passTurn=%s,calcTimeline=%s,nowTimeline=%s,skillID=%s" % (passTurn, calcTimeline, nowTimeline, skillID))

                        continue

                    
                    updRemainTime = max(0, remainTime - passTurn)

                    GameWorld.DebugLog("更新buff剩余回合数: curID=%s,buffID=%s,skillID=%s,updRemainTime=%s,calcTimeline=%s,passTurn=%s" 
                                       % (curID, buffID, skillID, updRemainTime, calcTimeline, passTurn))

                    if updRemainTime > 0:

                        buff.SetRemainTime(updRemainTime)

                        buff.SetCalcTime(nowTimeline)

                        TurnBuff.SyncBuffRefresh(turnFight, batObj, buff)

                    else:

                        TurnBuff.DoBuffDel(turnFight, batObj, buff)

                        
    return



def __calcPassturn(calcTimeline, nowTimeline, equalOK):

    ## 计算已经过了的回合数

    # @param equalOK: 时间节点相同时是否算1回合，一般技能可以算，buff可算可不算，具体看需求调整

    calcTurnNum = calcTimeline / TimelineSet

    calcTimeNode = calcTimeline % TimelineSet

    nowTurnNum = nowTimeline / TimelineSet

    nowTimeNode = nowTimeline % TimelineSet

    if equalOK:

        if nowTimeNode >= calcTimeNode:

            return max(0, nowTurnNum - calcTurnNum)

        return max(0, nowTurnNum - calcTurnNum - 1)

    else:

        if nowTimeNode > calcTimeNode:

            return max(0, nowTurnNum - calcTurnNum)

        return max(0, nowTurnNum - calcTurnNum - 1)

    return 0



def TurnFightPerTurnBigStart(turnFight, batObj, turnNum):

    ## 大回合开始时

    if not batObj:

        return

    
    if batObj.GetHP() <= 0:

        return

    
    turnFight.ResetOneActionUseSkillCnt()

    TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_BigTurnStart)

    return



def TurnFightPerTurnBigEnd(turnFight, batObj, turnNum):

def TurnFightPerTurnBigEnd(turnFight, turnNum):

    ## 大回合结束时

    if not batObj:

        return

    

    if batObj.GetHP() <= 0:

        return

    
    TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_BigTurnEnd)

    batObjMgr = BattleObj.GetBatObjMgr()

    for faction, num in turnFight.actionSortList:

        GameWorld.DebugLogEx("回合结束逻辑: turnNum=%s,faction=%s, num=%s", turnNum, faction, num)

        batFaction = turnFight.getBatFaction(faction)

        batLineup = batFaction.getBatlineup(num)

        for objID in batLineup.posObjIDDict.values():

            batObj = batObjMgr.getBatObj(objID)

            if not batObj:

                continue

            if not batObj.IsAlive():

                continue

            
            turnFight.ResetOneActionUseSkillCnt()

            TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_BigTurnEnd)

            
    return



def TurnFightHeroTurnStart(turnFight, batObj, turnNum):

@@ -1469,12 +1740,134 @@
    if not batObj:

        return

    

    if batObj.GetHP() <= 0:

    if not batObj.IsAlive():

        return

    

    GameWorld.DebugLog("---[武将回合开始时] : curID=%s,curHP=%s/%s" % (batObj.GetID(), batObj.GetHP(), batObj.GetMaxHP()))

    GameWorld.DebugLogEx("---[武将回合开始] : curID=%s,curHP=%s/%s", batObj.GetID(), batObj.GetHP(), batObj.GetMaxHP())

    turnFight.ResetOneActionUseSkillCnt()

    RefreshObjBuffTime(turnFight, batObj)

    TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_HeroTurnStart)

    
    # 最后设置时机为回合后，说明：回合开启前的逻辑处理完后，其他的均默认为回合后

    batObj.SetTiming(ChConfig.TurnTiming_After)

    return



def TurnFightHeroTurnEnd(turnFight, batObj, turnNum):

    ## 武将回合结束时，不能行动也要触发

    if not batObj:

        return

    
    if not batObj.IsAlive():

        return

    
    GameWorld.DebugLogEx("---[武将回合结束] : curID=%s,curHP=%s/%s", batObj.GetID(), batObj.GetHP(), batObj.GetMaxHP())

    turnFight.ResetOneActionUseSkillCnt()

    RefreshObjBuffTime(turnFight, batObj)

    return



def ResetObjSkill(batObj):

    ## 重置所有技能，一般是每场战斗开始的重置

    curID = batObj.GetID()

    batObj.ResetSkillUseCnt() # 使用次数

    skillManager = batObj.GetSkillManager()

    for index in range(0, skillManager.GetSkillCount()):

        curSkill = skillManager.GetSkillByIndex(index)

        if not curSkill:

            continue

        skillID = curSkill.GetSkillID()

        initCD = curSkill.GetCoolDownInit()

        if initCD:

            curSkill.SetRemainTime(initCD)

            GameWorld.DebugLogEx("技能初始CD: curID=%s,skillID=%s,initCD=%s", curID, skillID, initCD)

        elif curSkill.GetRemainTime():

            curSkill.SetRemainTime(0)

        curSkill.SetEnergy(0)

        
    return



def RefreshObjSkillByBigTurn(batObj):

    '''按回合刷新技能：默认以大回合统一减1回合

    '''

    curID = batObj.GetID()

    skillManager = batObj.GetSkillManager()

    for index in range(0, skillManager.GetSkillCount()):

        curSkill = skillManager.GetSkillByIndex(index)

        if not curSkill:

            continue

        skillID = curSkill.GetSkillID()

        preTurnUseCnt = batObj.GetSkillTurnUseCnt(skillID)

        remainTime = curSkill.GetRemainTime()

        if remainTime <= 0:

            continue

        if preTurnUseCnt > 0:

            GameWorld.DebugLogEx("    上回合有使用技能本回合不刷新CD: curID=%s,skillID=%s,remainTime=%s,preTurnUseCnt=%s", curID, skillID, remainTime, preTurnUseCnt)

            continue

        remainTime -= 1

        curSkill.SetRemainTime(remainTime)

        GameWorld.DebugLogEx("    更新技能CD: curID=%s,skillID=%s,remainTime=%s", curID, skillID, remainTime)

    return



def RefreshObjByBigTurn(turnFight, batObj):

    ## 根据大回合开始刷新buff持续时间，每个大回合-1，第1回合不处理

    curID = batObj.GetID()

    buffMgr = batObj.GetBuffManager()

    for index in range(buffMgr.GetBuffCount())[::-1]:

        buff = buffMgr.GetBuffByIndex(index)

        buffID = buff.GetBuffID()

        skillID = buff.GetSkillID()

        skillData = buff.GetSkillData()

        if skillData.GetLastTimeType() != ChConfig.BuffLastTimeType_BigTurn:

            continue

        if skillData.GetSkillType() in ChConfig.Def_LstBuff_List:

            #GameWorld.DebugLogEx("    持续类buff由触发时机决定剩余时间! curID=%s,index=%s,skillID=%s,buffID=%s", curID, index, skillID, buffID)

            continue

        if skillData.GetSkillType() == ChConfig.Def_SkillType_Halo and buff.GetOwnerID() != curID:

            GameWorld.DebugLogEx("    光环buff非光源不处理! curID=%s,index=%s,skillID=%s,buffID=%s", curID, index, skillID, buffID)

            continue

        remainTime = buff.GetRemainTime()

        if remainTime <= 0:

            continue

        remainTime -= 1

        GameWorld.DebugLogEx("    更新buff回合: curID=%s,buffID=%s,skillID=%s,remainTime=%s", curID, buffID, skillID, remainTime)

        TurnBuff.SetBuffRemainTime(turnFight, batObj, buff, remainTime)

    return



def RefreshObjBuffTime(turnFight, batObj):

    '''刷新buff持续时间：以武将自身回合前、回合后处理buff持续时间

    回合前添加的buff在回合开始减1，回合后添加的buff在回合结束减1

    '''

    curID = batObj.GetID()

    curTiming = batObj.GetTiming() # 时间节点 0-回合前；1-回合后

    buffMgr = batObj.GetBuffManager()

    for index in range(buffMgr.GetBuffCount())[::-1]:

        buff = buffMgr.GetBuffByIndex(index)

        buffID = buff.GetBuffID()

        skillID = buff.GetSkillID()

        skillData = buff.GetSkillData()

        if skillData.GetLastTimeType() != ChConfig.BuffLastTimeType_Default:

            continue

        if skillData.GetSkillType() in ChConfig.Def_LstBuff_List:

            #GameWorld.DebugLogEx("    持续类buff由触发时机决定剩余时间! curID=%s,index=%s,skillID=%s,buffID=%s", curID, index, skillID, buffID)

            continue

        if skillData.GetSkillType() == ChConfig.Def_SkillType_Halo and buff.GetOwnerID() != curID:

            GameWorld.DebugLogEx("    光环buff非光源不处理! curID=%s,index=%s,skillID=%s,buffID=%s", curID, index, skillID, buffID)

            continue

        remainTime = buff.GetRemainTime()

        if remainTime <= 0:

            # 永久buff不处理

            #GameWorld.DebugLogEx("    永久buff不处理! curID=%s,index=%s,skillID=%s", curID, index, skillID)

            continue

        addTiming = buff.GetAddTiming()

        if not buff.GetRefreshState():

            GameWorld.DebugLogEx("    未刷新过的buff更新为刷新过! curID=%s,index=%s,skillID=%s,buffID=%s,addTiming=%s", curID, index, skillID, buffID, addTiming)

            buff.SetRefreshState(1)

            continue

        if addTiming != curTiming:

            GameWorld.DebugLogEx("    buff添加时机不同不处理! curID=%s,index=%s,skillID=%s,buffID=%s,addTiming=%s", curID, index, skillID, buffID, addTiming)

            continue

        remainTime -= 1

        GameWorld.DebugLogEx("    更新buff回合: curID=%s,buffID=%s,skillID=%s,remainTime=%s,addTiming=%s", curID, buffID, skillID, remainTime, addTiming)

        TurnBuff.SetBuffRemainTime(turnFight, batObj, buff, remainTime)

    return



def AddTurnObjCureHP(curObj, srcObj, addValue, cureHP, skillID=0):

@@ -1488,36 +1881,36 @@
    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))

    GameWorld.DebugLogEx("        统计治疗: 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, skillID=0, isBounce=False):

def AddTurnObjHurtValue(curBatObj, tagBatObj, hurtValue, lostHP, skillID=0, lostType=""):

    ## 回合对象添加伤害值

    # @param isBounce: 是否反弹伤害

    if hurtValue <= 0:

        return

    curID = curBatObj.GetID()

    tagID = tagBatObj.GetID()

    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))

        GameWorld.DebugLogEx("        统计输出: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,tagHP=%s,lostType=%s", 
                             curID, tagID, skillID, hurtValue, lostHP, updStatValue, tagBatObj.GetHP(), lostType)

        

        if tagBatObj:

            updStatValue = tagBatObj.StatDefValue(hurtValue)

            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))

            GameWorld.DebugLogEx("        统计承伤: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,curHP=%s,lostType=%s", 
                                 tagID, curID, skillID, hurtValue, lostHP, updStatValue, tagBatObj.GetHP(), lostType)

            

    else:

        # 如换血类技能，自残的伤害不算输出

        GameWorld.DebugLog("        自残: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,curHP=%s" 
                           % (curID, tagID, skillID, hurtValue, lostHP, curBatObj.GetHP()))

        GameWorld.DebugLogEx("        自残: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,curHP=%s", 
                             curID, tagID, skillID, hurtValue, lostHP, curBatObj.GetHP())

    return



def OnObjAction(turnFight, curBatObj, isExtra=False):

    ## 战斗单位行动

    # @param isExtra: 是否额外行动的

    if not curBatObj:

        return

    

@@ -1532,12 +1925,13 @@
    # 是否可行动状态判断

    canAction = curBatObj.CanAction()

    if not canAction:

        GameWorld.DebugLog("★回合%s %s 当前状态不可行动! isExtra=%s" % (turnNum, objName, isExtra))

        GameWorld.DebugLogEx("★回合%s %s 当前状态不可行动! isExtra=%s", turnNum, objName, isExtra)

        return

    

    atk = curBatObj.GetAtk()

    curXP = curBatObj.GetXP()

    GameWorld.DebugLog("★回合%s %s %s行动 : atk=%s,curHP=%s/%s,curXP=%s" % (turnNum, objName, "额外" if isExtra else "", atk, curHP, curBatObj.GetMaxHP(), curXP))

    GameWorld.DebugLogEx("★回合%s %s %s行动 : atk=%s,curHP=%s/%s,curXP=%s", turnNum, objName, "额外" if isExtra else "", atk, curHP, curBatObj.GetMaxHP(), curXP)

    turnFight.ResetOneActionUseSkillCnt()

    turnFight.syncObjAction(turnNum, objID)

    

    TurnPassive.OnTriggerPassiveEffect(turnFight, curBatObj, ChConfig.TriggerWay_HeroActionStart)

@@ -1545,7 +1939,7 @@
    xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2) 

    skillManager = curBatObj.GetSkillManager()

    useSkillList = []

    #GameWorld.DebugLog('skillCount=%s' % skillManager.GetSkillCount(), npcID)

    #GameWorld.DebugLogEx('skillCount=%s', skillManager.GetSkillCount(), npcID)

    for index in range(0, skillManager.GetSkillCount()):

        useSkill = skillManager.GetSkillByIndex(index)

        if not useSkill:

@@ -1562,18 +1956,21 @@
        skillID = useSkill.GetSkillID()

        # 常规攻击优先xp

        if SkillCommon.isAngerSkill(useSkill):

            if curXP < xpMax:

            if curXP < xpMax and not useSkill.GetEffectByID(ChConfig.SkillEff_AngerSkillNoXP):

                continue

            if curBatObj.CheckInState(ChConfig.BatObjState_Sneer):

                GameWorld.DebugLog("嘲讽状态下，无法主动释放怒技!") # 可被动释放怒技，如怒技追击

                GameWorld.DebugLogEx("嘲讽状态下，无法主动释放怒技! skillID=%s", skillID) # 可被动释放怒技，如怒技追击

                continue

            useCnt = -1 # xp技能优先释放

        else:

            if useSkill.GetEffectByID(ChConfig.SkillEff_ActionUseInvalid): # 配置该效果时如果被嘲讽，相当于无法行动

                GameWorld.DebugLogEx("行动时无法释放该技能! skillID=%s", skillID)

                continue

            useCnt = curBatObj.GetSkillUseCnt(skillID)

        useSkillList.append([useCnt, skillID, useSkill])

        

    useSkillList.sort() # 按使用次数优先升序排，使用次数低的优先判断使用

    #GameWorld.DebugLog('    技能使用顺序 = useSkillList%s' % str(useSkillList), npcID)

    #GameWorld.DebugLogEx('    技能使用顺序 = useSkillList%s', str(useSkillList), npcID)

    

    for useInfo in useSkillList:

        useSkill = useInfo[-1]

@@ -1584,27 +1981,35 @@
    return True



def SetObjKilled(turnFight, gameObj, killer=None, useSkill=None):

    curPlayer = turnFight.curPlayer

    npcID = gameObj.GetNPCID()

    
    # 非主线的PVE目标怪物

    if npcID and turnFight.getReqPlayerID() and turnFight.isFBMap() and gameObj.GetFaction() != ChConfig.Def_FactionA:

        if not FBLogic.OnFBNPCKilledBefore(turnFight, gameObj, killer, useSkill):

            return

        
    objID = gameObj.GetID()

    killerObjID = killer.GetID() if killer else 0

    skillID = useSkill.GetSkillID() if useSkill else 0

    GameWorld.DebugLog("        %s 回合战斗主体被击杀: curID=%s,killerObjID=%s,skillID=%s" % (GetObjName(gameObj), objID, killerObjID, skillID))

    GameWorld.DebugLogEx("        %s 回合战斗主体被击杀: curID=%s,killerObjID=%s,skillID=%s", GetObjName(gameObj), objID, killerObjID, skillID)

    gameObj.SetDead()

    TurnBuff.DoBuffByDead(turnFight, gameObj)

    

    clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagMCTurnFightObjDead)

    clientPack = ChPyNetSendPack.tagMCTurnFightObjDead()

    clientPack.ObjID = objID

    clientPack.KillerObjID = killerObjID

    clientPack.SkillID = skillID

    turnFight.addBatPack(clientPack)

    

    curPlayer = turnFight.curPlayer

    # 暂时只算主线小怪

    if curPlayer and turnFight.mapID == ChConfig.Def_FBMapID_Main and gameObj.GetFaction() != ChConfig.Def_FactionA:

        PlayerTask.AddTaskValue(curPlayer, ChConfig.TaskType_KillNPC, 1)    
        GetMainFightMgr(curPlayer).killNPCCnt += 1

    return True



def OnTurnAllOver(guid):

    ## 所有回合已经全部执行完毕

    GameWorld.DebugLog("所有回合结束")

    GameWorld.DebugLogEx("所有回合结束")

    turnFight = GetTurnFightMgr().getTurnFight(guid)

    if not turnFight:

        return

@@ -1612,9 +2017,12 @@
    if turnFight.winFaction:

        return

    

    if turnFight.playerID:

    if turnFight.getReqPlayerID():

        # 玩家发起的，未击杀对方，算玩家输

        turnFight.winFaction = ChConfig.Def_FactionB

        if turnFight.mapID in ChConfig.PlayerWinMapIDList:

            turnFight.winFaction = ChConfig.Def_FactionA

        else:

            turnFight.winFaction = ChConfig.Def_FactionB

    else:

        # 系统场次，按一定规则来，这里先随机

        turnFight.winFaction = random.choice([ChConfig.Def_FactionA, ChConfig.Def_FactionB])

@@ -1632,44 +2040,64 @@
    turnFight.costTime = time.time() - turnFight.startTime

    winFaction = turnFight.winFaction

    turnFight.isWin = (winFaction == ChConfig.Def_FactionA)

    GameWorld.DebugLog("--- 战斗结束处理 ---, winFaction=%s, costTime=%ss, %s" % (winFaction, turnFight.costTime, guid))

    
    mapID = turnFight.mapID

    funcLineID = turnFight.funcLineID

    reqPlayerID = turnFight.getReqPlayerID()

    GameWorld.DebugLogEx("--- 战斗结束处理 ---, winFaction=%s, costTime=%ss, %s", winFaction, turnFight.costTime, guid)

    if mapID != ChConfig.Def_FBMapID_Main:

        GameWorld.Log("战斗耗时: %ss, mapID=%s,funcLineID=%s,turnNum=%s/%s" % (turnFight.costTime, mapID, funcLineID, turnFight.turnNum, turnFight.turnMax))

        
    # 统计明细

    heroCount = 0

    batObjMgr = BattleObj.GetBatObjMgr()

    statInfo = {}

    drLineupInfo = {}

    for faction in turnFight.factionDict.keys():

        if str(faction) not in statInfo:

            statInfo[str(faction)] = {}

        facStatInfo = statInfo[str(faction)]

        if str(faction) not in drLineupInfo:

            drLineupInfo[str(faction)] = {}

        facDRLineupInfo = drLineupInfo[str(faction)]

        batFaction = turnFight.getBatFaction(faction)

        batFaction.totalHurt = 0

        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))

            batLineup.totalHurt = 0

            facDRLineupInfo[str(num)] = batLineup.lineupInfo

            GameWorld.DebugLogEx("阵容明细: faction=%s,num=%s", faction, num)

            for posNum, objID in batLineup.posObjIDDict.items():

                batObj = batObjMgr.getBatObj(objID)

                if not batObj:

                    continue

                heroCount += 1

                objID = batObj.GetID()

                npcID = batObj.GetNPCID()

                heroID = batObj.GetHeroID()

                atkHurt = batObj.hurtStat

                defHurt = batObj.defStat

                cureHP = batObj.cureStat

                GameWorld.DebugLog("    Pos:%s ID=%s,npcID=%s,heroID=%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}

                batLineup.totalHurt += atkHurt

                batFaction.totalHurt += atkHurt

                dead = 0 if batObj.IsAlive() else 1

                GameWorld.DebugLogEx("    Pos:%s ID=%s,npcID=%s,heroID=%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, 
                                               "LV":batObj.GetLV(), "Star":batObj.GetStar(), "Skin":batObj.GetSkinID(), "Dead":dead}

                

    overMsg = {"winFaction":winFaction, "statInfo":statInfo}

    curPlayer = turnFight.curPlayer

    mapID = turnFight.mapID

    funcLineID = turnFight.funcLineID

    statMsg = {"winFaction":winFaction, "statInfo":statInfo}

    

    FBLogic.OnTurnFightOver(curPlayer, turnFight, mapID, funcLineID, overMsg)

    FBLogic.OnTurnFightOver(turnFight, mapID, funcLineID, statMsg)

    

    turnFight.syncState(FightState_Award, overMsg)

    turnFight.syncState(FightState_Award, statMsg)

    
    # 流向记录

    if mapID != ChConfig.Def_FBMapID_Main and reqPlayerID:

        DataRecordPack.DR_FightStat(reqPlayerID, mapID, funcLineID, turnFight.isWin, turnFight.turnNum, turnFight.turnMax, 
                                    heroCount, turnFight.costTime, statInfo, drLineupInfo)

    return



#// B4 14 查看战报 #tagCSTurnFightReportView

@@ -1703,4 +2131,66 @@
    clientPack.Len = len(clientPack.Report)

    NetPackCommon.SendFakePack(curPlayer, clientPack)

    return



def __saveBatBuffer(turnFight):

    ## 持久化战报

    
    reqPlayerID = turnFight.getReqPlayerID()

    reqServerID = turnFight.getReqServerID()

    
    guid = turnFight.guid

    ReportRoot = "C:\TurnFightReport"

    
    dateStr = GameWorld.ChangeTimeNumToStr(int(time.time()), "%Y%m%d") 
    ReportDir = os.path.join(ReportRoot, "S%s" % reqServerID, dateStr, "%s" % reqPlayerID, "%s" % turnFight.mapID)

    if not os.path.exists(ReportDir):

        os.makedirs(ReportDir)

    else:

        items = os.listdir(ReportDir)

        for item in items:

            fullPath = os.path.join(ReportDir, item)

            try:

                os.remove(fullPath)

            except:

                pass

            
    saveFilePath = os.path.join(ReportDir, "%s.tfr" % guid)

    GameWorld.DebugLogEx("战报路径=%s", saveFilePath)

    
    try:

        clientPack = ChPyNetSendPack.tagSCTurnFightReport()

        clientPack.GUID = guid

        clientPack.Report = turnFight.batBuffer

        clientPack.Len = len(clientPack.Report)

        fp = open(saveFilePath, "wb")

        fp.write(clientPack.GetBuffer())

        fp.close()

    except:

        return

    
    turnFight.dateStr = dateStr

    return True



def SyncTurnFightRet(curPlayer, guid, mapID, funcLineID, reqData, isWin, statMsg, dateStr, awardDict):

    tagType, tagID, valueList = 0, 0, []

    if reqData and len(reqData) == 3:

        tagType, tagID, valueList = reqData

    clientPack = ChPyNetSendPack.tagSCTurnFightRet()

    clientPack.MapID = mapID

    clientPack.FuncLineID = funcLineID

    clientPack.TagType = tagType

    clientPack.TagID = tagID

    clientPack.ValueList = valueList

    clientPack.ValueCount = len(clientPack.ValueList)

    
    clientPack.IsWin = isWin

    clientPack.AwardMsg = json.dumps(awardDict, ensure_ascii=False).replace(" ", "")

    clientPack.AwardLen = len(clientPack.AwardMsg)

    clientPack.BatStatMsg = json.dumps(statMsg, ensure_ascii=False).replace(" ", "")

    clientPack.BatLen = len(clientPack.BatStatMsg)

    clientPack.PathDate = dateStr

    clientPack.GUID = guid

    NetPackCommon.SendFakePack(curPlayer, clientPack)

    return