129 【战斗】战斗系统-服务端（优化战斗与结算逻辑分离；优化战斗结果同步及战报；）

hxp

2025-12-01 1a9aa08e61a036b6c051cb072f7b4c8c746662b3

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

@@ -47,6 +47,8 @@
import random

import time

import json

import shutil

import os



g_gmTestFightReq = []



@@ -86,7 +88,7 @@
        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

    

@@ -99,7 +101,7 @@
        self.fightPower = lineupInfo.get("FightPower", 0)

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

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

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

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

        return

    

    def clearLineup(self):

@@ -171,10 +173,11 @@
    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

        self.curPlayer = None

        self.mapID = mapID

        self.funcLineID = funcLineID

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

@@ -185,10 +188,11 @@
        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.awardData = None # 战斗奖励设置的数据，可以是任意数据格式，由功能自行决定，会传递给 OnTurnFightAward 处理

        

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

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

@@ -203,38 +207,40 @@
        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.awardData = None

        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 getPVPPlayerID(self): return self.tagPlayerID # 获取PVP目标玩家ID，也可用于判断是否PVP

    def isPVP(self): return self._isPVP

    

    def isFBMap(self):

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

@@ -242,9 +248,6 @@
    

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

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

    
    #def setPVPTeam(self):

    #    return

    

    def nextTurnFight(self, msgDict={}):

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

@@ -421,6 +424,8 @@
    

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

@@ -449,7 +454,7 @@
            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))

@@ -479,10 +484,10 @@
        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 = ObjPool.GetPoolMgr().acquire(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

    

@@ -521,7 +526,7 @@
        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

@@ -860,20 +865,16 @@
    GameWorld.DebugLog("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

    '''

    lineupPlayerID = lineupInfo.get("PlayerID", 0) # 阵容所属玩家ID

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

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

    if playerID:

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

        if not curPlayer:

            return

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

        

    turnFight = batLineup.turnFight

    tfGUID = turnFight.guid

@@ -948,7 +949,7 @@
        

        if npcID:

            #副本指定NPC属性

            fbNPCInitAttrDict = FBLogic.GetFBNPCInitAttr(curPlayer, turnFight, batObj)

            fbNPCInitAttrDict = FBLogic.GetFBNPCInitAttr(turnFight, batObj)

            if fbNPCInitAttrDict:

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

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

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

    '''

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

    playerID = curPlayer.GetPlayerID()

    mapID = clientData.MapID

    funcLineID = clientData.FuncLineID

    tagType = clientData.TagType

@@ -1035,7 +1037,7 @@
    valueList = clientData.ValueList

    

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

                       % (mapID, funcLineID, tagType, tagID, valueList), curPlayer.GetPlayerID())

                       % (mapID, funcLineID, tagType, tagID, valueList), playerID)

    

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

    if not reqRet:

@@ -1059,10 +1061,33 @@
    if CheckFightCD(curPlayer, tick, "TurnFightReqTick"):

        return

    

    reqPlayerID = playerID

    guid = GameWorld.GetGUID()

    
    atkLineupInfo = GetPlayerLineupInfo(curPlayer, atkLineupID)

    if not atkLineupInfo:

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

        return

    
    # 玩家

    if tagType == 1:

        if not OnTurnFightVSPlayer(curPlayer, mapID, funcLineID, atkLineupID, defLineupID, tagID):

        tagPlayerID = tagID

        tagViewCache = PlayerViewCache.FindBattleViewCache(tagPlayerID)

        if not tagViewCache:

            # 跨服玩家待扩展

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

            PlayerControl.NotifyCode(curPlayer, "TagNoViewCache")

            return

        
        defLineupInfo = GetCacheLineupInfo(tagViewCache, defLineupID)

        if not defLineupInfo:

            GameWorld.DebugLog("目标玩家没有该阵容数据! 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, reqData=[tagType, tagID, valueList])

        

    # NPC

    else:

@@ -1077,38 +1102,117 @@
            if not ret:

                return

            npcLineupIDList, strongerLV, difficulty = ret

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

            return

        

    return True



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)

        #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, npcLineupIDList, strongerLV, difficulty)

        
    return True



