Project_SG_ServerCode.git

			@@ -21,11 +21,15 @@

			import ChConfig
			import PlayerTask
			import PlayerActivity
			import PlayerViewCache
			import ChPyNetSendPack
			import NetPackCommon
			import PlayerControl
			import GameWorld
			import PlayerLLMJ
			import PlayerPrestigeSys
			import CrossServerPackLogic
			import IpyGameDataPY
			import PlayerOnline
			import NPCCommon
			@@ -36,6 +40,7 @@
			import TurnPassive
			import TurnSkill
			import TurnBuff
			import FBCommon
			import CommFunc
			import ObjPool
			import FBLogic
			@@ -43,8 +48,10 @@
			import random
			import time
			import json
			import os

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

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

			@@ -70,12 +77,18 @@
			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

			@@ -86,7 +99,9 @@
			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):
			@@ -99,10 +114,25 @@
			for objID in self.beautyObjIDDict.values():
			batObjMgr.delBatObj(objID)
			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 +141,7 @@
			self.turnFight = turnFight # TurnFight
			self.faction = faction
			self.lineupDict = {} # 该阵营所有阵容信息 {编号:BatLineup, ...}
			self.totalHurt = 0 # 阵营总输出
			return

			def getBatlineup(self, num=1):
			@@ -122,6 +153,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 +173,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
			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 # 时间轴节点 turnNum1000+actionIndex100++actionNum
			self.actionIndex = 0 # 行动顺序索引
			self.startTime = 0 # 开始时间戳，支持毫秒小数
			self.costTime = 0 # 单场战斗总耗时，支持毫秒小数
			self._oneActionUseSkillCntDict = {} # 某对象行动开始后所有对象累计使用技能次数，用于单对象单次行动中限制每个对象的最高触发技能次数 {objID:useCnt, ...}
			@@ -170,50 +207,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):
			@@ -258,21 +304,6 @@
			GameWorld.DebugLog("阵容战力排序[isPlayer, fp, sortV, f, n]: %s" % sortList)
			GameWorld.DebugLog("阵容行动顺序[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
			@@ -327,7 +358,7 @@
			## 准备就绪，开始战斗
			self.state = FightState_Start
			self.turnNum = 1
			self.timeline = self.getTurnNumStartTimelin(self.turnNum)
			self.turnNumStart = 0
			self.syncInit()
			return

			@@ -372,7 +403,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 +417,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,9 +454,10 @@
			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, %s" % (headStr, buffLen, CommFunc.B2Hex(packBuff)))
			GameWorld.DebugLog("回合战斗过程封包: %s, len:%s" % (headStr, buffLen))
			self.batBuffer += CommFunc.WriteWORD("", buffLen)
			self.batBuffer += packBuff
			@@ -439,13 +481,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 = 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

			@@ -484,7 +527,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 +581,8 @@
			## 获取玩家阵容
			olPlayer = PlayerOnline.GetOnlinePlayer(curPlayer)
			lineup = olPlayer.GetLineup(lineupID)
			if not lineup.lineupHeroDict:
			# 为空时默认取主阵容
			if lineup.IsEmpty():
			GameWorld.DebugLog("玩家没有目标阵容默认取主阵容! lineupID=%s" % lineupID, curPlayer.GetPlayerID())
			lineup = olPlayer.GetLineup(ShareDefine.Lineup_Main)
			return lineup

			@@ -538,12 +593,12 @@

			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
			@@ -578,13 +633,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 +655,96 @@
			continue
			heroDict[str(posNum)] = battleDict

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

			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: 成长等级
			@@ -719,21 +866,19 @@
			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
			'''
			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.DebugLog("SummonLineupObjs faction:%s,num:%s,npcLineupID=%s,lineupPlayerID=%s" % (faction, num, npcLineupID, lineupPlayerID), reqPlayerID)

			turnFight = batLineup.turnFight
			tfGUID = turnFight.guid
			heroDict = lineupInfo.get("Hero", {})

			batObjMgr = BattleObj.GetBatObjMgr()
			@@ -799,7 +944,16 @@
			skillManager.LearnSkillByID(skillID)

			batLineup.posObjIDDict[posNum] = objID
			batLineup.heroObjIDDict[heroID] = objID
			GameWorld.DebugLog("AddBatObj %s,skill=%s" % (GetObjName(batObj), skillManager.GetSkillIDList()))
			ResetObjSkill(batObj)

			if npcID:
			#副本指定NPC属性
			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()} # 统一格式
			batObj.InitBatAttr({int(k):v for k, v in attrDict.items()}, initXP)

			return
			@@ -821,21 +975,44 @@
			if not batObj.IsAlive():
			GameWorld.DebugLog(" 已被击杀不处理! %s" % (objName))
			continue
			GameWorld.DebugLog(" 重置武将: %s, HP:%s/%s, XP:%s" % (objName, batObj.GetHP(), batObj.GetMaxHP(), batObj.GetXP()))

			batObj.TurnReset()
			GameWorld.DebugLog("重置武将: %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.DebugLog("回合制战斗请求服务器公共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.DebugLog("回合制战斗请求CD中: %s" % selfKey)
			PlayerControl.NotifyCode(curPlayer, "BattleCoolDown")
			return True

			tfMgr.lastRequestTick = tick
			curPlayer.SetDict(selfKey, tick)
			return False

			#// B4 10 回合制战斗 #tagCMTurnFight
			#
			@@ -853,122 +1030,243 @@
			''' 本战斗会一次性处理完所有小队战斗，以战报的形式下发，目前除了主线小怪分段战斗外，均使用该战斗
			'''
			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.DebugLog("----- 回合制战斗请求: 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.DebugLog("不存在该副本功能线路! 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 tagType == 1:
			OnTurnFightVSPlayer(curPlayer, mapID, funcLineID, atkLineupID, defLineupID, tagID)

			# NPC
			else:
			ret = FBLogic.GetFBNPCLineupInfo(curPlayer, mapID, funcLineID)
			if not ret:
			return
			npcLineupIDList, strongerLV, difficulty = ret
			OnTurnFightVSNPC(curPlayer, mapID, funcLineID, atkLineupID, npcLineupIDList, strongerLV, difficulty)

			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:
			if CheckFightCD(curPlayer, tick, "TurnFightReqTick"):
			return

			lineupMainInfo = GetPlayerLineupInfo(curPlayer, atkLineupID)
			if not lineupMainInfo:
			GameWorld.DebugLog("玩家没有该阵容数据! atkLineupID=%s" % atkLineupID, playerID)
			return
			reqPlayerID = playerID
			guid = GameWorld.GetGUID()

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

			turnFight.setTurnFight(mapID, funcLineID, turnMax, True)
			turnFight.setPVE(npcLineupIDList, strongerLV, difficulty)
			turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo})

			for index, lineupID in enumerate(npcLineupIDList):
			turnFight.lineupIndex = index
			GameWorld.DebugLog("对战NPC阵容: index=%s, lineupID=%s" % (index, lineupID))
			if index > 0:
			turnFight.nextTurnFight(resetByNextTeam=True)
			turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID, strongerLV, difficulty)})
			turnFight.sortActionQueue()
			turnFight.startFight()

			__processTurnFight(turnFight.guid)

			if not turnFight.isWin:
			break

			PlayerOnline.GetOnlinePlayer(curPlayer).SetLastBatBuffer(guid, turnFight.batBuffer)
			SyncTurnFightReport(curPlayer, guid, turnFight.batBuffer)
			tfMgr.delTurnFight(guid)
			return

			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)
			# 玩家
			if tagType == 1:
			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:
			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

			#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 = [guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, npcLineupIDList, strongerLV, difficulty, reqData]
			multiMapSet = IpyGameDataPY.GetFuncCfg("TurnFightProcess", 1)
			# 多地图战斗 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, reqServerID)
			return

			def SSMsg_BattleRequest(reqInfo, fromServerID):
			## 请求执行战斗，由本地图或其他服务器地图分配过来的战斗请求
			guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, npcLineupIDList, strongerLV, difficulty, reqData = reqInfo

			if npcLineupIDList:
			turnFight = DoTurnFightPVE(guid, mapID, funcLineID, reqPlayerID, fromServerID, lineupDictA, npcLineupIDList, strongerLV, difficulty)
			else:
			turnFight = DoTurnFightPVP(guid, mapID, funcLineID, lineupDictA, lineupDictB, reqPlayerID, fromServerID)

			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 DoTurnFightPVE(guid, mapID, funcLineID, reqPlayerID, reqServerID, playerLineupDict, npcLineupIDList, strongerLV, difficulty):
			'''执行PVE战斗，支持多小队
			'''

			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.setPVE(npcLineupIDList, strongerLV, difficulty)
			turnFight.setFactionLineup(ChConfig.Def_FactionA, playerLineupDict)

			for index, lineupID in enumerate(npcLineupIDList):
			turnFight.lineupIndex = index
			GameWorld.DebugLog("对战NPC阵容: index=%s, lineupID=%s" % (index, lineupID))
			if index > 0:
			turnFight.nextTurnFight()
			turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID, strongerLV, difficulty)})
			turnFight.sortActionQueue()
			turnFight.startFight()

			__processTurnFight(turnFight)

			if not turnFight.isWin:
			break

			saveOK = __saveBatBuffer(turnFight)
			tfMgr.delTurnFight(guid)
			return turnFight if saveOK else None

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

			turnFight.setTurnFight(mapID, funcLineID, turnMax, True)
			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 +1294,10 @@
			__doSetFightPoint(curPlayer, reqValue)
			return

			GameWorld.DebugLog("主线战斗请求: reqType=%s" % reqType, curPlayer.GetPlayerID())
			GameWorld.DebugLog("------------------- 主线战斗请求: reqType=%s" % reqType, curPlayer.GetPlayerID())
			mainFightMgr = GetMainFightMgr(curPlayer)
			mainFightMgr.resetMainFightExDataRec() # 请求时补重置，防止异常时重复结算逻辑

			clientPack = ChPyNetSendPack.tagSCTurnFightReportSign()
			clientPack.Sign = 0
			NetPackCommon.SendFakePack(curPlayer, clientPack) # 标记开始
			@@ -1011,6 +1312,34 @@
			# 标记结束
			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)
			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)

			# 结算逻辑最后重置数据
			mainFightMgr.resetMainFightExDataRec()
			return

			def __doExitMainFight(curPlayer):
			@@ -1024,15 +1353,13 @@
			def __doSetFightPoint(curPlayer, fightPoint):
			## 设置消耗倍值
			GameWorld.DebugLog("设置战锤消耗倍值: %s" % fightPoint)
			if fightPoint == 1:
			pass
			elif fightPoint == 2:
			# 条件验证
			pass
			elif fightPoint == 3:
			# 条件验证
			pass
			else:
			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.DebugLog("祝福树等级不足: treeLV=%s < %s" % (treeLV, needTreeLV))
			return
			curPlayer.SetFightPoint(fightPoint)
			return
			@@ -1093,7 +1420,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)})
			@@ -1110,12 +1437,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
			@@ -1135,7 +1458,7 @@
			if nextLineupID:
			GameWorld.DebugLog("---开始进入下一小队: 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()
			@@ -1162,49 +1485,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.DebugLog("【----- 回合制战斗轮次: %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.DebugLog("武将位置: 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.DebugLog("没有武将: faction=%s,posNum=%s" % (faction, posNum))
			continue

			objID = batLineup.posObjIDDict[posNum]
			@@ -1213,13 +1526,16 @@
			# 玩家自己阵营，预判可否行动
			if checkBreakpoint and faction == ChConfig.Def_FactionA and batObj:
			if batObj.CanAction():
			GameWorld.DebugLog("玩家阵容下一个可行动的武将，断点: curTimeline=%s,nextPosNum=%s" % (curTimeline, posNum))
			GameWorld.DebugLog("玩家阵容下一个可行动的武将，断点: 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 +1548,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)
			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 +1590,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 +1605,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)
			@@ -1354,114 +1643,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.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)
			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.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)
			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 +1701,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.DebugLog("---[武将回合开始] : 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.DebugLog("---[武将回合结束] : 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.DebugLog("技能初始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.DebugLog(" 上回合有使用技能本回合不刷新CD: curID=%s,skillID=%s,remainTime=%s,preTurnUseCnt=%s" % (curID, skillID, remainTime, preTurnUseCnt))
			continue
			remainTime -= 1
			curSkill.SetRemainTime(remainTime)
			GameWorld.DebugLog(" 更新技能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.DebugLog(" 持续类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.DebugLog(" 光环buff非光源不处理! curID=%s,index=%s,skillID=%s,buffID=%s" % (curID, index, skillID, buffID))
			continue
			remainTime = buff.GetRemainTime()
			if remainTime <= 0:
			continue
			remainTime -= 1
			GameWorld.DebugLog(" 更新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.DebugLog(" 持续类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.DebugLog(" 光环buff非光源不处理! curID=%s,index=%s,skillID=%s,buffID=%s" % (curID, index, skillID, buffID))
			continue
			remainTime = buff.GetRemainTime()
			if remainTime <= 0:
			# 永久buff不处理
			#GameWorld.DebugLog(" 永久buff不处理! curID=%s,index=%s,skillID=%s" % (curID, index, skillID))
			continue
			addTiming = buff.GetAddTiming()
			if not buff.GetRefreshState():
			GameWorld.DebugLog(" 未刷新过的buff更新为刷新过! curID=%s,index=%s,skillID=%s,buffID=%s,addTiming=%s" % (curID, index, skillID, buffID, addTiming))
			buff.SetRefreshState(1)
			continue
			if addTiming != curTiming:
			GameWorld.DebugLog(" buff添加时机不同不处理! curID=%s,index=%s,skillID=%s,buffID=%s,addTiming=%s" % (curID, index, skillID, buffID, addTiming))
			continue
			remainTime -= 1
			GameWorld.DebugLog(" 更新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):
			@@ -1493,22 +1847,21 @@

			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.DebugLog(" 统计输出: 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.DebugLog(" 统计承伤: 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:
			# 如换血类技能，自残的伤害不算输出
			@@ -1518,6 +1871,7 @@

			def OnObjAction(turnFight, curBatObj, isExtra=False):
			## 战斗单位行动
			# @param isExtra: 是否额外行动的
			if not curBatObj:
			return

			@@ -1538,6 +1892,7 @@
			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))
			turnFight.ResetOneActionUseSkillCnt()
			turnFight.syncObjAction(turnNum, objID)

			TurnPassive.OnTriggerPassiveEffect(turnFight, curBatObj, ChConfig.TriggerWay_HeroActionStart)
			@@ -1562,13 +1917,16 @@
			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.DebugLog("嘲讽状态下，无法主动释放怒技! skillID=%s" % skillID) # 可被动释放怒技，如怒技追击
			continue
			useCnt = -1 # xp技能优先释放
			else:
			if useSkill.GetEffectByID(ChConfig.SkillEff_ActionUseInvalid): # 配置该效果时如果被嘲讽，相当于无法行动
			GameWorld.DebugLog("行动时无法释放该技能! skillID=%s" % skillID)
			continue
			useCnt = curBatObj.GetSkillUseCnt(skillID)
			useSkillList.append([useCnt, skillID, useSkill])

			@@ -1584,11 +1942,20 @@
			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))
			gameObj.SetDead()
			TurnBuff.DoBuffByDead(turnFight, gameObj)

			clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagMCTurnFightObjDead)
			clientPack.ObjID = objID
			@@ -1596,10 +1963,9 @@
			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):
			@@ -1612,7 +1978,7 @@
			if turnFight.winFaction:
			return

			if turnFight.playerID:
			if turnFight.getReqPlayerID():
			# 玩家发起的，未击杀对方，算玩家输
			turnFight.winFaction = ChConfig.Def_FactionB
			else:
			@@ -1632,8 +1998,12 @@
			turnFight.costTime = time.time() - turnFight.startTime
			winFaction = turnFight.winFaction
			turnFight.isWin = (winFaction == ChConfig.Def_FactionA)
			mapID = turnFight.mapID
			funcLineID = turnFight.funcLineID
			GameWorld.DebugLog("--- 战斗结束处理 ---, 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))

			# 统计明细
			batObjMgr = BattleObj.GetBatObjMgr()
			statInfo = {}
			@@ -1642,11 +2012,13 @@
			statInfo[str(faction)] = {}
			facStatInfo = statInfo[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)
			batLineup.totalHurt = 0
			GameWorld.DebugLog("阵容明细: faction=%s,num=%s" % (faction, num))
			for posNum, objID in batLineup.posObjIDDict.items():
			batObj = batObjMgr.getBatObj(objID)
			@@ -1658,18 +2030,17 @@
			atkHurt = batObj.hurtStat
			defHurt = batObj.defStat
			cureHP = batObj.cureStat
			batLineup.totalHurt += atkHurt
			batFaction.totalHurt += atkHurt
			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}

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

			#// B4 14 查看战报 #tagCSTurnFightReportView
			@@ -1703,4 +2074,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.DebugLog("__saveBatBuffer=%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