Project_SG_ServerCode.git

			@@ -20,30 +20,32 @@
			#-------------------------------------------------------------------------------

			import ChConfig
			import PlayerTask
			import PlayerViewCache
			import ChPyNetSendPack
			import NetPackCommon
			import PlayerControl
			import GameWorld
			import GameObj
			import FBCommon
			import IpyGameDataPY
			import PlayerOnline
			import NPCCommon
			import ShareDefine
			import PyGameData
			import IPY_GameWorld
			import ItemControler
			import SkillCommon
			import SkillShell
			import AttackCommon
			import BattleObj
			import TurnPassive
			import TurnSkill
			import TurnBuff
			import CommFunc
			import ObjPool
			import FBLogic

			import random
			import time
			import json

			FighterNPCID = 100 # 战斗NPCID，仅后端用，除怪物外，所有玩家武将均使用该NPCID
			PosNumMax = 10 # 最大站位编号
			TimelineSet = 10000 # 单回合最大时间轴
			PosNumMax = 7 # 最大站位编号
			ActionNumStart = -1 # 起始行动位置编号，一般是从1开始，如果有加主公、红颜等则扣除相应位置值，如从0或-1开始

			# 回合战斗流程状态
			@@ -54,130 +56,59 @@
			FightState_FightEnd, # 3 战斗结束
			FightState_Award, # 4 结算奖励
			FightState_Over, # 5 结束状态，无特殊意义，仅代表所有处理结束了，与Start对应
			) = range(6)

			Def_FactionA = 1
			Def_FactionB = 2

			FightState_Rest, # 6 结束并休息，一般是前端主动退出并休息的
			) = range(7)

			class BatLineup():
			## 战斗阵容

			def __init__(self, faction, num, fightMgr):
			self.fightMgr = fightMgr
			def __init__(self, faction, num, turnFight):
			self.turnFight = turnFight # TurnFight
			self.faction = faction # 所属阵营
			self.num = num # 该阵容所在阵营中的编号，不同阵营可重复，多V多
			self.ownerID = 0 # 阵容所属玩家ID，可能为0，0代表非玩家阵容
			self.npcPosDict = {} # 阵容NPC {站位编号:curNPC, ...}, 站位编号小于0为非主战单位，如主公、红颜等
			self.npcObjIDDict = {} # NPC实例ID字典 {objID:curNPC, ...}
			self.shapeType = 0 # 阵型
			self.actionNum = ActionNumStart # 行动位置，从1开始
			self.lordAttrDict = {} # 主公属性
			self.npcAttrDict = {} # 阵容NPC属性 {npcID:{attrID:value, ...}, ...}
			self.fightPower = 0 # 阵容总战力

			# 战斗统计
			self.hurtStatDict = {} # 输出统计 {objID:totalValue, ...}
			self.defStatDict = {} # 承伤统计 {objID:totalValue, ...}
			self.cureStatDict = {} # 治疗统计 {objID:totalValue, ...}
			self.posObjIDDict = {} # 站位对应战斗实体 {站位编号:batObjID, ...}, 站位编号小于0为非主战单位，如主公、红颜等
			self.lingshouObjIDDict = {} # 灵兽战斗单位 {位置编号:batObjID, ...}
			self.beautyObjIDDict = {} # 红颜战斗单位 {位置编号:batObjID, ...}
			self.actionNum = ActionNumStart # 行动位置，从1开始
			return

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

			def isEmpty(self): return not self.npcPosDict
			def isEmpty(self): return not self.posObjIDDict

			def setLineup(self, lineupInfo):
			## 设置阵容
			# @param lineupInfo: 阵容信息
			self.clearLineup()
			self.ownerID = lineupInfo.get("PlayerID", 0) # 阵容所属的玩家ID
			self.shapeType = lineupInfo.get("Shape", 0)
			self.lordAttrDict = lineupInfo.get("LordAttrDict", {})
			self.shapeType = lineupInfo.get("ShapeType", 0)
			self.fightPower = lineupInfo.get("FightPower", 0)
			SummonLineupObjs(self, self.faction, self.num, lineupInfo, self.getPlayerID())
			return

			def refreshFightPower(self):
			## 刷新阵容总战力
			if self.fightPower:
			return self.fightPower

			return self.fightPower

			def __resetStat(self):
			## 重置战斗统计
			self.actionNum = ActionNumStart
			self.hurtStatDict = {}
			self.defStatDict = {}
			self.cureStatDict = {}
			return

			def __resetAttrState(self, isReborn=True):
			## 重置属性状态
			# @param isReborn: 是否复活
			initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
			for curNPC in self.npcPosDict.values():
			if not curNPC:
			continue
			if GameObj.GetHP(curNPC) <= 0 and not isReborn:
			continue
			# 回满血，清除buff
			GameObj.SetHPFull(curNPC, False)
			# 重置怒气
			GameObj.SetXP(curNPC, initXP, False)
			# ...

			return

			def resetLineup(self, isReborn=True):
			## 重置阵容
			self.__resetAttrState(isReborn)
			self.__resetStat()
			return

			def clearLineup(self):
			## 清除阵容
			if not self.npcPosDict:
			return
			for curNPC in self.npcPosDict.values():
			if not curNPC:
			continue
			NPCCommon.SetDeadEx(curNPC)
			self.npcPosDict = {}
			self.npcObjIDDict = {}
			self.npcAttrDict = {}
			batObjMgr = BattleObj.GetBatObjMgr()
			for objID in self.posObjIDDict.values():
			batObjMgr.delBatObj(objID)
			for objID in self.lingshouObjIDDict.values():
			batObjMgr.delBatObj(objID)
			for objID in self.beautyObjIDDict.values():
			batObjMgr.delBatObj(objID)
			self.posObjIDDict = {}
			self.lingshouObjIDDict = {}
			self.beautyObjIDDict = {}
			self.fightPower = 0
			self.__resetStat()
			return

			def statHurtValue(self, objID, hurtValue):
			## 统计输出
			if objID not in self.npcObjIDDict:
			return
			updValue = self.hurtStatDict.get(objID, 0) + hurtValue
			self.hurtStatDict[objID] = updValue
			return updValue

			def statDefValue(self, objID, lostHP):
			## 统计承伤
			if objID not in self.npcObjIDDict:
			return
			updValue = self.defStatDict.get(objID, 0) + lostHP
			self.defStatDict[objID] = updValue
			return updValue

			def statCureValue(self, objID, cureValue):
			## 统计治疗
			if objID not in self.npcObjIDDict:
			return
			updValue = self.cureStatDict.get(objID, 0) + cureValue
			self.cureStatDict[objID] = updValue
			return updValue

			class BatFaction():
			## 战斗阵营

			def __init__(self, faction, fightMgr):
			self.fightMgr = fightMgr
			def __init__(self, faction, turnFight):
			self.turnFight = turnFight # TurnFight
			self.faction = faction
			self.lineupDict = {} # 该阵营所有阵容信息 {编号:BatLineup, ...}
			return
			@@ -188,15 +119,9 @@
			if num in self.lineupDict:
			lineup = self.lineupDict[num]
			else:
			lineup = BatLineup(self.faction, num, self.fightMgr)
			lineup = BatLineup(self.faction, num, self.turnFight)
			self.lineupDict[num] = lineup
			return lineup

			def resetLineups(self):
			## 重置所有战斗阵容
			for lineup in self.lineupDict.values():
			lineup.resetLineup()
			return

			def clearLineups(self):
			## 清除所有战斗阵容
			@@ -221,67 +146,95 @@
			self.curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID) if playerID else None
			self.mapID = mapID
			self.funcLineID = funcLineID
			self.state = -1 # -1 代表未战斗
			self.turnNum = 1 # 当前第x回合，默认第1回合开始
			self.turnMax = 15 # 最大回合数
			self.enterLogic = False # 是否已执行进场逻辑
			self.turnStart = 0 # 已执行回合开始值，如第1回合开始已执行则为1，第2回合为2
			self.turnEnd = 0 # 已执行回合结束值，如第1回合结束已执行则为1，第2回合为2
			self.winFaction = 0 # 本场战斗结束标记，获胜阵营，为0时代表未结束，所有小队打完或失败才有结果，0-未结束，>0-获胜的阵营
			self.isWin = False
			self.batBuffer = "" # 战报buffer，战报暂时只保留最后一个小队的
			self.isNeedReport = isNeedReport # 是否需要战报
			self.msgDict = {} # 扩展信息字典，一般由MapID绑定的功能决定信息内容 {k:v, ...}

			self.factionDict = {} # 战斗阵营 {faction:BatFaction, ...}，一般是只有两个阵营，faction为1或2，每个阵营支持多个阵容
			self.actionSortList = [] # 阵容行动顺序 [[faction, num], ...]
			self.actionIndex = 0 # 行动顺序索引

			self.actionIndex = 0 # 行动顺序索引
			self.timeline = 0 # 时间轴节点 turnNum1000+actionIndex100++actionNum
			self.startTime = 0 # 开始时间戳，支持毫秒小数
			self.costTime = 0 # 单场战斗总耗时，支持毫秒小数

			#玩家武将行动后击杀目标
			self.playerKillObjIDList = [] # [objID, ...]
			# pve 多小队 - 一般只有PVE用到
			self.lineupIndex = 0 # 当前小队索引
			self.lineupIDList = [] # npc小队列表
			self.strongerLV = 0 # npc成长等级
			self.difficulty = 0 # npc难度

			# pvp 目标
			self.tagPlayerID = 0
			self.tagViewCache = None
			return

			def setTurn(self, mapID, funcLineID, turnMax, isNeedReport=False, msgDict={}):
			def setTurnFight(self, mapID, funcLineID, turnMax, isNeedReport=False, msgDict={}):
			## 设置本场回合战斗设定
			self.mapID = mapID
			self.funcLineID = funcLineID
			self.turnMax = turnMax # 最大回合数
			self.isNeedReport = isNeedReport
			self.setPVE()
			self.setPVP()
			self.msgDict = {}
			self.resetTurn(msgDict)
			self.nextTurnFight(msgDict)
			return

			def resetTurn(self, msgDict):
			def setPVE(self, lineupIDList=[], strongerLV=0, difficulty=0):
			self.lineupIndex = 0
			self.lineupIDList = lineupIDList
			self.strongerLV = strongerLV
			self.difficulty = difficulty
			return

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

			#def setPVPTeam(self):
			# return

			def nextTurnFight(self, msgDict={}, resetByNextTeam=False):
			## 一般用于玩家发起的战斗，在需要保留玩家阵容属性及状态的情况下，重置回合进入下一场战斗
			self.turnNum = 1
			self.enterLogic = False
			self.turnStart = 0
			self.turnEnd = 0
			self.winFaction = 0
			self.batBuffer = "" # 战报buffer
			self.isWin = False
			self.msgDict.update(msgDict)
			self.timeline = 0
			self.startTime = time.time()
			self.costTime = 0
			if resetByNextTeam:
			ResetByNextTeam(self)
			return

			def setFactionLineup(self, faction, lineupDict, onlyReset=False):
			def haveNextLineup(self):
			## 是否可以打下一小队，获胜且还有下一小队时可打
			return (self.winFaction == ChConfig.Def_FactionA and self.lineupIndex < len(self.lineupIDList) - 1)
			def nextLineupID(self):
			## 下一小队ID
			if not self.haveNextLineup():
			return 0
			self.lineupIndex += 1
			return self.lineupIDList[self.lineupIndex]

			def setFactionLineup(self, faction, lineupDict):
			## 设置阵营阵容
			# @param lineupDict: {阵容编号:阵容信息, ...} 每个阵营支持多个阵容，即支持多V多
			# @param onlyReset: 是否仅重置，一般用于玩家的阵容，重复利用阵容实例，
			batFaction = self.getBatFaction(faction)
			if onlyReset:
			batFaction.resetLineups()
			else:
			batFaction.clearLineups()
			batFaction.clearLineups()
			for num, lineupInfo in lineupDict.items():
			batLineup = batFaction.getBatlineup(num)
			if onlyReset and not batLineup.isEmpty():
			continue
			if not lineupInfo:
			continue
			batLineup = batFaction.getBatlineup(num)
			batLineup.setLineup(lineupInfo)
			batLineup.refreshFightPower()
			return

			def sortActionQueue(self):
			@@ -290,21 +243,37 @@
			for batFaction in self.factionDict.values():
			faction = batFaction.faction
			for num, batLineup in batFaction.lineupDict.items():
			fightPower = batLineup.refreshFightPower()
			isPlayer = 1 if batLineup.ownerID else 0 # 玩家阵容优先攻击
			fightPower = batLineup.fightPower
			sortValue = -(faction * 10 + num)
			sortList.append([fightPower, sortValue, faction, num])
			sortList.append([isPlayer, fightPower, sortValue, faction, num])
			sortList.sort(reverse=True) # 战力高的先手

			self.actionIndex = 0
			self.actionSortList = []
			for _, _, faction, num in sortList:
			for _, _, _, faction, num in sortList:
			self.actionSortList.append([faction, num])

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

			def getBatFaction(self, faction=Def_FactionA):
			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
			batFaction = None
			if faction in self.factionDict:
			@@ -321,36 +290,47 @@
			if self.winFaction:
			return self.winFaction

			batObjMgr = BattleObj.GetBatObjMgr()
			for faction, batFaction in self.factionDict.items():
			allKilled = True
			for batLineup in batFaction.lineupDict.values():
			if not allKilled:
			break
			for posNum, curNPC in batLineup.npcPosDict.items():
			for posNum, objID in batLineup.posObjIDDict.items():
			if posNum <= 0:
			# 非主战位置不判断
			continue
			if GameObj.GetHP(curNPC) > 0:
			batObj = batObjMgr.getBatObj(objID)
			if not batObj:
			continue
			if batObj.IsAlive():
			allKilled = False
			break

			if allKilled:
			self.winFaction = Def_FactionA if faction == Def_FactionB else Def_FactionA
			self.winFaction = ChConfig.Def_FactionA if faction == ChConfig.Def_FactionB else ChConfig.Def_FactionB
			DoTurnFightOver(self.guid)
			return self.winFaction

			return 0

			def clearBatFaction(self, faction):
			batFaction = self.getBatFaction(faction)
			batFaction.clearLineups()
			return

			def clearFight(self):
			self.syncState(FightState_Over)
			def exitFight(self, rest=False):
			## 退出战斗
			self.syncState(FightState_Over if not rest else FightState_Rest)
			for batFaction in self.factionDict.values():
			batFaction.clearLineups()
			self.state = -1
			return

			def startFight(self):
			## 准备就绪，开始战斗
			self.state = FightState_Start
			self.turnNum = 1
			self.timeline = self.getTurnNumStartTimelin(self.turnNum)
			self.syncInit()
			return

			def isInFight(self): return self.state != -1

			def syncInit(self):
			## 初始化通知
			@@ -363,6 +343,8 @@
			clientPack.Msg = msg
			clientPack.Len = len(clientPack.Msg)
			clientPack.FactionList = []

			batObjMgr = BattleObj.GetBatObjMgr()
			for faction in self.factionDict.keys():
			batFaction = self.getBatFaction(faction)
			tfFaction = ChPyNetSendPack.tagSCTurnFightFaction()
			@@ -375,19 +357,22 @@
			tfLineup.OwnerID = batLineup.ownerID
			tfLineup.ShapeType = batLineup.shapeType
			tfLineup.ObjList = []
			for posNum, curNPC in batLineup.npcPosDict.items():
			for posNum, objID in batLineup.posObjIDDict.items():
			batObj = batObjMgr.getBatObj(objID)
			if not batObj:
			continue
			tfObj = ChPyNetSendPack.tagSCTurnFightObj()
			tfObj.ObjID = curNPC.GetID()
			tfObj.NPCID = curNPC.GetNPCID()
			tfObj.HeroID = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_HeroID)
			tfObj.SkinID = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_SkinID)
			tfObj.HP = curNPC.GetHP()
			tfObj.HPEx = curNPC.GetHPEx()
			tfObj.MaxHP = curNPC.GetMaxHP()
			tfObj.MaxHPEx = curNPC.GetMaxHPEx()
			tfObj.LV = NPCCommon.GetNPCLV(curNPC)
			tfObj.ObjID = batObj.GetID()
			tfObj.NPCID = batObj.GetNPCID()
			tfObj.HeroID = batObj.GetHeroID()
			tfObj.SkinID = batObj.GetSkinID()
			tfObj.HP = batObj.GetHP() % ChConfig.Def_PerPointValue
			tfObj.HPEx = batObj.GetHP() / ChConfig.Def_PerPointValue
			tfObj.MaxHP = batObj.GetMaxHP() % ChConfig.Def_PerPointValue
			tfObj.MaxHPEx = batObj.GetMaxHP() / ChConfig.Def_PerPointValue
			tfObj.LV = batObj.GetLV()
			tfObj.PosNum = posNum
			tfObj.AngreXP = GameObj.GetXP(curNPC)
			tfObj.AngreXP = batObj.GetXP()
			tfLineup.ObjList.append(tfObj)
			tfLineup.ObjCnt = len(tfLineup.ObjList)
			tfFaction.LineupList.append(tfLineup)
			@@ -398,6 +383,7 @@
			return

			def syncState(self, state, msgDict={}):
			self.state = state
			msg = json.dumps(msgDict, ensure_ascii=False)
			msg = msg.replace(" ", "")
			clientPack = ChPyNetSendPack.tagMCTurnFightState()
			@@ -411,7 +397,7 @@
			self.addBatPack(clientPack)
			return

			def syncObjAction(self, turnNum, objType, objID):
			def syncObjAction(self, turnNum, objID):
			clientPack = ChPyNetSendPack.tagMCTurnFightObjAction()
			clientPack.Clear()
			clientPack.TurnNum = turnNum
			@@ -426,12 +412,20 @@
			headStr = "%02x%02x" % (clientPack.Head.Cmd, clientPack.Head.SubCmd)
			else:
			headStr = "%02x%02x" % (clientPack.Cmd, clientPack.SubCmd)
			GameWorld.DebugLog("回合战斗过程封包: %s, isNeedReport=%s,%s" % (headStr, self.isNeedReport, self.guid))
			if self.isNeedReport:
			self.batBuffer += clientPack.GetBuffer()
			# 有玩家的统一每个包单独发送，同样也支持战报统计
			if self.curPlayer:
			NetPackCommon.SendFakePack(self.curPlayer, clientPack)
			packBuff = clientPack.GetBuffer()
			buffLen = len(packBuff)
			GameWorld.DebugLog("回合战斗过程封包: %s, len:%s" % (headStr, buffLen))
			self.batBuffer += CommFunc.WriteWORD("", buffLen)
			self.batBuffer += packBuff
			ObjPool.GetPoolMgr().release(clientPack)
			else:
			GameWorld.DebugLog("回合战斗过程封包: %s" % (headStr))
			# 有玩家的统一每个包单独发送，同样也支持战报统计
			if self.curPlayer:
			NetPackCommon.SendFakePack(self.curPlayer, clientPack)
			else:
			ObjPool.GetPoolMgr().release(clientPack)
			return

			class TurnFightMgr():
			@@ -439,11 +433,12 @@

			def __init__(self):
			self.turnFightDict = {} # {guid:TurnFight, ...}
			self.npcGUIDDict = {} # npc所属的某场战斗guid {objID:guid, ...}
			return

			def addTurnFight(self, mapID, funcLineID=0, playerID=0):
			tf = TurnFight(mapID, funcLineID, playerID, False)
			def addTurnFight(self, mapID, funcLineID=0, playerID=0, isNeedReport=False):
			tf = ObjPool.GetPoolMgr().acquire(TurnFight, mapID, funcLineID, playerID, isNeedReport)
			if not tf:
			tf = TurnFight(mapID, funcLineID, playerID, isNeedReport) # 一般是不可能，为了点出代码
			self.turnFightDict[tf.guid] = tf
			return tf

			@@ -451,8 +446,9 @@
			turnFight = self.getTurnFight(guid)
			if not turnFight:
			return
			turnFight.clearFight()
			turnFight.exitFight()
			self.turnFightDict.pop(guid, None)
			ObjPool.GetPoolMgr().release(turnFight)
			return

			def getTurnFight(self, guid):
			@@ -462,27 +458,6 @@
			elif False:
			tf = TurnFight()
			return tf

			def getNPCTurnFight(self, objID):
			## 获取NPC所在的回合战斗，如果该npc不属于某场回合战斗则返回None
			tf = None
			if objID in self.npcGUIDDict:
			guid = self.npcGUIDDict[objID]
			if guid in self.turnFightDict:
			tf = self.turnFightDict[guid]
			if not tf and False:
			tf = TurnFight()
			return tf

			def setNPCGUID(self, objID, guid):
			## 设置NPC所属回合战斗guid
			self.npcGUIDDict[objID] = guid
			GameWorld.DebugLog("设置NPC所属回合战斗guid: %s,%s" % (objID, guid))
			return
			def delNPCGUID(self, objID):
			guid = self.npcGUIDDict.pop(objID, None)
			GameWorld.DebugLog("删除NPC所属回合战斗guid: %s,%s" % (objID, guid))
			return

			def GetTurnFightMgr():
			tfMgr = None
			@@ -502,20 +477,12 @@
			self.levelNum = 0 # 关卡编号
			self.waveMax = 6 # 本关最大波数，每波有多个小队，每个小队即为一张战斗 TurnFight
			self.wave = 0 # 当前刷怪波，注意不是玩家当前进度波，比如被击杀会回退一波
			self.teamNum = 1 # 当前小队
			self.teamMax = 1 # 当前波最大小队，某场战斗可能包含多个小队，所有小队混流击杀完才算过了本波
			self.nextTeam = False # 下次前端请求战斗是否是下一小队，否则都是重新刷新当前进度怪
			self.waveLineupList = [] # 小队列表
			self.turnFight = GetTurnFightMgr().addTurnFight(ChConfig.Def_FBMapID_Main, 0, playerID)
			return

			def isLevelBoss(self):
			## 当前战斗是否关卡boss
			return self.turnFight.mapID == ChConfig.Def_FBMapID_MainBoss

			def clear(self):
			self.turnFight.clearFight()
			return

			def GetMainFightMgr(curPlayer):
			## 获取主线战斗管理
			@@ -532,73 +499,78 @@
			% (chapterID, levelNum, nowChapterID, fixNowValue), curPlayer.GetPlayerID())
			return

			def GetPlayerLineupByCache(playerID, lineupID):
			## 获取玩家阵容信息 - 根据玩家查看缓存
			return {}

			def GetCacheLineupFightPower(tagViewCache, lineupID):
			lineupInfo = GetCacheLineupInfo(tagViewCache, lineupID)
			return lineupInfo.get("FightPower", 0)
			def GetCacheLineupInfo(tagViewCache, lineupID):
			## 根据查看缓存获取阵容信息，一般是 GetPlayerLineupInfo 返回的结果
			plusDict = tagViewCache.GetPlusDict()
			lineupDict = plusDict.get("Lineup", {})
			lineupInfo = lineupDict.get("%s" % lineupID, {})
			if not lineupInfo:
			lineupInfo = lineupDict.get("%s" % ShareDefine.Lineup_Main, {})
			return lineupInfo

			def GetPlayerLineupFightPower(curPlayer, lineupID):
			## 获取玩家阵容战力，一般用于直接获取阵容战力记录用
			return GetPlayerLineup(curPlayer, lineupID).fightPower
			def GetPlayerLineup(curPlayer, lineupID):
			## 获取玩家阵容信息
			## 获取玩家阵容
			olPlayer = PlayerOnline.GetOnlinePlayer(curPlayer)
			lineup = olPlayer.GetLineup(lineupID)
			if not lineup.lineupHeroDict:
			# 为空时默认取主阵容
			lineup = olPlayer.GetLineup(ShareDefine.Lineup_Main)
			return lineup

			def GetPlayerLineupInfo(curPlayer, lineupID):
			## 获取玩家阵容信息，可用于战斗或查看缓存，因为可能取玩家的缓存进行对战，所以统一使用json格式，前端通用
			# @param lineupID: 阵容ID
			# @return: 阵容全部信息json字典，前端通用格式

			playerID = curPlayer.GetPlayerID()
			lineup = GetPlayerLineup(curPlayer, lineupID)
			if not lineup.lineupHeroDict:
			return {}

			# 武将
			heroDict = {}
			heroCount = 0
			curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
			for index in range(curPack.GetCount()):
			heroItem = curPack.GetAt(index)
			if not heroItem or heroItem.IsEmpty():
			continue
			lineupCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroLineup)
			if not lineupCount:
			continue
			posNum = 0 # վλ
			for lpIndex in range(lineupCount):
			lineupValue = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroLineup, lpIndex)
			#阵容类型10000+阵型类型100+位置编号
			if lineupValue / 10000 != lineupID:
			continue
			posNum = lineupValue % 100
			break

			if not posNum:
			continue

			heroID = heroItem.GetItemTypeID()
			heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
			if not heroIpyData:
			continue
			skinIDList = heroIpyData.GetSkinIDList()
			skinIndex = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroSkin)
			if skinIndex < 0 or skinIndex >= len(skinIDList):
			continue
			skinID = skinIDList[skinIndex]
			for posNum in lineup.lineupHeroDict.keys():
			hero = lineup.GetLineupHero(posNum)
			heroID = hero.heroID
			itemIndex = hero.itemIndex
			userData = ""
			heroLV = 1
			if itemIndex >= 0 and itemIndex < curPack.GetCount():
			heroItem = curPack.GetAt(itemIndex)
			if heroItem and not heroItem.IsEmpty():
			userData = heroItem.GetUserData()
			heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)

			skillIDlist = []
			skillIDlist += hero.heroSkillIDList
			heroDict[str(posNum)] = {
			"HeroID":heroID,
			"SkinID":skinID,
			"Data":heroItem.GetUserData(),
			"SkinID":hero.skinID,
			"LV":heroLV,
			"Data":userData,
			"FightPower":hero.fightPower,
			"AttrDict":{str(k):v for k, v in hero.heroBatAttrDict.items() if v > 0},
			"SkillIDList":skillIDlist,
			}

			heroCount += 1
			if heroCount >= ShareDefine.LineupObjMax:
			break

			if not heroDict:
			return {}

			# 主公属性
			lordAttrDict = PlayerControl.GetLordAttr(curPlayer)

			# 其他

			lineupInfo = {"PlayerID":playerID, "LordAttrDict":lordAttrDict, "Hero":heroDict}
			lineupInfo = {"PlayerID":playerID, "FightPower":lineup.fightPower, "ShapeType":lineup.shapeType, "Hero":heroDict}
			return lineupInfo

			def GetNPCLineup(lineupID):
			def GetNPCLineupInfo(lineupID, strongerLV=0, difficulty=0):
			## 获取NPC阵容信息
			# @param lineupID: 阵容ID
			# @param npcLV: 成长NPC等级
			# @param difficulty: 成长NPC难度系数
			# @return: 阵容全部信息json字典，前端通用格式
			ipyData = IpyGameDataPY.GetIpyGameData("NPCLineup", lineupID)
			if not ipyData:
			@@ -611,11 +583,131 @@
			npcID = getattr(ipyData, "GetPosNPCID%s" % posNum)()
			if not npcID:
			continue
			battleDict = GetNPCBattleDict(ipyData, npcID, strongerLV, difficulty)
			if not battleDict:
			continue
			heroDict[str(posNum)] = battleDict

			heroDict[str(posNum)] = {"NPCID":npcID}

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

			def GetNPCBattleDict(lineupIpyData, npcID, strongerLV=0, difficulty=0):
			## 获取NPC战斗相关字典，支持成长NPC
			# @param strongerLV: 成长等级
			# @param difficulty: 难度系数
			npcData = NPCCommon.GetNPCDataPy(npcID)
			if not npcData:
			return
			heroID = npcData.GetRelatedHeroID()
			npcLV = npcData.GetLV()

			lvIpyData = None
			heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID) if heroID else None
			npcStronger = IpyGameDataPY.GetIpyGameDataNotLog("NPCStronger", npcID)
			if npcStronger and strongerLV:
			lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", strongerLV)
			if lvIpyData:
			npcLV = strongerLV
			if not lvIpyData:
			lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", npcLV)

			if heroIpyData and lvIpyData:
			skinIDList = heroIpyData.GetSkinIDList()
			skinID = skinIDList[0] if skinIDList else 0
			skillIDList = GetNPCHeroSkillIDList(heroID, heroIpyData, lvIpyData.GetReHeroBreakLV(), lvIpyData.GetReHeroAwakeLV())
			else:
			heroID = 0
			skinID = 0
			skillIDList = [] + npcData.GetSkillIDList()

			# boss额外随机技能
			bossID = lineupIpyData.GetBossID()
			if npcID == bossID:
			skillIDExList = lineupIpyData.GetSkillIDExList()
			if skillIDExList:
			randSkillIDExList = [] + list(skillIDExList)
			skillExCnt = lineupIpyData.GetSkillExCnt()
			if skillExCnt > 0 and len(randSkillIDExList) > skillExCnt:
			random.shuffle(randSkillIDExList)
			randSkillIDExList = randSkillIDExList[:skillExCnt]
			skillIDList += randSkillIDExList
			GameWorld.DebugLog("阵容boss技能: %s, 随机附加技能: %s" % (skillIDList, randSkillIDExList))

			# 成长怪属性
			batAttrDict = GetNPCStrongerAttrDict(npcID, lvIpyData, npcStronger, difficulty)
			if not batAttrDict:
			batAttrDict = {ChConfig.AttrID_Atk:npcData.GetAtk(), ChConfig.AttrID_Def:npcData.GetDef(), ChConfig.AttrID_MaxHP:npcData.GetMaxHP(),
			ChConfig.AttrID_FinalDamPer:npcData.GetFinalDamPer(), ChConfig.AttrID_FinalDamPerDef:npcData.GetFinalDamPerDef(),
			ChConfig.AttrID_MissRate:npcData.GetMissRate(), ChConfig.AttrID_MissRateDef:npcData.GetMissRateDef(),
			ChConfig.AttrID_SuperHitRate:npcData.GetSuperHitRate(), ChConfig.AttrID_SuperHitRateDef:npcData.GetSuperHitRateDef(),
			ChConfig.AttrID_StunRate:npcData.GetStunRate(), ChConfig.AttrID_StunRateDef:npcData.GetStunRateDef(),
			ChConfig.AttrID_ComboRate:npcData.GetComboRate(), ChConfig.AttrID_ComboRateDef:npcData.GetComboRateDef(),
			ChConfig.AttrID_ParryRate:npcData.GetParryRate(), ChConfig.AttrID_ParryRateDef:npcData.GetParryRateDef(),
			ChConfig.AttrID_SuckHPPer:npcData.GetSuckHPPer(), ChConfig.AttrID_SuckHPPerDef:npcData.GetSuckHPPerDef(),
			}
			batAttrDict.update(npcData.GetSpecAttrInfo())

			battleDict = {"NPCID":npcID,
			"HeroID":heroID,
			"SkinID":skinID,
			"LV":npcLV,
			"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))
			return battleDict

			def GetNPCHeroSkillIDList(heroID, heroIpyData, breakLV, awakeLV):
			## 获取NPC对应武将的技能ID列表
			normalSkillID = heroIpyData.GetNormalSkillID()
			angerSkillID = heroIpyData.GetAngerSkillID()
			skillIDList = [normalSkillID, angerSkillID]

			breakIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroBreak", heroID)
			if breakIpyDataList:
			for breakIpyData in breakIpyDataList:
			if breakIpyData.GetBreakLV() > breakLV:
			break
			skillID = breakIpyData.GetSkillID()
			if skillID:
			skillIDList.append(skillID)

			awakeIpyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("HeroAwake", heroID)
			if awakeIpyDataList:
			for awakeIpyData in awakeIpyDataList:
			if awakeIpyData.GetAwakeLV() > awakeLV:
			break
			skillID = awakeIpyData.GetSkillID()
			if skillID:
			skillIDList.append(skillID)

			return skillIDList

			def GetNPCStrongerAttrDict(npcID, lvIpyData, npcStronger, difficulty):
			## 获取NPC成长属性
			# @param strongerLV: 成长等级
			# @param difficulty: 难度系数

			batAttrDict = {}
			if not lvIpyData or not npcStronger or not difficulty:
			return batAttrDict
			lv = lvIpyData.GetLV()
			for attrID in ChConfig.CalcBattleAttrIDList:
			attrIpyData = IpyGameDataPY.GetIpyGameData("PlayerAttr", attrID)
			if not attrIpyData:
			continue
			attrName = attrIpyData.GetParameter()
			if not hasattr(lvIpyData, "GetRe%s" % attrName):
			continue
			reValue = getattr(lvIpyData, "GetRe%s" % attrName)() # 基础参考值
			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.DebugLog("NPC成长属性: npcID=%s,lv=%s,difficulty=%s,%s" % (npcID, lv, difficulty, batAttrDict))
			return batAttrDict

			def SummonLineupObjs(batLineup, faction, num, lineupInfo, playerID=0):
			'''召唤阵容战斗实例
			@@ -624,124 +716,263 @@
			@param lineupInfo: 阵容信息
			@param playerID: 发起的玩家ID，系统场次为0
			'''

			'''关于视野层级说明 sightLevel
			玩家发起的战斗视野层级只能用玩家ID，才能达到只通知该玩家的效果
			但是由于同个玩家可能同时存在多场战斗，如主线战斗 + 其他战斗，所以视野层级只能用作仅通知该玩家的作用，
			不能用于处理NPC视野来遍历伤害对象等，因为不同战场的NPC视野层级可能相同，对于同场战斗NPC的遍历处理只能用 turnFight 管理遍历
			鉴于视野层级仅用于通知的作用，故系统场次理论上可以只用一个视野层级，但是为了减少不必要的问题，系统场次的视野层级还是尽量区分开来
			这里暂时用时间戳的后4位来做短时间内的理论上唯一视野层级
			'''
			GameWorld.DebugLog("SummonLineupObjs faction:%s,num:%s,lineupInfo=%s" % (faction, num, lineupInfo), playerID)
			if playerID:
			curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			if not curPlayer:
			return
			posX, posY = curPlayer.GetPosX(), curPlayer.GetPosY()
			sightLevel = playerID

			# 开发过程中可以先开启视野层级及视野，方便检查战斗相关是否有遗漏
			if curPlayer.GetSightLevel() != sightLevel:
			PlayerControl.SetPlayerSightLevel(curPlayer, sightLevel)
			sight = ChConfig.Def_PlayerSight_Default * 5
			if curPlayer.GetSight() != sight:
			PlayerControl.SetSight(curPlayer, sight)
			else:
			gameMap = GameWorld.GetMap()
			posX, posY = gameMap.GetRebornMapX(), gameMap.GetRebornMapY() # 系统战斗默认取当前地图的复活点，需要优化
			sightLevel = 2000000000 + int(time.time()) % 10000

			GameWorld.DebugLog("sightLevel=%s,pos=(%s,%s)" % (sightLevel, posX, posY), playerID)

			tfGUID = batLineup.turnFight.guid
			lineupPlayerID = lineupInfo.get("PlayerID", 0) # 阵容所属玩家ID
			heroDict = lineupInfo.get("Hero", {})
			tick = GameWorld.GetGameWorld().GetTick()

			batObjMgr = BattleObj.GetBatObjMgr()
			initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
			baseAtkSkillIDList = IpyGameDataPY.GetFuncEvalCfg("ParryCfg", 3)
			tfMgr = GetTurnFightMgr()
			space = 3
			for posNumKey, heroInfo in heroDict.items():
			posNum = int(posNumKey)

			heroID, skinID = 0, 0
			baseAtkSkillID = 0 # 基础普攻ID
			skillIDList = []
			fightPower = 0
			skillIDList = [] # 战斗对象可能改变属性或技能，重新创建，防止误修改来源值
			attrDict = {}
			skillIDList += heroInfo.get("SkillIDList", [])
			attrDict.update(heroInfo.get("AttrDict", {}))
			npcID = heroInfo.get("NPCID", 0)
			heroID = heroInfo.get("HeroID", 0)
			skinID = heroInfo.get("SkinID", 0)
			lv = heroInfo.get("LV", 1)
			heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID) if heroID else None
			if heroIpyData:
			specialty = heroIpyData.GetSpecialty()
			atkDistType = heroIpyData.GetAtkDistType()
			objName = heroIpyData.GetName()
			country = heroIpyData.GetCountry()
			sex = heroIpyData.GetSex()

			if lineupPlayerID:
			heroID = heroInfo.get("HeroID", 0)
			skinID = heroInfo.get("SkinID", 0)
			npcID = FighterNPCID
			heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
			fightPower = heroInfo.get("FightPower", 0)
			if not heroIpyData:
			continue
			normalSkillID = heroIpyData.GetNormalSkillID()
			angerSkillID = heroIpyData.GetAngerSkillID()
			skillIDList += [normalSkillID, angerSkillID]
			atkDistType = heroIpyData.GetAtkDistType()

			else:
			npcID = heroInfo.get("NPCID", 0)
			npcDataEx = NPCCommon.GetNPCDataEx(npcID)
			npcDataEx = NPCCommon.GetNPCDataPy(npcID)
			if not npcDataEx:
			continue
			skillIDList += npcDataEx.GetSkillIDList()
			atkDistType = npcDataEx.GetAtkDistType()

			if not npcID:
			continue
			if not heroIpyData:
			specialty = npcDataEx.GetSpecialty()
			atkDistType = npcDataEx.GetAtkDistType()
			objName = npcDataEx.GetNPCName()
			country = npcDataEx.GetCountry()
			sex = npcDataEx.GetSex()

			batObj = batObjMgr.addBatObj()
			if not batObj:
			break
			objID = batObj.GetID()
			if npcID:
			batObj.SetNPCID(npcID)
			elif lineupPlayerID:
			batObj.SetOwnerID(lineupPlayerID)
			batObj.SetTFGUID(tfGUID)
			batObj.SetName(objName)
			batObj.SetFaction(faction)
			batObj.SetLineupPos(posNum, num)
			batObj.SetFightPower(fightPower)
			batObj.SetLV(lv)
			batObj.SetAtkDistType(atkDistType)
			batObj.SetSpecialty(specialty)
			batObj.SetCountry(country)
			batObj.SetSex(sex)
			batObj.SetHero(heroID, skinID)

			npcData = GameWorld.GetGameData().FindNPCDataByID(npcID)
			if not npcData:
			continue
			curSummon = GameWorld.GetNPCManager().AddPlayerSummonNPC()
			if not curSummon:
			continue
			objID = curSummon.GetID()
			batLineup.npcPosDict[posNum] = curSummon
			batLineup.npcObjIDDict[objID] = curSummon
			tfMgr.setNPCGUID(objID, batLineup.getGUID())

			curSummon.SetNPCTypeID(npcID)
			curSummon.SetBornTime(tick)
			curSummon.SetAIType(0)
			curSummon.SetSightLevel(sightLevel)
			curSummon.SetIsNeedProcess(False)
			curSummon.SetCanAttack(True)
			curSummon.SetVisible(True)
			curSummon.SetDict(ChConfig.Def_Obj_Dict_TurnFightPosInfo, num * 100 + posNum)
			curSummon.SetDict(ChConfig.Def_Obj_Dict_LineupPlayerID, lineupPlayerID)
			curSummon.SetDict(ChConfig.Def_Obj_Dict_HeroID, heroID)
			curSummon.SetDict(ChConfig.Def_Obj_Dict_SkinID, skinID)
			GameObj.SetFaction(curSummon, faction)
			GameObj.SetXP(curSummon, initXP, False)

			if atkDistType == ChConfig.AtkDistType_Short:
			baseAtkSkillID = baseAtkSkillIDList[0] if len(baseAtkSkillIDList) > 0 else 0
			elif atkDistType == ChConfig.AtkDistType_Long:
			baseAtkSkillID = baseAtkSkillIDList[1] if len(baseAtkSkillIDList) > 1 else 0
			skillManager = batObj.GetSkillManager()
			skillManager.SkillReset()
			for skillID in skillIDList:
			skillManager.LearnSkillByID(skillID)

			skillManager = curSummon.GetSkillManager()
			#有指定的技能，重新学习
			if skillIDList:
			skillManager.ResetSkill()
			for skillID in skillIDList:
			skillManager.LVUPSkillByID(skillID)
			if baseAtkSkillID:
			skillManager.LVUPSkillByID(baseAtkSkillID)

			rebornX = posX - space + (faction - 1) * space * 3 + ((posNum - 1) / 3 * space * 2 * (-1 if faction == 1 else 1))
			rebornY = posY + (posNum - 1) % 3 * space
			GameWorld.DebugLog("SummonNPC ID:%s,faction:%s,num=%s,posNum=%s,baseAtkSkillID=%s,%s" % (curSummon.GetID(), faction, num, posNum, baseAtkSkillID, skillIDList))
			curSummon.Reborn(rebornX, rebornY, False)
			NPCCommon.NPCControl(curSummon).DoNPCRebornCommLogic(tick)
			batLineup.posObjIDDict[posNum] = objID
			GameWorld.DebugLog("AddBatObj %s,skill=%s" % (GetObjName(batObj), skillManager.GetSkillIDList()))
			batObj.InitBatAttr({int(k):v for k, v in attrDict.items()}, initXP)

			return

			def ResetByNextTeam(turnFight):
			## 切换下一小队时重置相关，目前设置仅保留血量、怒气、已被击杀的不复活，其他重置

			batFaction = turnFight.getBatFaction(ChConfig.Def_FactionA)
			if not batFaction:
			return
			GameWorld.DebugLog("切换小队重置玩家阵容武将...")
			batLineup = batFaction.getBatlineup(1) # 只处理玩家阵容
			batObjMgr = BattleObj.GetBatObjMgr()
			for objID in batLineup.posObjIDDict.values():
			batObj = batObjMgr.getBatObj(objID)
			if not batObj:
			continue
			objName = GetObjName(batObj)
			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()

			# 清除buff
			buffMgr = batObj.GetBuffManager()
			buffMgr.ClearBuff()

			# 重置CD

			# 重刷属性、被动
			TurnBuff.RefreshBuffAttr(batObj)
			TurnPassive.RefreshPassive(batObj)

			return

			#// B4 10 回合制战斗 #tagCMTurnFight
			#
			#struct tagCMTurnFight
			#{
			# tagHead Head;
			# DWORD MapID; // 自定义地图ID，可用于绑定战斗地图场景功能（如主线boss、爬塔、竞技场等）
			# DWORD FuncLineID; // MapID对应的扩展值，如具体某个关卡等
			# BYTE TagType; // 目标类型，0-NPC阵容，1-玩家
			# DWORD TagID; // 目标类型对应的ID，如玩家ID
			# BYTE ValueCount;
			# DWORD ValueList[ValueCount]; // 附加值列表，可选，具体含义由MapID决定
			#};
			def OnTurnFight(index, clientData, tick):
			''' 本战斗会一次性处理完所有小队战斗，以战报的形式下发，目前除了主线小怪分段战斗外，均使用该战斗
			'''
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			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())

			reqRet = FBLogic.OnTurnFightRequest(curPlayer, mapID, funcLineID, tagType, tagID, valueList)
			if not reqRet:
			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:
			return

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

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

			turnMax = GetTurnMax(mapID)

			tfMgr = GetTurnFightMgr()
			turnFight = tfMgr.addTurnFight(mapID, funcLineID, playerID)
			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.sortActionQueue()
			turnFight.startFight()

			__processTurnFight(turnFight.guid)

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

			def GetTurnMax(mapID):
			if mapID == ChConfig.Def_FBMapID_Main:
			return IpyGameDataPY.GetFuncCfg("TurnMax", 1)
			mapTurnMaxDict= IpyGameDataPY.GetFuncEvalCfg("TurnMax", 3, {})
			return mapTurnMaxDict.get(mapID, IpyGameDataPY.GetFuncCfg("TurnMax", 2))

			#// B4 13 主线战斗请求 #tagCSMainFightReq
			#
			#struct tagCSMainFightReq
			#{
			# tagHead Head;
			# BYTE ReqType; // 0-停止战斗回城；1-设置消耗倍值；2-挑战关卡小怪；3-挑战关卡boss；4-继续战斗；
			# BYTE ReqType; // 0-停止战斗回城；1-设置消耗倍值；2-挑战关卡小怪；4-继续战斗；
			# DWORD ReqValue; // 请求值，ReqType为1时发送消耗倍值
			#};
			def OnMainFightReq(index, clientData, tick):
			@@ -756,14 +987,13 @@
			__doSetFightPoint(curPlayer, reqValue)
			return

			GameWorld.DebugLog("主线战斗请求: reqType=%s" % reqType, curPlayer.GetPlayerID())
			clientPack = ChPyNetSendPack.tagSCTurnFightReportSign()
			clientPack.Sign = 0
			NetPackCommon.SendFakePack(curPlayer, clientPack) # 标记开始

			if reqType == 2: # 前端主动请求开始关卡小怪的视为从休息中开始
			__doMainLevelWave(curPlayer, True)
			elif reqType == 3:
			__doMainBossStart(curPlayer, tick)
			elif reqType == 4:
			__doMainFight(curPlayer, tick)
			else:
			@@ -779,7 +1009,7 @@
			mainFightMgr = GetMainFightMgr(curPlayer)
			turnFight = mainFightMgr.turnFight
			if turnFight:
			turnFight.clearFight()
			turnFight.exitFight(True)
			return

			def __doSetFightPoint(curPlayer, fightPoint):
			@@ -803,9 +1033,6 @@
			# @param isRestStart: 是否从休息状态重新开始的
			playerID = curPlayer.GetPlayerID()
			chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)
			if not chapterID and not levelNum:
			PlayerControl.SetMainLevelNowInfo(curPlayer, 1, 1, 1)
			chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)
			GameWorld.DebugLog("请求关卡波战斗: chapterID=%s,levelNum=%s,wave=%s,isRestStart=%s" % (chapterID, levelNum, wave, isRestStart), playerID)
			fightPoint = max(curPlayer.GetFightPoint(), 1)
			if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
			@@ -834,291 +1061,198 @@
			if wave > waveMax:
			wave = waveMax

			waveLineupList = getattr(levelIpyData, "GetWaveLineupIDList%s" % wave)() # 小队1阵容ID\|小队2阵容ID\|...
			if not waveLineupList:
			lineupIDList = getattr(levelIpyData, "GetWaveLineupIDList%s" % wave)() # 小队1阵容ID\|小队2阵容ID\|...
			if not lineupIDList:
			return
			teamMax = len(waveLineupList)
			teamNum = 1
			lineupID = waveLineupList[teamNum - 1] # NPC阵容ID
			lineupID = lineupIDList[0] # NPC阵容ID

			lineupMainInfo = GetPlayerLineup(curPlayer, ShareDefine.Lineup_Main)
			lineupMainInfo = GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)
			if not lineupMainInfo:
			GameWorld.DebugLog("没有设置主阵容!", playerID)
			return

			strongerLV = levelIpyData.GetNPCLV()
			difficulty = levelIpyData.GetDifficulty()
			mainFightMgr = GetMainFightMgr(curPlayer)
			mainFightMgr.nextTeam = False
			mainFightMgr.chapterID = chapterID
			mainFightMgr.levelNum = levelNum
			mainFightMgr.waveMax = waveMax
			mainFightMgr.wave = wave
			mainFightMgr.waveLineupList = waveLineupList
			mainFightMgr.teamNum = teamNum
			mainFightMgr.teamMax = teamMax
			turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 2)
			mapID, funcLineID = ChConfig.Def_FBMapID_Main, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
			GameWorld.DebugLog("设置起始关卡波: 关卡%s-%s,波=%s/%s,teamMax=%s,mapID=%s,funcLineID=%s,lineupID=%s"
			% (chapterID, levelNum, wave, waveMax, teamMax, mapID, funcLineID, lineupID), playerID)
			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)

			turnFight = mainFightMgr.turnFight
			turnFight.setTurn(mapID, funcLineID, turnMax, False, {"teamNum":teamNum, "teamMax":teamMax})
			turnFight.setFactionLineup(Def_FactionA, {1:lineupMainInfo}, True)
			turnFight.setFactionLineup(Def_FactionB, {1:GetNPCLineup(lineupID)})
			turnFight.setTurnFight(mapID, funcLineID, turnMax, False)
			turnFight.setPVE(lineupIDList, strongerLV, difficulty)
			turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo})
			turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID, strongerLV, difficulty)})
			turnFight.sortActionQueue()
			turnFight.syncInit()
			turnFight.startFight()

			__doMainFight(curPlayer)
			return

			def __doMainBossStart(curPlayer, tick):
			## 开始挑战关卡boss
			playerID = curPlayer.GetPlayerID()
			chapterID, levelNum, wave = PlayerControl.GetMainLevelPassInfo(curPlayer)
			if not chapterID:
			chapterID = 1
			if not levelNum:
			levelNum = 1
			GameWorld.DebugLog("请求挑战关卡Boss! passInfo: chapterID=%s,levelNum=%s,wave=%s" % (chapterID, levelNum, wave), playerID)
			chapterIpyData = IpyGameDataPY.GetIpyGameData("MainChapter", chapterID)
			if not chapterIpyData:
			return
			levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
			if not levelIpyData:
			return
			def __doMainFight(curPlayer, tick=0):
			'''执行主线战斗，单场战斗断电式战斗，以前端玩家手动点击节点做为断点处
			每场战斗的初始化、结束默认断点，由前端决定自动继续或者点击继续
			'''

			nowChapterID, nowLevelNum, _ = PlayerControl.GetMainLevelNowInfo(curPlayer)
			if chapterID != nowChapterID or levelNum != nowLevelNum:
			'''一般有两种情况会导致
			1. 理论上玩家当前刷怪的章节关卡一定是与过关的章节关卡是一致的，除了全部章节已通关
			当通关时，已过关的记录会被设置为下一章节第1关（版本关卡表实际不存在该关卡）
			但是当前刷怪的还是版本的最后一关，固会出现不一致的情况
			在增加章节关卡新版本更新后玩家重登会自动进行修复当前刷怪进度为最新章节第1关
			2. 真的出现问题了，可能是bug引起，这种情况只能进行bug修复及针对异常账号特殊处理，或者重登后也会自动进行修正
			'''
			GameWorld.ErrLog("当前刷怪章节关卡与挑战的boss章节关卡不一致，无法挑战! chapterID=%s,levelNum=%s,nowChapterID=%s,nowLevelNum=%s"
			% (chapterID, levelNum, nowChapterID, nowLevelNum), playerID)
			return

			# 本关卡最大波数
			waveMax = 6
			while waveMax >= 1 and (not hasattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax) or not getattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax)()):
			waveMax -= 1
			# 限制请求CD
			if tick:
			key = "MainFightReqTick"
			lastTick = curPlayer.GetDictByKey(key)
			if lastTick and tick - lastTick <= 1000:
			GameWorld.DebugLog("主线战斗请求CD中")
			return
			curPlayer.SetDict(key, tick)

			if wave < waveMax:
			GameWorld.DebugLog("最后一波未通过，无法挑战本关boss! passWave=%s < %s" % (wave, waveMax))
			return

			waveLineupList = levelIpyData.GetBossLineupIDList() # Boss波阵容ID列表，小队1阵容ID\|小队2阵容ID\|...
			if not waveLineupList:
			return
			teamMax = len(waveLineupList)
			teamNum = 1
			lineupID = waveLineupList[teamNum - 1] # NPC阵容ID

			wave = waveMax = 1 # 关卡boss固定只有一波

			lineupMainInfo = GetPlayerLineup(curPlayer, ShareDefine.Lineup_Main)
			if not lineupMainInfo:
			GameWorld.DebugLog("没有设置主阵容!", playerID)
			return

			mainFightMgr = GetMainFightMgr(curPlayer)
			mainFightMgr.nextTeam = False
			mainFightMgr.chapterID = chapterID
			mainFightMgr.levelNum = levelNum
			mainFightMgr.waveMax = waveMax
			mainFightMgr.wave = wave
			mainFightMgr.waveLineupList = waveLineupList
			mainFightMgr.teamNum = teamNum
			mainFightMgr.teamMax = teamMax
			turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 3)
			mapID, funcLineID = ChConfig.Def_FBMapID_MainBoss, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
			GameWorld.DebugLog("设置关卡boss: 关卡%s-%s,波=%s/%s,teamMax=%s,mapID=%s,funcLineID=%s,lineupID=%s"
			% (chapterID, levelNum, wave, waveMax, teamMax, mapID, funcLineID, lineupID), playerID)

			turnFight = mainFightMgr.turnFight
			turnFight.setTurn(mapID, funcLineID, turnMax, False, {"teamNum":teamNum, "teamMax":teamMax})
			turnFight.setFactionLineup(Def_FactionA, {1:lineupMainInfo}, True)
			turnFight.setFactionLineup(Def_FactionB, {1:GetNPCLineup(lineupID)})
			turnFight.sortActionQueue()
			turnFight.syncInit()

			# 挑战boss无中间过程，每次执行直接挑战一队结果
			__processTurnFight(turnFight.guid, tick)
			return

			def __doMainFight(curPlayer, tick):
			## 主线执行战斗
			mainFightMgr = GetMainFightMgr(curPlayer)
			turnFight = mainFightMgr.turnFight

			isLevelBoss = mainFightMgr.isLevelBoss()
			winFaction = turnFight.winFaction
			if winFaction:
			if mainFightMgr.nextTeam:
			# 自动开始下一小队
			teamNum = mainFightMgr.teamNum = mainFightMgr.teamNum + 1
			GameWorld.DebugLog("开始进入下一小队: teamNum=%s" % teamNum)
			if teamNum < 1 or teamNum > len(mainFightMgr.waveLineupList):
			return
			lineupID = mainFightMgr.waveLineupList[teamNum - 1] # NPC阵容ID
			GameWorld.DebugLog("teamNum=%s,lineupID=%s" % (teamNum, lineupID))

			mainFightMgr.nextTeam = False
			turnFight.resetTurn({"teamNum":teamNum})
			# 切换小队时，玩家阵容不需要处理，保留状态
			turnFight.setFactionLineup(Def_FactionB, {1:GetNPCLineup(lineupID)})
			turnFight.sortActionQueue()
			turnFight.syncInit()

			if mainFightMgr.isLevelBoss():
			# 每次处理一小队的完整战斗，相当于一次完整战报
			__processTurnFight(turnFight.guid, tick)
			return
			else:
			__doMainLevelWave(curPlayer, False)
			return

			if isLevelBoss:
			## 关卡boss是一次性处理完的，一般不可能走到这里，这边做下防范
			return

			# 以下均是处理关卡小怪分段实时战斗
			if not turnFight.isInFight():
			__doMainLevelWave(curPlayer, True)
			return

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

			turnFight.nextTurnFight(resetByNextTeam=True)
			# 切换小队时，玩家阵容不需要处理，保留状态
			turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(nextLineupID, turnFight.strongerLV, turnFight.difficulty)})
			turnFight.sortActionQueue()
			turnFight.startFight()

			__doMainFight(curPlayer)
			else:
			__doMainLevelWave(curPlayer, False)
			return

			# 小怪战斗，每次消耗1个战锤
			fightPoint = max(curPlayer.GetFightPoint(), 1) # 主线战斗消耗倍值，默认1
			if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
			GameWorld.DebugLog("回合开始时战锤不足!")
			return

			# 按阵营阵容执行顺序，逐个遍历
			doCnt = 0
			doMax = (PosNumMax + 2) * len(turnFight.actionSortList) # 防止死循环，做最大循环次数限制 = (最大位置数 + 主公、红颜位置)*行动阵容数
			overLineupList = [] # 本回合已经结束行动的阵容列表 [(faction, num), ...]，所有阵容全部结束代表本回合结束
			# 以下均是处理关卡小怪分段实时战斗
			isEntry = EntryLogic(turnFight)

			# 是否开始检查断点，预判可断的点，方便前端点击体验，点下去就是玩家放的某个行动
			# 初始开始进场后，默认开始断点
			checkBreakpoint = True if isEntry else False

			batObjMgr = BattleObj.GetBatObjMgr()
			turnNum = turnFight.turnNum
			GameWorld.DebugLog("turnNum=%s,doMax=%s,actionIndex=%s,%s" % (turnNum, doMax, turnFight.actionIndex, turnFight.actionSortList))
			while doCnt < doMax and len(overLineupList) < len(turnFight.actionSortList):
			doCnt += 1
			turnNum = turnFight.turnNum
			# 执行回合开始逻辑
			if turnFight.turnStart < turnNum:
			GameWorld.DebugLog("执行行动: turnNum=%s, 回合开始" % (turnFight.turnNum))
			turnFight.syncState(FightState_Fighting)
			if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
			GameWorld.DebugLog("回合开始时战锤不足!")
			return
			turnFight.turnStart = turnNum
			turnFight.actionIndex = 0
			turnMax = turnFight.turnMax
			for turnNum in range(turnNum, turnMax + 1):
			turnTimeline = turnFight.getTurnNumStartTimelin(turnNum) # 本回合起始时间节点
			curTimeline = turnFight.getTimeline()

			# 回合开始
			turnTimeline += 1 # 每回合开始算一个时间节点
			if curTimeline < turnTimeline:
			curTimeline = turnFight.setTimeline(turnTimeline)
			GameWorld.DebugLog("【----- 回合制战斗轮次: %s -----】 curTimeline=%s" % (turnNum, curTimeline))
			turnFight.turnNum = 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 = ActionNumStart
			for curNPC in batLineup.npcPosDict.values():
			TurnFightObjPerTurnStart(curNPC, None, turnNum, tick)
			batLineup.actionNum = 1
			for objID in batLineup.posObjIDDict.values():
			batObj = batObjMgr.getBatObj(objID)
			TurnFightPerTurnBigStart(turnFight, batObj, turnNum)

			if turnFight.actionIndex >= len(turnFight.actionSortList):
			turnFight.actionIndex = 0

			playerHeroAtk = False # 玩家阵容行动标记
			faction, num = turnFight.actionSortList[turnFight.actionIndex]
			batFaction = turnFight.getBatFaction(faction)
			batLineup = batFaction.getBatlineup(num)
			if batLineup.actionNum > max(batLineup.npcPosDict):
			if (faction, num) not in overLineupList:
			overLineupList.append((faction, num))

			turnFight.actionIndex += 1
			continue

			if faction == Def_FactionA:
			if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
			GameWorld.DebugLog("战锤不足!")
			return
			GameWorld.DebugLog("执行行动: turnNum=%s,faction=%s,num=%s,actionNum=%s" % (turnFight.turnNum, faction, num, batLineup.actionNum))

			# 主公
			if batLineup.actionNum == -1:
			pass

			# 红颜
			elif batLineup.actionNum == 0:
			pass
			# 灵兽

			if turnFight.checkOverByKilled():
			break

			# 武将
			elif batLineup.actionNum > 0:
			doMax = PosNumMax * len(turnFight.actionSortList)
			doCnt = 0
			while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList):
			doCnt += 1
			faction, num = turnFight.actionSortList[turnFight.actionIndex]
			batFaction = turnFight.getBatFaction(faction)
			batLineup = batFaction.getBatlineup(num)
			for posNum in range(batLineup.actionNum, PosNumMax + 1):
			batLineup.actionNum = posNum
			if posNum not in batLineup.npcPosDict:
			continue
			curNPC = batLineup.npcPosDict[posNum]
			if not curNPC or GameObj.GetHP(curNPC) <= 0:
			continue
			objType = curNPC.GetGameObjType()
			objID = curNPC.GetID()
			turnFight.syncObjAction(turnNum, objType, objID)

			objName = GetObjName(curNPC)
			curHP = GameObj.GetHP(curNPC)

			GameWorld.DebugLog("★回合%s %s 行动 : curHP=%s" % (turnNum, objName, curHP))
			if not DoAttack(curNPC, None, tick):
			GameWorld.DebugLog(" 攻击失败")
			# 每个武将位算一个时间节点
			#GameWorld.DebugLog("武将节点: faction=%s,posNum=%s,curTimeline=%s" % (faction, posNum, curTimeline))
			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))
			continue

			if faction == Def_FactionA:
			playerHeroAtk = True
			objID = batLineup.posObjIDDict[posNum]
			batObj = batObjMgr.getBatObj(objID)

			# 玩家自己阵营，预判可否行动
			if checkBreakpoint and faction == ChConfig.Def_FactionA and batObj:
			if batObj.CanAction():
			GameWorld.DebugLog("玩家阵容下一个可行动的武将，断点: curTimeline=%s,nextPosNum=%s" % (curTimeline, posNum))
			return

			batLineup.actionNum = posNum + 1
			curTimeline = turnFight.setTimeline(curTimeline + 1)
			TurnFightHeroTurnStart(turnFight, batObj, turnNum)
			if not OnObjAction(turnFight, batObj):
			continue

			if not checkBreakpoint and faction == ChConfig.Def_FactionA:
			checkBreakpoint = True

			break

			turnFight.actionIndex += 1
			batLineup.actionNum += 1
			if batLineup.actionNum > max(batLineup.npcPosDict):
			GameWorld.DebugLog("该阵容本回合已经全部行动完了: turnNum=%s,faction=%s,num=%s,actionNum=%s" % (turnFight.turnNum, faction, num, batLineup.actionNum))
			if (faction, num) not in overLineupList:
			overLineupList.append((faction, num))
			if turnFight.actionIndex >= len(turnFight.actionSortList) - 1:
			turnFight.actionIndex = 0
			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():
			break

			if playerHeroAtk:
			# 玩家武将有行动则停止，一段段执行
			GameWorld.DebugLog("玩家武将有行动则停止！")
			break
			if not turnFight.winFaction:
			OnTurnAllOver(turnFight.guid)

			if turnFight.winFaction:
			return

			GameWorld.DebugLog("turnNum=%s,doCnt=%s,overLineupList=%s" % (turnNum, doCnt, overLineupList))
			if len(overLineupList) >= len(turnFight.actionSortList):
			GameWorld.DebugLog("执行行动: turnNum=%s, 回合结束" % (turnFight.turnNum))
			if turnFight.turnEnd < turnNum:
			if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
			GameWorld.DebugLog("回合结束时战锤不足!")
			return
			turnFight.turnEnd = turnNum
			for faction, num in turnFight.actionSortList:
			batFaction = turnFight.getBatFaction(faction)
			batLineup = batFaction.getBatlineup(num)
			for curNPC in batLineup.npcPosDict.values():
			pass

			if turnFight.checkOverByKilled():
			return

			if turnNum < turnFight.turnMax:
			turnFight.turnNum += 1
			else:
			OnTurnAllOver(turnFight.guid)

			return

			def __processTurnFight(guid, tick):
			def __processTurnFight(guid):
			## 一次性处理完一个小队的战斗
			turnFight = GetTurnFightMgr().getTurnFight(guid)
			curPlayer = turnFight.curPlayer
			turnMax = turnFight.turnMax
			EntryLogic(turnFight)
			batObjMgr = BattleObj.GetBatObjMgr()
			for turnNum in range(1, turnMax + 1):
			turnFight.turnNum = turnNum
			GameWorld.DebugLog("【----- 回合制战斗轮次: %s -----】" % turnNum)
			curTimeline = turnFight.getTurnNumStartTimelin(turnNum) # 本回合起始时间节点
			curTimeline = turnFight.setTimeline(curTimeline + 1)
			if curPlayer:
			turnFight.syncState(FightState_Fighting)

			@@ -1128,20 +1262,13 @@
			batFaction = turnFight.getBatFaction(faction)
			batLineup = batFaction.getBatlineup(num)
			batLineup.actionNum = 1
			for curNPC in batLineup.npcPosDict.values():
			TurnFightObjPerTurnStart(curNPC, None, turnNum, tick)
			for objID in batLineup.posObjIDDict.values():
			batObj = batObjMgr.getBatObj(objID)
			TurnFightPerTurnBigStart(turnFight, batObj, turnNum)

			# 主公
			for faction, num in turnFight.actionSortList:
			GameWorld.DebugLog("主公逻辑: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
			batFaction = turnFight.getBatFaction(faction)
			batLineup = batFaction.getBatlineup(num)


			# 红颜
			for faction, num in turnFight.actionSortList:
			GameWorld.DebugLog("红颜逻辑: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
			batFaction = turnFight.getBatFaction(faction)
			batLineup = batFaction.getBatlineup(num)
			# 灵兽

			if turnFight.checkOverByKilled():
			break
			@@ -1156,20 +1283,14 @@
			batLineup = batFaction.getBatlineup(num)
			for posNum in range(batLineup.actionNum, PosNumMax + 1):
			batLineup.actionNum = posNum + 1
			if posNum not in batLineup.npcPosDict:
			if posNum not in batLineup.posObjIDDict:
			curTimeline = turnFight.setTimeline(curTimeline + 1, True)
			continue
			curNPC = batLineup.npcPosDict[posNum]
			if not curNPC or GameObj.GetHP(curNPC) <= 0:
			continue
			objType = curNPC.GetGameObjType()
			objID = curNPC.GetID()
			turnFight.syncObjAction(turnNum, objType, objID)

			objName = GetObjName(curNPC)
			curHP = GameObj.GetHP(curNPC)

			GameWorld.DebugLog("★回合%s %s 行动 : curHP=%s" % (turnNum, objName, curHP))
			if not DoAttack(curNPC, None, tick):
			curTimeline = turnFight.setTimeline(curTimeline + 1) # 每个武将位算一个时间节点
			objID = batLineup.posObjIDDict[posNum]
			batObj = batObjMgr.getBatObj(objID)
			TurnFightHeroTurnStart(turnFight, batObj, turnNum)
			if not OnObjAction(turnFight, batObj):
			continue

			break
			@@ -1180,13 +1301,15 @@
			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 curNPC in batLineup.npcPosDict.values():
			pass

			for objID in batLineup.posObjIDDict.values():
			batObj = batObjMgr.getBatObj(objID)
			TurnFightPerTurnBigEnd(turnFight, batObj, turnNum)

			if turnFight.checkOverByKilled():
			break

			@@ -1194,32 +1317,18 @@
			OnTurnAllOver(turnFight.guid)
			return

			#// B4 10 回合制战斗 #tagCMTurnFight
			#
			#struct tagCMTurnFight
			#{
			# tagHead Head;
			# DWORD MapID; // 自定义地图ID，可用于绑定战斗地图场景功能（如主线关卡、主线boss、爬塔、竞技场等）
			# DWORD FuncLineID; // MapID对应的扩展值，如具体某个关卡等
			# BYTE TagType; // 目标类型，0-NPC阵容，1-玩家
			# DWORD TagID; // 目标类型对应的ID，如阵容ID或玩家ID
			# BYTE ValueCount;
			# DWORD ValueList[ValueCount]; // 附加值列表，可选，具体含义由MapID决定
			#};
			def OnTurnFight(index, clientData, tick):
			#curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			#mapID = clientData.MapID
			#funcLineID = clientData.FuncLineID
			return

			def GetObjName(gameObj):
			objName = gameObj.GetName()
			faction = GameObj.GetFaction(gameObj)
			posInfo = gameObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo)
			heroID = gameObj.GetDictByKey(ChConfig.Def_Obj_Dict_HeroID)
			if not heroID:
			heroID = gameObj.GetNPCID()
			return "%s%s %s[%s-%s]" % ("A" if faction == Def_FactionA else "B", posInfo, objName, gameObj.GetID(), heroID)
			def GetObjName(batObj):
			faction = batObj.faction
			num = batObj.lineupNum
			posNum = batObj.posNum
			heroID = batObj.heroID
			npcID = batObj.npcID
			objName = GameWorld.CodeToGbk(batObj.GetName())
			if heroID:
			objName += " Hero:%s" % heroID
			if npcID:
			objName += " NPC:%s" % npcID
			return "%s%s-P%s ID:%s %s" % ("A" if faction == ChConfig.Def_FactionA else "B", num, posNum, batObj.GetID(), objName)

			def EntryLogic(turnFight):
			## 执行进场逻辑
			@@ -1227,509 +1336,262 @@
			return
			GameWorld.DebugLog("执行进场逻辑...")

			batObjMgr = BattleObj.GetBatObjMgr()
			for faction, num in turnFight.actionSortList:
			batFaction = turnFight.getBatFaction(faction)
			batLineup = batFaction.getBatlineup(num)
			batLineup.actionNum = ActionNumStart
			for objID in batLineup.posObjIDDict.values():
			batObj = batObjMgr.getBatObj(objID)
			TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_FightStart)

			turnFight.enterLogic = True
			return True

			def OnTimelineChange(turnFight):
			## 每个时间节点变化时处理

			nowTimeline = turnFight.getTimeline()

			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

			batObj.SetDict(ChConfig.Def_Obj_Dict_TurnComboNum, 0)
			batObj.SetDict(ChConfig.Def_Obj_Dict_TurnMissNum, 0)
			batObj.SetDict(ChConfig.Def_Obj_Dict_TurnParryNum, 0)

			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, False)
			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 TurnFightObjPerTurnStart(gameObj, tagObj, turnNum, tick):
			## 回合制战斗实例 - 每回合开始时处理
			if not gameObj:
			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

			# SetTimeline(gameObj, turnNum, 0)
			# # 重置连击、反击数
			# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnComboNum, 0)
			# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnAtkBackNum, 0)
			# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnParryNum, 0)
			# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnMissNum, 0)
			# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnAtkAddXPCount, 0)
			# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnXPUseState, 0)
			# gameObj.SetDict(ChConfig.Def_PlayerKey_AttrFaintCD, 0) # 击晕CD
			#
			# objType = gameObj.GetGameObjType()
			# objID = gameObj.GetID()
			# objName = GetObjName(gameObj)
			# GameWorld.DebugLog("ObjPerTurnStart: 回合%s, %s objType-ID-HP(%s-%s-%s)" % (turnNum, objName, objType, objID, GameObj.GetHP(gameObj)))
			#
			# # 每回合开始减技能CD
			# skillManager = gameObj.GetSkillManager()
			# for i in range(skillManager.GetSkillCount()):
			# skill = skillManager.GetSkillByIndex(i)
			# remainTime = skill.GetRemainTime()
			# if not remainTime:
			# continue
			# skillID = skill.GetSkillID()
			# updRemainTime = max(0, remainTime - ChConfig.Def_PerTurnTick)
			# skill.SetRemainTime(updRemainTime)
			# GameWorld.DebugLog(" skillID=%s,remainTime=%s,updRemainTime=%s" % (skillID, remainTime, updRemainTime))
			#
			# # 刷新定时处理的buff效果
			# SkillShell.ProcessPersistBuff(gameObj, tick)
			#
			# PassiveBuffEffMng.OnPassiveSkillTrigger(gameObj, tagObj, None, ChConfig.TriggerType_TurnNum, tick)
			#
			# __logGameObjAttr(gameObj)
			if batObj.GetHP() <= 0:
			return

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

			def TurnFightPerTurnBigEnd(turnFight, batObj, turnNum):
			## 大回合结束时
			if not batObj:
			return

			if batObj.GetHP() <= 0:
			return

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

			def TurnFightHeroTurnStart(turnFight, batObj, turnNum):
			## 武将回合开始时，不能行动也要触发
			if not batObj:
			return

			if batObj.GetHP() <= 0:
			return

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

			def AddTurnObjCureHP(curObj, srcObj, addValue, cureHP, skillID=0):
			## 回合对象添加治疗值
			if not curObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
			# @param curObj: 获得治疗的对象
			# @param srcObj: 来自谁的治疗
			# @param addValue: 治疗值
			# @param cureHP: 实际回血量
			if not srcObj:
			return

			curFaction = GameObj.GetFaction(curObj)
			if not srcObj or curFaction != GameObj.GetFaction(srcObj):
			# 同阵营的治疗才统计
			return

			curID = curObj.GetID()
			srcID = srcObj.GetID()
			turnFight = GetTurnFightMgr().getNPCTurnFight(curID)
			if not turnFight:
			return

			curBatFaction = turnFight.getBatFaction(curFaction)
			for num in curBatFaction.lineupDict.keys():
			batLineup = curBatFaction.getBatlineup(num)
			updStatValue = batLineup.statCureValue(srcID, cureHP)
			if updStatValue == None:
			continue
			GameWorld.DebugLog(" 统计治疗: curTD=%s,srcID=%s,skillID=%s,addValue=%s,cureHP=%s,updStatValue=%s"
			% (curID, srcID, skillID, addValue, cureHP, updStatValue))
			break

			updStatValue = srcObj.StatCureValue(cureHP)
			GameWorld.DebugLog(" 统计治疗: curID=%s,srcID=%s,skillID=%s,addValue=%s,cureHP=%s,updStatValue=%s"
			% (curID, srcID, skillID, addValue, cureHP, updStatValue))

			return

			def AddTurnObjHurtValue(curObj, tagObj, hurtType, hurtValue, lostHP, curSkill=None):
			def AddTurnObjHurtValue(curBatObj, tagBatObj, hurtValue, lostHP, skillID=0, isBounce=False):
			## 回合对象添加伤害值
			if not curObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
			# @param isBounce: 是否反弹伤害
			if hurtValue <= 0:
			return
			curID = curObj.GetID()
			tagID = tagObj.GetID()
			skillID = curSkill.GetSkillID() if curSkill else 0
			turnFight = GetTurnFightMgr().getNPCTurnFight(curID)
			if not turnFight:
			return

			curID = curBatObj.GetID()
			tagID = tagBatObj.GetID()
			if curID != tagID:
			curBatFaction = turnFight.getBatFaction(GameObj.GetFaction(curObj))
			for num in curBatFaction.lineupDict.keys():
			batLineup = curBatFaction.getBatlineup(num)
			updStatValue = batLineup.statHurtValue(curID, lostHP)
			if updStatValue == None:
			continue
			GameWorld.DebugLog(" 统计伤血: curTD=%s,tagID=%s,skillID=%s,hurtType=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,tagHP=%s"
			% (curID, tagID, skillID, hurtType, hurtValue, lostHP, updStatValue, GameObj.GetHP(tagObj)))
			break
			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))

			tagBatFaction = turnFight.getBatFaction(GameObj.GetFaction(tagObj))
			for num in tagBatFaction.lineupDict.keys():
			batLineup = tagBatFaction.getBatlineup(num)
			updStatValue = batLineup.statDefValue(tagID, lostHP)
			if updStatValue == None:
			continue
			GameWorld.DebugLog(" 统计承伤: curTD=%s,tagID=%s,skillID=%s,hurtType=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,curHP=%s"
			% (tagID, curID, skillID, hurtType, hurtValue, lostHP, updStatValue, GameObj.GetHP(tagObj)))
			break

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

			else:
			# 如换血类技能，自残的伤害不算输出
			GameWorld.DebugLog(" 自残: curTD=%s,tagID=%s,skillID=%s,hurtType=%s,hurtValue=%s,lostHP=%s,curHP=%s"
			% (curID, tagID, skillID, hurtType, hurtValue, lostHP, GameObj.GetHP(curObj)))

			if lostHP > 0 and curID != tagID:
			addXP = IpyGameDataPY.GetFuncCfg("AngerXP", 4)
			AddTurnFightXP(tagObj, addXP, "skillID:%s" % skillID)
			GameWorld.DebugLog(" 自残: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,curHP=%s"
			% (curID, tagID, skillID, hurtValue, lostHP, curBatObj.GetHP()))
			return

			def AddTurnFightXP(gameObj, addXP, reason=""):
			## 回合战斗增加XP
			if addXP <= 0 or not addXP:
			#GameWorld.DebugLog(" 没有增加XP! curID=%s" % (gameObj.GetID()))
			def OnObjAction(turnFight, curBatObj):
			## 战斗单位行动
			if not curBatObj:
			return
			posNum = gameObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) % 10
			if posNum <= 0:
			#非主战单位不加

			curHP = curBatObj.GetHP()
			objID = curBatObj.GetID()
			if curHP <= 0:
			return
			curXP = GameObj.GetXP(gameObj)
			updXP = curXP + addXP
			GameObj.SetXP(gameObj, updXP)
			GameWorld.DebugLog(" 更新XP: curID=%s,curXP=%s,addXP=%s,updXP=%s,reason=%s" % (gameObj.GetID(), curXP, addXP, updXP, reason))
			return

			def DoAttack(curNPC, tagNPC, tick, turnBattleType=ChConfig.TurnBattleType_Normal, useSkill=None):
			curID = curNPC.GetID()
			npcID = curNPC.GetNPCID()
			objName = GetObjName(curNPC)
			GameWorld.DebugLog(" ● %s DoAttack: curID=%s,,turnBattleType=%s" % (objName, curID, turnBattleType))

			atkOK = False
			tagObj = tagNPC
			curNPC.SetDict(ChConfig.Def_Obj_Dict_TurnBattleType, turnBattleType)
			turnNum = turnFight.turnNum
			objName = GetObjName(curBatObj)

			if turnBattleType == ChConfig.TurnBattleType_AtkBack:
			if not tagObj:
			return
			skillManager = curNPC.GetSkillManager()
			for index in range(0, skillManager.GetSkillCount()):
			skill = skillManager.GetSkillByIndex(index)
			#已经到尾部了
			if not skill or skill.GetSkillTypeID() == 0:
			break
			if skill.GetFuncType() == ChConfig.Def_SkillFuncType_NormalAttack:
			useSkill = skill
			break
			atkOK = SkillShell.DoLogic_UseSkill(curNPC, tagObj, useSkill, tick)
			elif turnBattleType == ChConfig.TurnBattleType_Combo:
			if not tagObj:
			return
			atkOK = SkillShell.DoLogic_UseSkill(curNPC, tagObj, useSkill, tick)
			else:
			curXP = GameObj.GetXP(curNPC)
			xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2)
			skillManager = curNPC.GetSkillManager()
			useSkillList = []
			#GameWorld.DebugLog('skillCount=%s' % skillManager.GetSkillCount(), npcID)
			for index in range(0, skillManager.GetSkillCount()):
			useSkill = skillManager.GetSkillByIndex(index)
			#已经到尾部了
			if not useSkill or useSkill.GetSkillTypeID() == 0:
			break
			if useSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_NormalAttack]:
			#基础普攻不能主动释放，目前仅用于反击
			# 是否可行动状态判断
			canAction = curBatObj.CanAction()
			if not canAction:
			GameWorld.DebugLog("★回合%s %s 当前状态不可行动!" % (turnNum, objName))
			return

			atk = curBatObj.GetAtk()
			curXP = curBatObj.GetXP()
			GameWorld.DebugLog("★回合%s %s 行动 : atk=%s,curHP=%s/%s,curXP=%s" % (turnNum, objName, atk, curHP, curBatObj.GetMaxHP(), curXP))
			turnFight.syncObjAction(turnNum, objID)

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

			xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2)
			skillManager = curBatObj.GetSkillManager()
			useSkillList = []
			#GameWorld.DebugLog('skillCount=%s' % skillManager.GetSkillCount(), npcID)
			for index in range(0, skillManager.GetSkillCount()):
			useSkill = skillManager.GetSkillByIndex(index)
			if not useSkill:
			continue
			if useSkill.GetFuncType() not in [ChConfig.Def_SkillFuncType_TurnNormaSkill, ChConfig.Def_SkillFuncType_AngerSkill]:
			#只能主动释放普攻或怒技
			continue
			#被动技能无法使用
			if SkillCommon.isPassiveSkill(useSkill):
			continue
			#还在冷却时间内无法释放
			if useSkill.GetRemainTime():
			continue
			skillID = useSkill.GetSkillID()
			# 常规攻击优先xp
			if SkillCommon.isAngerSkill(useSkill):
			if curXP < xpMax:
			continue
			#被动技能无法使用
			if SkillCommon.isPassiveSkill(useSkill):
			if curBatObj.IsInState(ChConfig.BatObjState_Sneer):
			GameWorld.DebugLog("嘲讽状态下，无法主动释放怒技!") # 可被动释放怒技，如怒技追击
			continue
			#还在冷却时间内无法释放
			if SkillCommon.RefreshSkillRemainTime(useSkill, tick) != 0:
			continue
			skillTypeID = useSkill.GetSkillTypeID()
			# 常规攻击优先xp
			if SkillCommon.isAngerSkill(useSkill) and turnBattleType == ChConfig.TurnBattleType_Normal:
			if curXP < xpMax:
			continue
			useCnt = -1 # xp技能优先释放
			else:
			useCnt = curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_SkillUseCnt % skillTypeID) # 该技能已使用次数
			useSkillList.append([useCnt, index, skillTypeID, useSkill])

			useSkillList.sort() # 按使用次数优先升序排，使用次数低的优先判断使用
			#GameWorld.DebugLog(' 技能使用顺序 = useSkillList%s' % str(useSkillList), npcID)
			useCnt = -1 # xp技能优先释放
			else:
			useCnt = curBatObj.GetSkillUseCnt(skillID)
			useSkillList.append([useCnt, skillID, useSkill])

			for useInfo in useSkillList:
			useSkill = useInfo[-1]
			#skillID = useSkill.GetSkillID()
			atkOK, tagObj = DoNPCUseSkill(curNPC, useSkill, tick)
			if atkOK:
			break

			curNPC.SetDict(ChConfig.Def_Obj_Dict_TurnBattleType, 0) # 无论攻击成功与否都重置战斗类型
			useSkillList.sort() # 按使用次数优先升序排，使用次数低的优先判断使用
			#GameWorld.DebugLog(' 技能使用顺序 = useSkillList%s' % str(useSkillList), npcID)

			tagID = 0
			tagHP = 0
			if tagObj:
			tagID = tagObj.GetID()
			tagHP = GameObj.GetHP(tagObj)
			GameWorld.DebugLog(' atkOK=%s,tagID=%s,tagHP=%s' % (atkOK, tagID, tagHP), npcID)
			if not atkOK:
			return

			if not tagObj:
			return

			if GameObj.GetFaction(curNPC) == GameObj.GetFaction(tagObj):
			# 同阵营直接返回，不处理连击、反击
			return True

			curHP = GameObj.GetHP(curNPC)
			tagHP = GameObj.GetHP(tagObj)
			tagID = tagObj.GetID()
			GameWorld.DebugLog(" curID-HP=(%s-%s),tagID-HP=(%s-%s)" % (curID, curHP, tagID, tagHP))
			if tagHP <= 0 or curHP <= 0:
			return True

			# 反击，反击可打断连击，所以优先判断
			if CanAtkBack(curNPC, tagObj):
			DoAttack(tagObj, curNPC, tick, ChConfig.TurnBattleType_AtkBack)
			return True

			# 连击
			if CanCombo(curNPC, tagObj):
			DoAttack(curNPC, tagObj, tick, ChConfig.TurnBattleType_Combo, useSkill)
			for useInfo in useSkillList:
			useSkill = useInfo[-1]
			if TurnSkill.OnUseSkill(turnFight, curBatObj, useSkill):
			break

			TurnPassive.OnTriggerPassiveEffect(turnFight, curBatObj, ChConfig.TriggerWay_HeroActionEnd)
			return True

			def CanAtkBack(atkObj, defObj):
			## 可否反击
			posNum = atkObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) % 100
			if posNum <= 0:
			GameWorld.DebugLog(" 被非主战单位攻击时无法触发反击: atkID=%s,posNum=%s" % (atkObj.GetID(), posNum))
			return False
			atkDistType = AttackCommon.GetAtkDistType(defObj)
			if atkDistType == ChConfig.AtkDistType_Long:
			if not IpyGameDataPY.GetFuncCfg("ParryCfg", 2):
			GameWorld.DebugLog(" 远程单位不可反击: defID=%s" % (defObj.GetID()))
			return False
			defAtkBackRate = GameObj.GetAtkBackRate(defObj) # 防方反击率
			atkBackNum = defObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnAtkBackNum) # 已反击次数
			if atkBackNum > 10:
			# 内置最高反击数防范
			return False
			if atkBackNum > 0:
			validPerList = IpyGameDataPY.GetFuncEvalCfg("TurnFight", 4)
			vaildPer = validPerList[atkBackNum - 1] if len(validPerList) >= atkBackNum else 0
			defAtkBackRate = int(defAtkBackRate * vaildPer / 100.0)

			atkAtkBackDefRate = GameObj.GetAtkBackDefRate(atkObj) # 攻方抵抗反击率
			atkBackRate = max(0, defAtkBackRate - atkAtkBackDefRate)
			if atkBackRate <= 0 or not GameWorld.CanHappen(atkBackRate):
			GameWorld.DebugLog(" 无法反击: defID=%s,atkBackNum=%s,atkBackRate=%s=(defAtkBackRate=%s - atkAtkBackDefRate=%s)"
			% (defObj.GetID(), atkBackNum, atkBackRate, defAtkBackRate, atkAtkBackDefRate))
			return False
			GameWorld.DebugLog(" 可以反击: defID=%s,atkBackNum=%s,atkBackRate=%s=(defAtkBackRate=%s - atkAtkBackDefRate=%s)"
			% (defObj.GetID(), atkBackNum, atkBackRate, defAtkBackRate, atkAtkBackDefRate))
			return True

			def CanCombo(atkObj, defObj):
			## 可否连击

			atkComboRate = GameObj.GetComboRate(atkObj) # 攻方连击率
			comboNum = atkObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnComboNum) # 已连击次数
			if comboNum > 10:
			# 内置最高连击数防范
			return False
			if comboNum > 0:
			validPerList = IpyGameDataPY.GetFuncEvalCfg("TurnFight", 3)
			vaildPer = validPerList[comboNum - 1] if len(validPerList) >= comboNum else 0
			atkComboRate = int(atkComboRate * vaildPer / 100.0)

			defComboReduce = GameObj.GetComboDefRate(defObj) # 防方抵抗连击率
			comboRate = max(0, atkComboRate - defComboReduce)
			if comboRate <= 0 or not GameWorld.CanHappen(comboRate):
			GameWorld.DebugLog(" 无法连击: atkID=%s,comboNum=%s,comboRate=%s=(atkComboRate=%s - defComboReduce=%s)"
			% (atkObj.GetID(), comboNum, comboRate, atkComboRate, defComboReduce))
			return False
			GameWorld.DebugLog(" 可以连击: atkID=%s,comboNum=%s,comboRate=%s=(atkComboRate=%s - defComboReduce=%s)"
			% (atkObj.GetID(), comboNum, comboRate, atkComboRate, defComboReduce))
			return True

			def DoNPCUseSkill(curNPC, useSkill, tick):
			'''NPC使用技能
			@return: 是否成功, tagObj
			'''
			if not useSkill or useSkill.GetSkillTypeID() == 0:
			return False, None

			#检查是否几率触发
			rate = useSkill.GetHappenRate()
			if rate != ChConfig.Def_MaxRateValue and not GameWorld.CanHappen(rate, ChConfig.Def_MaxRateValue):
			#GameWorld.Log('检查是否几率触发 = %s失败 = %s'%(rate, useSkill.GetSkillName()))
			return False, None

			tagObj = None
			skillTag = SkillShell.GetSkillAffectTag(useSkill)
			skillAim = SkillShell.GetSkillFireAim(useSkill)

			# 注：多V多的情况友好目标仅针对本阵容、敌对目标可针对任意敌对阵容

			#---对自己释放,或者无目标技能---
			if skillTag in ChConfig.Def_ST_CanNPCUseSkill or skillAim == ChConfig.Def_UseSkillAim_None:
			#释放自身类技能
			tagObj = curNPC
			isOK = SkillShell.DoLogic_UseSkill(curNPC, tagObj, useSkill, tick)
			return isOK, tagObj

			# 召唤兽对主人释放技能
			elif skillTag == ChConfig.Def_UseSkillTag_SummonMaster:
			if not NPCCommon.IsSummonNPC(curNPC):
			GameWorld.ErrLog("该NPC非召唤兽，无法获得主人释放技能")
			return False, None

			curSummonOwner = NPCCommon.GetSummonNPCOwner(IPY_GameWorld.gotPlayer, curNPC)
			if curSummonOwner == None:
			curSummonOwner = NPCCommon.GetSummonNPCOwner(IPY_GameWorld.gotNPC, curNPC)

			if curSummonOwner == None:
			GameWorld.ErrLog("召唤兽（%s）对主人释放技能，找不到主人" % curNPC.GetNPCID())
			return False, None

			tagObj = curSummonOwner

			# 友好死亡目标，一般是复活技能
			elif skillTag == ChConfig.Def_UseSkillTag_FriendDeath:
			deathList = GetFriendDeathList(curNPC)
			if not deathList:
			return False, None
			tagObj = random.choice(deathList) # 随机选一个

			# 友好目标
			elif skillTag in ChConfig.Def_ST_CanNPCUseSkillFriend:
			friendList = GetFriendObjList(curNPC)
			if not friendList:
			return False, None
			tagObj = random.choice(friendList) # 随机选一个，可扩展其他选择规则

			# 敌方目标
			else:
			tagObj = GetEnemyObj(curNPC)

			if not tagObj:
			return False, None

			GameWorld.DebugLog(" 技能释放: skillID=%s,atkID=%s,def=%s,HP:%s/%s"
			% (useSkill.GetSkillID(), curNPC.GetID(), GetObjName(tagObj), GameObj.GetHP(tagObj), GameObj.GetMaxHP(tagObj)))
			isOK = SkillShell.DoLogic_UseSkill(curNPC, tagObj, useSkill, tick)
			return isOK, tagObj

			def GetFriendDeathList(curNPC):
			## 获取友方死亡单位，仅针对本阵容主战单位
			objID = curNPC.GetID()
			turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
			if not turnFight:
			return []
			batFaction = turnFight.getBatFaction(GameObj.GetFaction(curNPC))
			num = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) / 100
			batLineup = batFaction.getBatlineup(num)
			deathList = []
			for posNum, tagNPC in batLineup.npcPosDict.items():
			if posNum <= 0 or not tagNPC:
			continue
			if GameObj.GetHP(tagNPC) > 0:
			continue
			deathList.append(tagNPC)

			return deathList

			def GetFriendObjList(curNPC):
			## 获取友方单位，仅针对本阵容主战单位
			objID = curNPC.GetID()
			turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
			if not turnFight:
			return []
			batFaction = turnFight.getBatFaction(GameObj.GetFaction(curNPC))
			num = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) / 100
			batLineup = batFaction.getBatlineup(num)
			friendList = []
			for posNum, tagNPC in batLineup.npcPosDict.items():
			if posNum <= 0 or not tagNPC:
			continue
			if GameObj.GetHP(tagNPC) <= 0:
			continue
			friendList.append(tagNPC)
			return friendList

			def GetEnemyObj(curNPC, ruleType=0):
			## 获取一个敌对单位，针对所有敌对阵容主战单位，优先选择对位阵容单位，仅限活着的单位
			# @param ruleType: 选择规则，默认0任意，1-最低血量；2-最高血量
			objID = curNPC.GetID()
			faction = GameObj.GetFaction(curNPC)
			posInfo = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo)
			num = posInfo / 100 # 阵容编号
			posNum = posInfo % 100 # 所在阵容站位
			turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
			if not turnFight:
			return

			tagBatFaction = turnFight.getBatFaction(Def_FactionB if faction == Def_FactionA else Def_FactionA)

			tagLineupNumList = [num] # 目标阵容选择顺序，优先对位阵容，再其他阵容
			if num in tagBatFaction.lineupDict:
			tagLineupNumList = [num]
			for tagNum in tagBatFaction.lineupDict.keys():
			if tagNum not in tagLineupNumList:
			tagLineupNumList.append(tagNum)

			for tagNum in tagLineupNumList:
			tagLineup = tagBatFaction.getBatlineup(tagNum)
			tagPosNumList = [posNum] # 优先对位位置，再其他位置按顺序遍历
			pNumList = tagLineup.npcPosDict.keys()
			pNumList.sort()
			for pNum in pNumList:
			if pNum > 0 and pNum not in tagPosNumList:
			tagPosNumList.append(pNum)
			for pNum in tagPosNumList:
			tagNPC = tagLineup.npcPosDict.get(pNum)
			if not tagNPC:
			continue
			if GameObj.GetHP(tagNPC) <= 0:
			continue
			return tagNPC
			return

			def SetTurnObjKilled(gameObj, killer=None):
			if not gameObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
			#GameWorld.DebugLog("非回合战斗主体被击杀: curID=%s" % gameObj.GetID())
			return

			def SetObjKilled(turnFight, gameObj, killer=None, useSkill=None):
			objID = gameObj.GetID()
			GameWorld.DebugLog(" %s 回合战斗主体被击杀: curID=%s" % (GetObjName(gameObj), objID))
			gameObj.SetCurAction(IPY_GameWorld.laNPCDie)
			if GameObj.GetHP(gameObj) != 0:
			GameObj.SetHP(gameObj, 0) # 回合制死亡仅设置为0，实例暂时不回收
			gameObj.SetVisible(False)
			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()

			turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
			if not turnFight:
			return True
			clientPack = ChPyNetSendPack.tagMCTurnFightObjDead()
			clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagMCTurnFightObjDead)
			clientPack.ObjID = objID
			clientPack.KillerObjID = killerObjID
			clientPack.SkillID = skillID
			turnFight.addBatPack(clientPack)

			# 记录主动发起的玩家阵营击杀
			curPlayer = turnFight.curPlayer
			if killer and curPlayer and killer.GetDictByKey(ChConfig.Def_Obj_Dict_LineupPlayerID) == curPlayer.GetPlayerID():
			if objID not in turnFight.playerKillObjIDList:
			turnFight.playerKillObjIDList.append(objID)
			GameWorld.DebugLog("玩家单次击杀统计: %s" % turnFight.playerKillObjIDList)

			# 暂时只算主线小怪
			if curPlayer and turnFight.mapID == ChConfig.Def_FBMapID_Main and gameObj.GetFaction() != ChConfig.Def_FactionA:
			PlayerTask.AddTaskValue(curPlayer, ChConfig.TaskType_KillNPC, 1)
			return True

			def OnTurnfightAttackSuccess(curObj, tagObj, curSkill):
			## 回合战斗攻击成功额外处理，AttackResult之前，一般处理技能相关
			if curObj.GetGameObjType() != IPY_GameWorld.gotNPC:
			return
			if not curObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
			return

			objID = curObj.GetID()
			turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
			if not turnFight:
			return

			skillID = curSkill.GetSkillID() if curSkill else 0
			isXP = SkillCommon.isAngerSkill(curSkill)
			if isXP:
			GameObj.SetXP(curObj, 0)
			elif curSkill:
			if SkillCommon.isTurnNormalSkill(curSkill):
			addXP = IpyGameDataPY.GetFuncCfg("AngerXP", 3)
			AddTurnFightXP(curObj, addXP, "skillID:%s" % skillID)

			curPlayer = turnFight.curPlayer
			# 仅主动发起玩家阵容触发
			if curPlayer and curObj.GetDictByKey(ChConfig.Def_Obj_Dict_LineupPlayerID) == curPlayer.GetPlayerID():
			FBLogic.OnPlayerLineupAttackSuccess(curPlayer, curObj, tagObj, curSkill, turnFight.mapID, turnFight.funcLineID)

			return

			def OnTurnfightAttackResult(curObj, tagObj, curSkill):
			## 回合战斗攻击结果额外处理，AttackResult 之后，一般处理击杀结算相关
			if curObj.GetGameObjType() != IPY_GameWorld.gotNPC:
			return
			if not curObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
			return

			objID = curObj.GetID()
			turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
			if not turnFight:
			return

			curPlayer = turnFight.curPlayer
			# 仅主动发起玩家阵容触发
			if curPlayer and curObj.GetDictByKey(ChConfig.Def_Obj_Dict_LineupPlayerID) == curPlayer.GetPlayerID():
			FBLogic.OnPlayerLineupAttackResult(curPlayer, curObj, tagObj, curSkill, turnFight.mapID, turnFight.funcLineID)

			turnFight.playerKillObjIDList = []
			return

			def OnTurnAllOver(guid):
			## 所有回合已经全部执行完毕
			@@ -1743,10 +1605,10 @@

			if turnFight.playerID:
			# 玩家发起的，未击杀对方，算玩家输
			turnFight.winFaction = Def_FactionB
			turnFight.winFaction = ChConfig.Def_FactionB
			else:
			# 系统场次，按一定规则来，这里先随机
			turnFight.winFaction = random.choice([Def_FactionA, Def_FactionB])
			turnFight.winFaction = random.choice([ChConfig.Def_FactionA, ChConfig.Def_FactionB])

			DoTurnFightOver(guid)
			return
			@@ -1760,9 +1622,11 @@

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

			# 统计明细
			batObjMgr = BattleObj.GetBatObjMgr()
			statInfo = {}
			for faction in turnFight.factionDict.keys():
			if str(faction) not in statInfo:
			@@ -1774,143 +1638,30 @@
			facStatInfo[str(num)] = {}
			lineupStatInfo = facStatInfo[str(num)]
			batLineup = batFaction.getBatlineup(num)
			hurtStatDict = batLineup.hurtStatDict
			defStatDict = batLineup.defStatDict
			cureStatDict = batLineup.cureStatDict
			GameWorld.DebugLog("阵容明细: faction=%s,num=%s" % (faction, num))
			for posNum, curNPC in batLineup.npcPosDict.items():
			objID = curNPC.GetID()
			npcID = curNPC.GetNPCID()
			heroID = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_HeroID)
			atkHurt = hurtStatDict.get(objID, 0)
			defHurt = defStatDict.get(objID, 0)
			cureHP = cureStatDict.get(objID, 0)
			GameWorld.DebugLog(" Pos:%s ID=%s-%s-%s,,HP=%s/%s, 输出=%s,承伤=%s,治疗=%s"
			% (posNum, objID, npcID, heroID, GameObj.GetHP(curNPC), GameObj.GetMaxHP(curNPC), atkHurt, defHurt, cureHP))
			for posNum, objID in batLineup.posObjIDDict.items():
			batObj = batObjMgr.getBatObj(objID)
			if not batObj:
			continue
			objID = batObj.GetID()
			npcID = batObj.GetNPCID()
			heroID = batObj.GetHeroID()
			atkHurt = batObj.hurtStat
			defHurt = batObj.defStat
			cureHP = batObj.cureStat
			GameWorld.DebugLog(" Pos:%s ID=%s,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}

			awardItemList = []
			playerID = turnFight.playerID
			if playerID:
			curPlayer = turnFight.curPlayer
			isWin = (winFaction == Def_FactionA)
			# 主线小怪
			if turnFight.mapID == ChConfig.Def_FBMapID_Main:
			OnOver_MainLevel(curPlayer, isWin, awardItemList)
			# 主线boss
			elif turnFight.mapID == ChConfig.Def_FBMapID_MainBoss:
			OnOver_MainLevelBoss(curPlayer, isWin, awardItemList)
			else:
			pass

			overMsg = {"winFaction":winFaction, "statInfo":statInfo, FBCommon.Over_itemInfo:FBCommon.GetJsonItemList(awardItemList)}
			overMsg = {"winFaction":winFaction, "statInfo":statInfo}
			curPlayer = turnFight.curPlayer
			mapID = turnFight.mapID
			funcLineID = turnFight.funcLineID

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

			turnFight.syncState(FightState_Award, overMsg)

			# 除了主线外，其余战斗结束后均直接删除
			if not turnFight.playerID:
			tfMgr.delTurnFight(guid)
			return

			def OnOver_MainLevel(curPlayer, isWin, awardItemList):
			## 战斗结束额外处理 - 主线关卡
			if not curPlayer:
			return
			playerID = curPlayer.GetPlayerID()
			mainFightMgr = GetMainFightMgr(curPlayer)
			mainFightMgr.nextTeam = False
			chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)

			if not isWin:
			nextWave = max(1, wave - 1)
			nowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, nextWave)
			GameWorld.DebugLog("主线小怪战斗失败，降一波! chapterID=%s,levelNum=%s,wave=%s,nextWave=%s,nowValue=%s"
			% (chapterID, levelNum, wave, nextWave, nowValue), playerID)
			return

			if mainFightMgr.teamNum < mainFightMgr.teamMax:
			mainFightMgr.nextTeam = True
			GameWorld.DebugLog("主线小怪战斗胜利，下一小队! chapterID=%s,levelNum=%s,wave=%s,teamNum=%s/%s"
			% (chapterID, levelNum, wave, mainFightMgr.teamNum, mainFightMgr.teamMax), playerID)
			return

			# 获胜过波
			if wave < mainFightMgr.waveMax:
			nextWave = min(mainFightMgr.waveMax, wave + 1)
			nowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, nextWave)
			GameWorld.DebugLog("主线小怪波战斗胜利，下一波! chapterID=%s,levelNum=%s,wave=%s,nextWave=%s,nowValue=%s"
			% (chapterID, levelNum, wave, nextWave, nowValue), playerID)
			else:
			GameWorld.DebugLog("主线小怪波战斗胜利，最后一波循环刷! chapterID=%s,levelNum=%s,wave=%s" % (chapterID, levelNum, wave), playerID)

			# 小怪可能会退波，所以只在有超过已过关卡进度时才更新值
			hisPassValue = PlayerControl.GetMainLevelPassValue(curPlayer)
			curPassValue = PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
			if curPassValue > hisPassValue:
			GameWorld.DebugLog("更新当前过关进度! curPassValue=%s,hisPassValue=%s" % (curPassValue, hisPassValue), playerID)
			PlayerControl.SetMainLevelPassValue(curPlayer, curPassValue)
			else:
			GameWorld.DebugLog("未超过当前过关进度，不更新! curPassValue=%s <= hisPassValue=%s" % (curPassValue, hisPassValue), playerID)

			return

			def OnOver_MainLevelBoss(curPlayer, isWin, awardItemList):
			## 战斗结束额外处理 - 主线关卡boss
			if not curPlayer:
			return
			playerID = curPlayer.GetPlayerID()
			mainFightMgr = GetMainFightMgr(curPlayer)
			mainFightMgr.nextTeam = False
			chapterID, levelNum, _ = PlayerControl.GetMainLevelPassInfo(curPlayer)
			if not isWin:
			nowValue = PlayerControl.GetMainLevelNowValue(curPlayer)
			GameWorld.DebugLog("主线boss战斗失败！保持当前刷怪波进度不变! nowValue=%s" % nowValue, playerID)
			return

			if mainFightMgr.teamNum < mainFightMgr.teamMax:
			mainFightMgr.nextTeam = True
			GameWorld.DebugLog("主线boss小队战斗胜利，下一小队! chapterID=%s,levelNum=%s,teamNum=%s/%s"
			% (chapterID, levelNum, mainFightMgr.teamNum, mainFightMgr.teamMax), playerID)
			return

			isAllPass = False # 是否通关
			if IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID, levelNum + 1):
			nextChapterID, nextLevelNum = chapterID, levelNum + 1
			GameWorld.DebugLog("主线boss波战斗胜利！下一关! chapterID=%s,levelNum=%s,nextLevelNum=%s"
			% (chapterID, levelNum, nextLevelNum), playerID)
			elif IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID + 1, 1):
			nextChapterID, nextLevelNum = chapterID + 1, 1
			GameWorld.DebugLog("主线boss波战斗胜利！下一章! chapterID=%s,levelNum=%s,nextChapterID=%s,nextLevelNum=%s"
			% (chapterID, levelNum, nextChapterID, nextLevelNum), playerID)
			else:
			# 已通关的暂时先保持不变
			# 注意防范最后一关奖励重复获得
			nextChapterID, nextLevelNum = chapterID + 1, 1
			GameWorld.DebugLog("主线boss波战斗胜利！已通关! chapterID=%s,levelNum=%s,nextChapterID=%s,nextLevelNum=%s"
			% (chapterID, levelNum, nextChapterID, nextLevelNum), playerID)
			isAllPass = True

			updPassValue = PlayerControl.SetMainLevelPassInfo(curPlayer, nextChapterID, nextLevelNum, 0)
			if isAllPass:
			# 已通关的刷怪进度保持不变
			updNowValue = PlayerControl.GetMainLevelNowValue(curPlayer)
			GameWorld.DebugLog("已通关的刷怪进度保持不变: updNowValue=%s" % updNowValue, playerID)
			else:
			updNowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, nextChapterID, nextLevelNum, 1)
			GameWorld.DebugLog("为通关的刷怪进度设置为下一关的第1波: updNowValue=%s" % updNowValue, playerID)
			GameWorld.DebugLog("updPassValue=%s,updNowValue=%s" % (updPassValue, updNowValue), playerID)

			# 发放过关奖励
			levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
			if not levelIpyData:
			return
			itemList = levelIpyData.GetAwardItemList()
			GameWorld.DebugLog("过关奖励: chapterID=%s,levelNum=%s,itemList=%s" % (chapterID, levelNum, itemList), playerID)

			ItemControler.GivePlayerItemOrMail(curPlayer, itemList, event=["MainLevelBoss", False, {}], isNotifyAward=False)

			awardItemList += itemList
			return


			#// B4 14 查看战报 #tagCSTurnFightReportView
			#
			@@ -1920,4 +1671,27 @@
			# char GUID[40]; //战报guid
			#};
			def OnTurnFightReportView(index, clientData, tick):
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			guid = clientData.GUID

			lastBatBufferInfo = PlayerOnline.GetOnlinePlayer(curPlayer).GetLastBatBuffer()
			if lastBatBufferInfo and len(lastBatBufferInfo) == 2 and guid == lastBatBufferInfo[0]:
			guid, reprot = lastBatBufferInfo
			SyncTurnFightReport(curPlayer, guid, reprot)
			return

			# 其他战报，一般是入库存储的，待扩展

			# 战报已过期
			PlayerControl.NotifyCode(curPlayer, "FightReportExpired")
			return

			def SyncTurnFightReport(curPlayer, guid, reprot):
			## 通知完整战报
			clientPack = ChPyNetSendPack.tagSCTurnFightReport()
			clientPack.GUID = guid
			clientPack.Report = reprot
			clientPack.Len = len(clientPack.Report)
			NetPackCommon.SendFakePack(curPlayer, clientPack)
			return