def AddToBattleQueue(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID=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

    
    # 先默认本地图处理，后续优化多战斗地图支持

    
    reqServerID = GameWorld.GetGameWorld().GetServerID()

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

    OnMsg_BattleRequest(reqInfo)

    return



def OnMsg_BattleRequest(reqInfo):

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

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

    
    if npcLineupIDList:

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

    else:

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

        
    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 reqServerID == GameWorld.GetGameWorld().GetServerID():

        OnMsg_BattleResult(retInfo)

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

    else:

        pass

    
    return



def OnMsg_BattleResult(retInfo):

    ## 收到战斗结果信息

    
    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 DoTurnFightPVE(guid, mapID, funcLineID, reqPlayerID, reqServerID, 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, reqServerID)

    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

@@ -1119,58 +1223,40 @@
        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) # 同步战报

    #在同步战报后再处理结算奖励，与战斗表现分离

    FBLogic.OnTurnFightAward(curPlayer, turnFight, mapID, funcLineID, turnFight.awardData)

    saveOK = __saveBatBuffer(turnFight)

    tfMgr.delTurnFight(guid)

    return True

    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)

        PlayerControl.NotifyCode(curPlayer, "TagNoViewCache")

        return

    defLineupInfo = GetCacheLineupInfo(tagViewCache, defLineupID)

    if not defLineupInfo:

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

        PlayerControl.NotifyCode(curPlayer, "TagNoLineup")

        return

def DoTurnFightPVP(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID=0, reqServerID=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, reqServerID)

    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)

    FBLogic.OnTurnFightAward(curPlayer, turnFight, mapID, funcLineID, turnFight.awardData)

    saveOK = __saveBatBuffer(turnFight)

    tfMgr.delTurnFight(guid)

    return True

    return turnFight if saveOK else None



def GetTurnMax(mapID):

    if mapID == ChConfig.Def_FBMapID_Main:

@@ -1324,7 +1410,7 @@
                       % (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)})

@@ -1463,9 +1549,8 @@
        

    return



def __processTurnFight(guid):

def __processTurnFight(turnFight):

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

    turnFight = GetTurnFightMgr().getTurnFight(guid)

    curPlayer = turnFight.curPlayer

    turnMax = turnFight.turnMax

    EntryLogic(turnFight)

@@ -1480,9 +1565,6 @@
            

        # 回合开始

        TurnFightPerTurnBigStart(turnFight, turnNum)

                 
        # 红颜

        # 灵兽

            

        if turnFight.winFaction:

            break

@@ -1854,8 +1936,8 @@
    npcID = gameObj.GetNPCID()

    

    # 非主线的PVE目标怪物

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

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

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

@@ -1886,7 +1968,7 @@
    if turnFight.winFaction:

        return

    

    if turnFight.playerID:

    if turnFight.getReqPlayerID():

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

        turnFight.winFaction = ChConfig.Def_FactionB

    else:

@@ -1944,12 +2026,11 @@
                                   % (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}

                

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

    curPlayer = turnFight.curPlayer

    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)

    return



#// B4 14 查看战报 #tagCSTurnFightReportView

@@ -1984,3 +2065,58 @@
    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)

    
    GameWorld.DebugLog("ReportDir=%s" % ReportDir)

    if not os.path.exists(ReportDir):

        os.makedirs(ReportDir)

    else:

        shutil.rmtree(ReportDir)

        os.makedirs(ReportDir)

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

    GameWorld.DebugLog("saveFilePath=%s" % saveFilePath)

    
    try:

        fp = open(saveFilePath, "w")

        fp.write(turnFight.batBuffer)

        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