SnxxServerCode.git

			@@ -18,10 +18,11 @@
			import GameWorld
			import PlayerControl
			import CrossRealmMsg
			import DataRecordPack
			import ChPyNetSendPack
			import CrossRealmPlayer
			import PyGameDataStruct
			import PlayerDBGSEvent
			import CrossBillboard
			import PyDataManager
			import NetPackCommon
			import IpyGameDataPY
			@@ -34,45 +35,7 @@
			import operator
			import random
			import time

			class CrossPKPlayer():
			## 跨服PK玩家类

			def __init__(self):
			self.accID = ""
			self.playerID = 0
			self.playerName = ""
			self.playerJob = 0
			self.playerLV = 0
			self.maxHP = 0
			self.fightPower = 0
			self.realmLV = 0
			self.pkScore = 0
			self.danLV = 0
			self.matchTick = 0
			self.cWinCount = 0 # 连胜次数
			self.ondayScore = 0 # 过天时的积分
			self.serverGroupID = 0 # 所属服务器ID，一个服务器ID由多个服组成
			self.pkZoneID = 0 # 所属赛区ID，一个赛区由多个服务器ID组成
			self.seasonID = 0 # 赛季ID
			return

			class CrossPKRoom():
			## 跨服PK房间类

			def __init__(self):
			self.pkZoneID = 0
			self.seasonID = 0
			self.roomID = 0
			self.mapID = 0
			self.openTick = 0 # 开房时间
			self.readyTick = 0 # 玩家都准备好的时间
			self.roomState = ShareDefine.Def_VsRoom_State_WaitPlayer # 默认状态
			self.roomPlayerIDList = [] # 对战玩家ID列表
			self.readyPlayerIDList = [] # 已经准备好的玩家ID列表
			self.isMapOpen = False # 地图是否已经开启该房间，未开启的房间超时后，本次匹配视为无效，有玩家进地图才会开启副本分线
			return


			#跨服PK排行榜管理，注意该类只处理数据逻辑，功能相关逻辑不要写在该类，不然重读脚本不会生效
			class CrossPKBillboardManager(object):

			@@ -130,50 +93,34 @@
			if (zoneID, seasonID) not in self.__UnSortZoneSeasonTimeDict:
			self.__UnSortZoneSeasonTimeDict[(zoneID, seasonID)] = GameWorld.GetGameWorld().GetTick()
			return

			## ==================================== 子服的榜单数据管理 =====================================
			def UpdClientServerPKBillboard(self, zoneID, seasonID, syncBillboardList, isFinalBillboardData):
			## 先直接清除本服数据，然后直接覆盖更新
			billboardList = self.GetCrossPKBillboardInfo(zoneID, seasonID)[0]
			billboardList = billboardList[:len(syncBillboardList)] # 直接用本服以后的排行数据实例clear后覆盖更新，不足的创建新实例
			orderDict = {} # 排行信息重新更新
			for i, syncData in enumerate(syncBillboardList):
			playerID, playerName, job, fightPower, realmLV, pkScore, danLV, billTime, order = syncData
			if i < len(billboardList):
			billboardData = billboardList[i]
			billboardData.clear()
			else:
			billboardData = PyGameDataStruct.tagDBCrossPKBillboard()
			billboardList.append(billboardData)
			billboardData.ZoneID = zoneID
			billboardData.SeasonID = seasonID
			billboardData.PlayerID = playerID
			billboardData.PlayerName = playerName
			billboardData.Job = job
			billboardData.FightPower = fightPower
			billboardData.RealmLV = realmLV
			billboardData.PKScore = pkScore
			billboardData.DanLV = danLV
			billboardData.Time = billTime
			orderDict[playerID] = order

			listAttrName = self.__ZoneSeasonDataList % (zoneID, seasonID)
			orderDictAttrName = self.__ZoneSeasonPlayerOrderDict % (zoneID, seasonID)
			setattr(self, listAttrName, billboardList)
			setattr(self, orderDictAttrName, orderDict)
			dbIsFinalData = PlayerDBGSEvent.GetDBGSTrig_ByKey(self.DBKEY_CrossPKFinalBillboardData % (zoneID, seasonID))
			isFinalBillboardData = 1 if isFinalBillboardData else 0
			if dbIsFinalData != isFinalBillboardData:
			PlayerDBGSEvent.SetDBGSTrig_ByKey(self.DBKEY_CrossPKFinalBillboardData % (zoneID, seasonID), isFinalBillboardData)
			GameWorld.Log("更新子服榜单数据是否是最终榜单数据!zoneID=%s,seasonID=%s,isFinalBillboardData=%s"
			% (zoneID, seasonID, isFinalBillboardData))
			return billboardList, orderDict

			def IsFinalBillboardData(self, zoneID, seasonID):
			## 子服的赛区赛季榜单数据是否最终榜单数据
			return PlayerDBGSEvent.GetDBGSTrig_ByKey(self.DBKEY_CrossPKFinalBillboardData % (zoneID, seasonID))

			## ===========================================================================================

			def CopyToCrossBillboard(self):
			toBillboardType = ShareDefine.Def_CBT_CrossRealmPK
			billboardMgr = PyDataManager.GetCrossBillboardManager()
			for zoneID, seasonID in self.__ZoneSeasonList:
			groupValue1, groupValue2 = zoneID, seasonID
			toBillboardObj = billboardMgr.GetCrossBillboard(toBillboardType, groupValue1, groupValue2)
			billboardList = self.GetCrossPKBillboardInfo(zoneID, seasonID)[0]
			GameWorld.Log("CopyToCrossBillboard: zoneID=%s,seasonID=%s,%s" % (zoneID, seasonID, len(billboardList)))
			for billboardData in billboardList:
			tobillboardData = PyGameDataStruct.tagDBCrossBillboard()
			tobillboardData.GroupValue1 = groupValue1
			tobillboardData.GroupValue2 = groupValue2
			tobillboardData.BillboardType = toBillboardType
			tobillboardData.ID = billboardData.PlayerID
			tobillboardData.Name1 = billboardData.PlayerName
			tobillboardData.Type2 = billboardData.Job
			tobillboardData.Value1 = billboardData.RealmLV
			tobillboardData.Value2 = billboardData.DanLV
			tobillboardData.Value3 = billboardData.Face
			tobillboardData.Value4 = billboardData.FacePic
			tobillboardData.CmpValue = billboardData.PKScore
			tobillboardData.CmpValue3 = billboardData.Time
			toBillboardObj.AddBillboardData(tobillboardData)

			self.__ZoneSeasonList = []
			return

			# 保存数据存数据库和realtimebackup
			def GetSaveData(self):
			@@ -186,7 +133,7 @@
			cnt += 1
			savaData += billboardData.getBuffer()

			GameWorld.Log("SaveCrossPKBillboard cnt :%s" % cnt)
			GameWorld.Log("SaveCrossPKBillboard cnt :%s len=%s" % (cnt, len(savaData)))
			return CommFunc.WriteDWORD(cntData, cnt) + savaData

			# 从数据库载入数据
			@@ -210,303 +157,31 @@
			billboardList = self.GetCrossPKBillboardInfo(zoneID, seasonID, True)[0]
			GameWorld.Log(" zoneID=%s, seasonID=%s, count=%s" % (zoneID, seasonID, len(billboardList)))

			self.CopyToCrossBillboard()
			return pos

			def UpdateCrossPKBillboard(zoneID, seasonID, winner, loser):
			## 更新跨服PK排行榜，跨服服务器结算调用，子服不调用

			curZoneSeasonID = GameWorld.GetGameWorld().GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonID % zoneID)
			if curZoneSeasonID != seasonID:
			GameWorld.ErrLog("不是当前赛季，不更新排行榜! zoneID=%s,seasonID=%s,curZoneSeasonID=%s" % (zoneID, seasonID, curZoneSeasonID))
			return
			billboardCfg = IpyGameDataPY.GetFuncEvalCfg("CrossRealmPKCfg", 1, [])
			if not billboardCfg or len(billboardCfg) != 2:
			GameWorld.ErrLog("跨服竞技场排行榜配置错误！")
			return
			maxCount, danLVLimit = billboardCfg
			if maxCount <= 0:
			return
			maxCount = min(2000, maxCount)
			upBillboardList = []
			if winner.danLV >= danLVLimit:
			upBillboardList.append(winner)
			else:
			GameWorld.DebugLog(" 段位不足，无法上榜! winnerDanLV=%s < danLVLimit=%s" % (winner.danLV, danLVLimit), winner.playerID)
			if loser.danLV >= danLVLimit:
			upBillboardList.append(loser)
			else:
			GameWorld.DebugLog(" 段位不足，无法上榜! loserDanLV=%s < danLVLimit=%s" % (loser.danLV, danLVLimit), loser.playerID)
			if not upBillboardList:
			return

			crossPKBillboardMgr = PyDataManager.GetCrossPKBillboardManager()
			billboardList, orderDict = crossPKBillboardMgr.GetCrossPKBillboardInfo(zoneID, seasonID)

			isUpd = False
			curTime = int(time.time())
			billboardTime = max(0, GameWorld.ChangeTimeStrToNum("2080-01-01 00:00:00") - curTime) # 因为先上榜排前面，所以时间记录值得反减，倒序排
			for pkPlayer in upBillboardList:
			playerID = pkPlayer.playerID
			if playerID in orderDict:
			order = orderDict[playerID]
			billboardData = billboardList[order - 1]
			GameWorld.DebugLog(" 已经在榜单上!playerID=%s,order=%s" % (playerID, order), playerID)
			else:
			if len(billboardList) < maxCount:
			newBillboardData = PyGameDataStruct.tagDBCrossPKBillboard()
			billboardList.append(newBillboardData)
			order = len(billboardList)
			GameWorld.DebugLog(" 添加新上榜榜单!playerID=%s,order=%s" % (playerID, order), playerID)
			else:
			lastBillboardData = billboardList[-1]
			# 分数如果超过最后一个，则顶掉最后一个
			if lastBillboardData.PKScore >= pkPlayer.pkScore:
			GameWorld.DebugLog(" PK积分不超过最后一名玩家，无法上榜! pkScore=%s <= lastPKScore=%s"
			% (pkPlayer.pkScore, lastBillboardData.PKScore), playerID)
			continue
			order = orderDict.pop(lastBillboardData.PlayerID, len(billboardList))
			GameWorld.DebugLog(" 顶掉最后一个榜单!playerID=%s,lastPlayer=%s,lastScore=%s,order=%s"
			% (playerID, lastBillboardData.PlayerID, lastBillboardData.PKScore, order))
			newBillboardData = PyGameDataStruct.tagDBCrossPKBillboard()
			billboardList[-1] = newBillboardData
			billboardData = newBillboardData
			orderDict[playerID] = order

			isUpd = True
			# 更新值
			billboardData.ZoneID = zoneID
			billboardData.SeasonID = seasonID
			billboardData.PlayerID = playerID
			billboardData.PlayerName = pkPlayer.playerName
			billboardData.Job = pkPlayer.playerJob
			billboardData.FightPower = pkPlayer.fightPower
			billboardData.RealmLV = pkPlayer.realmLV
			billboardData.PKScore = pkPlayer.pkScore
			billboardData.DanLV = pkPlayer.danLV
			billboardData.Time = billboardTime
			GameWorld.Log(" 更新PK积分排行榜: playerID=%s,pkScore=%s,order=%s" % (playerID, billboardData.PKScore, order), playerID)

			# 战斗结算更新榜单先不排序，只设置需要排序
			if isUpd:
			crossPKBillboardMgr.SetNeedSort(zoneID, seasonID)

			# 如果匹配已经结束，且没有战斗中的房间了，则处理本阶段匹配总结算
			matchState = GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			if not matchState and not PyGameData.g_crossPKRoomDict:
			GameWorld.Log("匹配已结束，且当前没有PK中的房间了！主动广播子服最新榜单! ")
			zoneIpyData = IpyGameDataPY.GetIpyGameData("CrossRealmPKZone", zoneID)
			if zoneIpyData:
			serverGroupIDList = zoneIpyData.GetServerGroupIDList()
			SyncPKSyncBillboardToClientServer(zoneID, seasonID, serverGroupIDList)

			return

			#// C0 01 查看跨服竞技场赛季排行榜 #tagCGViewCrossPKBillboard
			#
			#struct tagCGViewCrossPKBillboard
			#{
			# tagHead Head;
			# BYTE ZoneID; // 赛区ID
			# BYTE SeasonID; // 赛季ID
			#};
			def OnViewCrossPKBillboard(index, clientData, tick):
			''' 赛区赛季榜单同步规则，这里以多台跨服服务器为考虑
			每台跨服服务器单独管理自己关联的子服赛区榜单
			每日匹配结束结算时间点主动同步所有子服本台跨服服务器的所有赛区当前赛季榜单，这样能确保所有子服的赛区榜单是最新的
			匹配期间，子服设置同步CD，如果有玩家查询，则每1分钟可向跨服服务器同步当前赛区赛季最新榜单信息，同步后发送玩家
			非匹配期间，只要子服有数据则可直接发送给玩家，没有的话向跨服服务器同步后再发送玩家
			历史赛季，因为每日跨服服务器都有主动广播，所以历史赛季只要子服有数据则可直接发送给玩家，没有的话向跨服服务器同步后再发送玩家
			赛季结束或历史赛季只要不是最终榜单数据的，则需主动向跨服服务器请求同步数据后再发送玩家
			不同跨服服务器赛区的话由跨服服务器之间自己同步数据，子服只管向自己所属跨服服务器同步数据即可

			跨服服务器与跨服服务器之间的赛区榜单同步，同步规则类似子服与跨服服务器，相互之间做好数据同步即可
			数据同步后再同步各自所有子服，确保子服也是最新的，可考虑匹配结算结束同步一次即可
			这样玩家查看其它跨服服务器赛区数据可能会延迟一次匹配阶段结算的时间，比如两个小时，这个等以后需要多台跨服服务器时再讨论
			'''
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			if GameWorld.IsCrossServer():
			return
			playerID = curPlayer.GetPlayerID()
			zoneID, seasonID = clientData.ZoneID, clientData.SeasonID
			tickKey = ChConfig.Def_PlayerKey_ViewCrossPKBillboardTick % (zoneID, seasonID)
			if tick - curPlayer.GetDictByKey(tickKey) < 60000:
			GameWorld.DebugLog("玩家查询跨服PK排行榜CD中: zoneID=%s, seasonID=%s" % (zoneID, seasonID), playerID)
			return
			curPlayer.SetDict(tickKey, tick)
			gameWorld = GameWorld.GetGameWorld()
			serverZoneID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)

			crossPKBillboardMgr = PyDataManager.GetCrossPKBillboardManager()
			billboardList = crossPKBillboardMgr.GetCrossPKBillboardInfo(zoneID, seasonID)[0]
			isFinalBillboardData = crossPKBillboardMgr.IsFinalBillboardData(zoneID, seasonID)

			GameWorld.DebugLog("玩家请求查看跨服PK排行榜: zoneID=%s,seasonID=%s,serverZoneID=%s,isFinalBillboardData=%s"
			% (zoneID, seasonID, serverZoneID, isFinalBillboardData))

			# 本服赛区
			if zoneID == serverZoneID:
			curSeasonID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
			seasonState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)

			# 其他赛区
			else:
			serverTime = GameWorld.GetServerTime()
			curSeasonID = 0
			seasonState = 0
			seasonList = IpyGameDataPY.GetIpyGameDataList("CrossRealmPKSeason", zoneID)
			seasonList = [] if not seasonList else seasonList
			for seasonIpyData in seasonList:
			startDateStr = seasonIpyData.GetStartDate()
			endDateStr = seasonIpyData.GetEndDate()
			endTimeStr = seasonIpyData.GetEndTime()

			startDateTime = datetime.datetime.strptime("%s 00:00:00" % (startDateStr), ChConfig.TYPE_Time_Format)
			endDateTime = datetime.datetime.strptime("%s %s:00" % (endDateStr, endTimeStr), ChConfig.TYPE_Time_Format)
			if serverTime < startDateTime:
			break
			if serverTime <= endDateTime:
			curSeasonID = seasonIpyData.GetSeasonID()
			seasonState = 1
			else:
			break

			# 查询当前进行中的赛季
			if seasonID == curSeasonID:
			matchState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			# 非匹配中的
			if not matchState:
			# 最终数据 or 赛季进行中直接同步
			if isFinalBillboardData or (seasonState == 1 and billboardList):
			SyncCrossPKBillboard(curPlayer, zoneID, seasonID, billboardList)
			return

			# 正在匹配中的，验证本服数据同步CD，暂定1分钟同步一次
			else:
			syncTickKey = ChConfig.Def_WorldKey_CrossPKBillboardSyncTick % (zoneID, seasonID)
			if matchState and billboardList and tick - gameWorld.GetDictByKey(syncTickKey) < 60000:
			SyncCrossPKBillboard(curPlayer, zoneID, seasonID, billboardList)
			return
			gameWorld.SetDict(syncTickKey, tick)

			# 查询历史赛季的
			else:
			# 如果是最终数据则直接同步
			if isFinalBillboardData and billboardList:
			SyncCrossPKBillboard(curPlayer, zoneID, seasonID, billboardList)
			return

			# 请求查询跨服服务器
			dataMsg = {"ZoneID":zoneID, "SeasonID":seasonID, "ExData":{"EventName":"View", "PlayerID":playerID}}
			CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_PKBillboard, dataMsg)
			return

			def MapServer_QueryCrossPKSeasonOrder(curPlayer, msgList):
			## 地图服务器查询玩家赛区赛季PK榜排名
			playerID = curPlayer.GetPlayerID()
			zoneID, seasonID, eventName, eventData = msgList
			crossPKBillboardMgr = PyDataManager.GetCrossPKBillboardManager()
			billboardList, orderDict = crossPKBillboardMgr.GetCrossPKBillboardInfo(zoneID, seasonID) # 子服的数据一定是排完序同步过来的，所以这里就不需要再排序了
			if not billboardList:
			# 本服没榜单数据，查询跨服服务器
			# 请求查询跨服服务器
			dataMsg = {"ZoneID":zoneID, "SeasonID":seasonID, "ExData":{"EventName":eventName, "PlayerID":playerID, "EventData":eventData}}
			CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_PKBillboard, dataMsg)
			return

			order = orderDict.get(playerID, 0)
			sysMsg = str([zoneID, seasonID, eventName, eventData, order])
			curPlayer.MapServer_QueryPlayerResult(0, 0, "CrossPKSeasonOrder", sysMsg, len(sysMsg))
			funcData = {"zoneID":zoneID, "seasonID":seasonID, "eventName":eventName, "eventData":eventData}
			CrossBillboard.OnQueryPlayerBillboardRank(playerID, "QueryCrossPKSeasonOrder", funcData, ShareDefine.Def_CBT_CrossRealmPK, zoneID, seasonID)
			return

			def ClientServerMsg_PKBillboard(serverGroupID, msgData):
			## 收到子服请求查询PK排行榜信息
			zoneID = msgData["ZoneID"]
			seasonID = msgData["SeasonID"]
			exData = msgData.get("ExData", {}) # 原数据返回子服
			SyncPKSyncBillboardToClientServer(zoneID, seasonID, [serverGroupID], exData)
			return

			def SyncPKSyncBillboardToClientServer(zoneID, seasonID, serverGroupIDList, exData={}):
			## 同步赛区赛季榜单到子服
			crossPKBillboardMgr = PyDataManager.GetCrossPKBillboardManager()
			billboardList, orderDict = crossPKBillboardMgr.GetCrossPKBillboardInfo(zoneID, seasonID, True) # 同步子服前需触发排序
			isFinalBillboardData = False # 是否最终的榜单数据
			gameWorld = GameWorld.GetGameWorld()
			curZoneSeasonID = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonID % zoneID)
			if seasonID < curZoneSeasonID:
			isFinalBillboardData = True # 历史赛季在跨服服务器中的一定是最终榜单数据
			elif seasonID == curZoneSeasonID:
			seasonState = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonState % zoneID)
			if seasonState == 2:
			isFinalBillboardData = True # 当前赛季已经是赛季结算状态的了，代表是最终榜单数据

			syncBillboardList = []
			for billboardData in billboardList:
			playerID = billboardData.PlayerID
			playerName = billboardData.PlayerName
			job = billboardData.Job
			fightPower = billboardData.FightPower
			realmLV = billboardData.RealmLV
			pkScore = billboardData.PKScore
			danLV = billboardData.DanLV
			billTime = billboardData.Time
			order = orderDict.get(playerID, 0)
			syncBillboardList.append([playerID, playerName, job, fightPower, realmLV, pkScore, danLV, billTime, order])

			syncInfo = [zoneID, seasonID, syncBillboardList, exData, isFinalBillboardData]
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKSyncBillboard, syncInfo, serverGroupIDList)
			return

			def CrossServerMsg_PKSyncBillboard(syncInfo):
			## 收到跨服服务器同步的排行榜信息
			zoneID, seasonID, syncBillboardList, exData, isFinalBillboardData = syncInfo
			GameWorld.Log("收到跨服服务器同步的排行榜信息: zoneID=%s,seasonID=%s,billboardDataCount=%s,exData=%s,isFinalBillboardData=%s"
			% (zoneID, seasonID, len(syncBillboardList), exData, isFinalBillboardData))

			crossPKBillboardMgr = PyDataManager.GetCrossPKBillboardManager()
			billboardList, orderDict = crossPKBillboardMgr.UpdClientServerPKBillboard(zoneID, seasonID, syncBillboardList, isFinalBillboardData)
			if not exData:
			return
			eventName = exData.get("EventName")
			eventData = exData.get("EventData")
			queryPlayerID = exData.get("PlayerID", 0)
			if not eventName or not queryPlayerID:
			return

			queryPlayer = GameWorld.GetPlayerManager().FindPlayerByID(queryPlayerID)
			def OnQueryCrossPKSeasonOrderRet(playerID, funcData, orderIndex):
			## 查询排名返回
			queryPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			if not queryPlayer:
			return

			if eventName == "View":
			SyncCrossPKBillboard(queryPlayer, zoneID, seasonID, billboardList)
			else:
			order = orderDict.get(queryPlayerID, 0)
			sysMsg = str([zoneID, seasonID, eventName, eventData, order])
			queryPlayer.MapServer_QueryPlayerResult(0, 0, "CrossPKSeasonOrder", sysMsg, len(sysMsg))

			zoneID = funcData["zoneID"]
			seasonID = funcData["seasonID"]
			eventName = funcData["eventName"]
			eventData = funcData["eventData"]
			order = orderIndex + 1
			sysMsg = str([zoneID, seasonID, eventName, eventData, order])
			queryPlayer.MapServer_QueryPlayerResult(0, 0, "CrossPKSeasonOrder", sysMsg, len(sysMsg))
			return

			def SyncCrossPKBillboard(curPlayer, zoneID, seasonID, billboardList):
			## 同步给玩家跨服PK榜单
			billboardInfo = ChPyNetSendPack.tagGCCrossRealmPKBillboardInfo()
			billboardInfo.ZoneID = zoneID
			billboardInfo.SeasonID = seasonID
			billboardInfo.PKBillboardList = []
			for billboardData in billboardList:
			billboardInfoData = ChPyNetSendPack.tagGCCrossRealmPKBillboardData()
			billboardInfoData.PlayerID = billboardData.PlayerID
			billboardInfoData.PlayerName = billboardData.PlayerName
			billboardInfoData.NameLen = len(billboardInfoData.PlayerName)
			billboardInfoData.Job = billboardData.Job
			billboardInfoData.FightPower = billboardData.FightPower
			billboardInfoData.RealmLV = billboardData.RealmLV
			billboardInfoData.PKScore = billboardData.PKScore
			billboardInfoData.DanLV = billboardData.DanLV
			billboardInfo.PKBillboardList.append(billboardInfoData)
			billboardInfo.Count = len(billboardInfo.PKBillboardList)
			NetPackCommon.SendFakePack(curPlayer, billboardInfo)
			return

			################################################################################

			def __GetCrossPKZoneSeasonTimeInfo():
			@@ -522,18 +197,19 @@

			zoneSeasonTimeDict = {}
			serverTime = GameWorld.GetServerTime()
			ipyDataMgr = IpyGameDataPY.IPY_Data()
			for index in xrange(ipyDataMgr.GetCrossRealmPKZoneCount()):
			zoneIpyData = ipyDataMgr.GetCrossRealmPKZoneByIndex(index)
			crossZoneName = GameWorld.GetCrossZoneName()
			crossZoneList = IpyGameDataPY.GetIpyGameDataByCondition("CrossZonePK", {"CrossZoneName":crossZoneName}, True)
			if not crossZoneList:
			return zoneSeasonTimeDict

			for zoneIpyData in crossZoneList:
			zoneID = zoneIpyData.GetZoneID()

			# 规定每个赛区的赛季时间需按顺序配置
			seasonIpyDataList = []
			for sIndex in xrange(ipyDataMgr.GetCrossRealmPKSeasonCount()):
			seasonIpyData = ipyDataMgr.GetCrossRealmPKSeasonByIndex(sIndex)
			if zoneID == seasonIpyData.GetZoneID():
			seasonIpyDataList.append(seasonIpyData)

			seasonIpyDataList = IpyGameDataPY.GetIpyGameDataList("CrossRealmPKSeason", crossZoneName, zoneID)
			if not seasonIpyDataList:
			continue

			for i, seasonIpyData in enumerate(seasonIpyDataList):
			seasonID = seasonIpyData.GetSeasonID()
			startDateStr = seasonIpyData.GetStartDate()
			@@ -591,8 +267,9 @@

			gameWorld = GameWorld.GetGameWorld()
			serverTime = GameWorld.GetServerTime()
			crossZoneName = GameWorld.GetCrossZoneName()
			for zoneID, seasonTimeInfo in zoneSeasonTimeDict.items():
			zoneIpyData = IpyGameDataPY.GetIpyGameData("CrossRealmPKZone", zoneID)
			zoneIpyData = IpyGameDataPY.GetIpyGameData("CrossZonePK", crossZoneName, zoneID)
			if not zoneIpyData:
			continue

			@@ -626,9 +303,9 @@
			GameWorld.Log("跨服PK赛季状态变更: zoneID=%s,seasonID=%s,seasonState=%s" % (zoneID, seasonID, seasonState))

			serverGroupIDList = zoneIpyData.GetServerGroupIDList()
			# 赛季总结算，为确保子服榜单的实时性，这里需再同步子服最终榜单信息，需在同步赛季状态之前同步
			# 赛季结束
			if seasonState == 2:
			SyncPKSyncBillboardToClientServer(zoneID, seasonID, serverGroupIDList)
			PyGameData.g_crossPKMatchDict = {}

			# 广播当前赛区的所有子服跨服PK赛季状态变更
			matchState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			@@ -644,11 +321,19 @@
			return

			gameWorld = GameWorld.GetGameWorld()
			preState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK, isOpen)

			ipyDataMgr = IpyGameDataPY.IPY_Data()
			for index in xrange(ipyDataMgr.GetCrossRealmPKZoneCount()):
			zoneIpyData = ipyDataMgr.GetCrossRealmPKZoneByIndex(index)
			# 匹配状态从关闭到开启
			if not preState and isOpen:
			GameWorld.Log("跨服PK匹配状态开启，重置相关匹配数据!")

			crossZoneName = GameWorld.GetCrossZoneName()
			crossZoneList = IpyGameDataPY.GetIpyGameDataByCondition("CrossZonePK", {"CrossZoneName":crossZoneName}, True)
			if not crossZoneList:
			return

			for zoneIpyData in crossZoneList:
			zoneID = zoneIpyData.GetZoneID()

			# 广播当前赛区的所有子服跨服PK赛季状态变更
			@@ -661,115 +346,95 @@

			return

			def ClientServerMsg_ServerInitOK(serverGroupID, tick):
			## 子服启动成功
			GameWorld.Log("子服启动成功，同步给子服对应的赛季信息: serverGroupID=%s" % (serverGroupID))
			zoneID = GetCrossPKServerGroupZoneID(serverGroupID)
			if not zoneID:
			GameWorld.Log(" 该子服没有分配赛区，不同步!")
			def Sync_CrossPKInitDataToClientServer(tick, serverGroupID=0):
			''' 同步跨服PK活动数据到子服务器
			@param serverGroupID: 为0时同步所有子服
			'''

			GameWorld.Log("同步给子服对应的赛季信息: syncServerGroupID=%s" % (serverGroupID))
			if serverGroupID:
			ipyData = GetCrossPKServerGroupZone(serverGroupID)
			if not ipyData:
			return
			crossZoneList = [ipyData]
			else:
			crossZoneName = GameWorld.GetCrossZoneName()
			crossZoneList = IpyGameDataPY.GetIpyGameDataByCondition("CrossZonePK", {"CrossZoneName":crossZoneName}, True)
			if not crossZoneList:
			return
			gameWorld = GameWorld.GetGameWorld()
			seasonID = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonID % zoneID)
			seasonState = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonState % zoneID)
			matchState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			seasonInfo = {"ZoneID":zoneID, "SeasonID":seasonID, "SeasonState":seasonState, "MatchState":matchState}
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKSeasonInfo, seasonInfo, [serverGroupID])
			for zoneIpyData in crossZoneList:
			zoneID = zoneIpyData.GetZoneID()
			seasonID = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonID % zoneID)
			seasonState = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonState % zoneID)
			matchState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			seasonInfo = {"ZoneID":zoneID, "SeasonID":seasonID, "SeasonState":seasonState, "MatchState":matchState}
			serverGroupIDList = [serverGroupID] if serverGroupID else zoneIpyData.GetServerGroupIDList()
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKSeasonInfo, seasonInfo, serverGroupIDList)

			return

			def GetCrossPKServerGroupZoneID(serverGroupID):
			def GetCrossPKServerGroupZone(serverGroupID):
			## 获取服务器组ID对应的跨服PK所属赛区，返回0代表该服务器没有分配赛区
			ipyDataMgr = IpyGameDataPY.IPY_Data()
			for index in xrange(ipyDataMgr.GetCrossRealmPKZoneCount()):
			zoneIpyData = ipyDataMgr.GetCrossRealmPKZoneByIndex(index)
			crossZoneName = GameWorld.GetCrossZoneName()
			crossZoneList = IpyGameDataPY.GetIpyGameDataByCondition("CrossZonePK", {"CrossZoneName":crossZoneName}, True)
			if not crossZoneList:
			return

			for zoneIpyData in crossZoneList:
			for groupInfo in zoneIpyData.GetServerGroupIDList():
			if (isinstance(groupInfo, int) and serverGroupID == groupInfo) \
			or (isinstance(groupInfo, tuple) and len(groupInfo) == 2 and groupInfo[0] <= serverGroupID <= groupInfo[1]):
			return zoneIpyData.GetZoneID()
			return 0

			def OnPlayerLogin(curPlayer):

			# 本服登录处理
			if not GameWorld.IsCrossServer():
			# 本服没有分配赛区不处理
			if not GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID):
			return
			__OnLoginNotifyPKOverInfo(curPlayer)

			# 同步所有赛区赛季信息
			zoneSeasonInfo = ChPyNetSendPack.tagGCCrossRealmPKSeasonInfo()
			zoneSeasonInfo.ZoneList = []
			ipyDataMgr = IpyGameDataPY.IPY_Data()
			for index in xrange(ipyDataMgr.GetCrossRealmPKZoneCount()):
			zoneIpyData = ipyDataMgr.GetCrossRealmPKZoneByIndex(index)
			zoneID = zoneIpyData.GetZoneID()
			zoneInfo = ChPyNetSendPack.tagGCCrossRealmPKZone()
			zoneInfo.ZoneID = zoneID
			zoneInfo.ZoneName = zoneIpyData.GetZoneName().decode(ShareDefine.Def_Game_Character_Encoding).encode(GameWorld.GetCharacterEncoding())
			zoneInfo.ZoneNameLen = len(zoneInfo.ZoneName)
			zoneInfo.SeasonList = []
			seasonList = IpyGameDataPY.GetIpyGameDataList("CrossRealmPKSeason", zoneID)
			seasonList = [] if not seasonList else seasonList
			for seasonIpyData in seasonList:
			seasonInfo = ChPyNetSendPack.tagGCCrossRealmPKSeason()
			seasonInfo.SeasonID = seasonIpyData.GetSeasonID()
			seasonInfo.StartDate = seasonIpyData.GetStartDate()
			seasonInfo.EndDate = seasonIpyData.GetEndDate()
			seasonInfo.EndTime = seasonIpyData.GetEndTime()
			zoneInfo.SeasonList.append(seasonInfo)
			zoneInfo.SeasonCount = len(zoneInfo.SeasonList)
			zoneSeasonInfo.ZoneList.append(zoneInfo)
			zoneSeasonInfo.ZoneCount = len(zoneSeasonInfo.ZoneList)
			NetPackCommon.SendFakePack(curPlayer, zoneSeasonInfo)

			# 同步本服赛季状态
			gameWorld = GameWorld.GetGameWorld()
			seasonStatePack = ChPyNetSendPack.tagGCCrossRealmPKSeasonState()
			seasonStatePack.ZoneID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)
			seasonStatePack.SeasonID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
			seasonStatePack.SeasonState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)
			seasonStatePack.MatchState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			NetPackCommon.SendFakePack(curPlayer, seasonStatePack)

			# 跨服登录处理
			else:
			mapID = curPlayer.GetMapID()
			mapIDList = IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch", 4)
			if mapID not in mapIDList:
			return

			GameWorld.Log("玩家登录跨服PK地图, mapID=%s" % mapID, curPlayer.GetPlayerID())
			if not __CheckCanLoginCrossServerPKMap(curPlayer):
			CrossRealmPlayer.PlayerExitCrossServer(curPlayer)
			return

			return zoneIpyData
			return

			def __CheckCanLoginCrossServerPKMap(curPlayer):
			# 检查玩家可否登录跨服PK房间
			def OnPlayerLogin(curPlayer):
			# 本服登录处理

			playerID = curPlayer.GetPlayerID()
			vsRoomID = curPlayer.GetVsRoomId()
			if not vsRoomID:
			GameWorld.ErrLog("玩家没有对战房间ID，不可进入对战地图! 强制踢出跨服服务器!", playerID)
			return False
			# 本服没有分配赛区不处理
			if not GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID):
			return
			__OnLoginNotifyPKOverInfo(curPlayer)

			if vsRoomID not in PyGameData.g_crossPKRoomDict:
			GameWorld.ErrLog("玩家对战房间ID已经不存在，不可进入对战地图! 强制踢出跨服服务器!vsRoomID=%s" % vsRoomID, playerID)
			return False
			crossZoneName = GameWorld.GetCrossZoneName()
			crossZoneList = IpyGameDataPY.GetIpyGameDataByCondition("CrossZonePK", {"CrossZoneName":crossZoneName}, True)
			if not crossZoneList:
			return
			# 同步所有赛区赛季信息
			zoneSeasonInfo = ChPyNetSendPack.tagGCCrossRealmPKSeasonInfo()
			zoneSeasonInfo.ZoneList = []
			for zoneIpyData in crossZoneList:
			zoneID = zoneIpyData.GetZoneID()
			zoneInfo = ChPyNetSendPack.tagGCCrossRealmPKZone()
			zoneInfo.ZoneID = zoneID
			zoneInfo.ZoneName = zoneIpyData.GetZoneName().decode(ShareDefine.Def_Game_Character_Encoding).encode(GameWorld.GetCharacterEncoding())
			zoneInfo.ZoneNameLen = len(zoneInfo.ZoneName)
			zoneInfo.SeasonList = []
			seasonList = IpyGameDataPY.GetIpyGameDataList("CrossRealmPKSeason", crossZoneName, zoneID)
			seasonList = [] if not seasonList else seasonList
			for seasonIpyData in seasonList:
			seasonInfo = ChPyNetSendPack.tagGCCrossRealmPKSeason()
			seasonInfo.SeasonID = seasonIpyData.GetSeasonID()
			seasonInfo.StartDate = seasonIpyData.GetStartDate()
			seasonInfo.EndDate = seasonIpyData.GetEndDate()
			seasonInfo.EndTime = seasonIpyData.GetEndTime()
			zoneInfo.SeasonList.append(seasonInfo)
			zoneInfo.SeasonCount = len(zoneInfo.SeasonList)
			zoneSeasonInfo.ZoneList.append(zoneInfo)
			zoneSeasonInfo.ZoneCount = len(zoneSeasonInfo.ZoneList)
			NetPackCommon.SendFakePack(curPlayer, zoneSeasonInfo)

			vsRoom = PyGameData.g_crossPKRoomDict[vsRoomID]
			if playerID not in vsRoom.roomPlayerIDList:
			GameWorld.ErrLog("玩家对战房间ID不存在该玩家ID，不可进入对战地图! 强制踢出跨服服务器!vsRoomID=%s,roomPlayerIDList=%s"
			% (vsRoomID, vsRoom.roomPlayerIDList), playerID)
			return False

			return True

			## 玩家离线处理
			def OnLeaveServer(curPlayer):
			# 发送取消匹配
			SendCancelCrossRealmPKMatch(curPlayer, "PlayerDisconnect")
			# 同步本服赛季状态
			gameWorld = GameWorld.GetGameWorld()
			seasonStatePack = ChPyNetSendPack.tagGCCrossRealmPKSeasonState()
			seasonStatePack.ZoneID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)
			seasonStatePack.SeasonID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
			seasonStatePack.SeasonState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)
			seasonStatePack.MatchState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
			seasonStatePack.CrossZoneName = GameWorld.GetCrossZoneName()
			seasonStatePack.CrossZoneNameLen = len(seasonStatePack.CrossZoneName)
			NetPackCommon.SendFakePack(curPlayer, seasonStatePack)

			return

			def IsCrossRealmPKMatchState():
			@@ -777,658 +442,288 @@
			return GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState \
			% ShareDefine.DailyActionID_CrossReamPK) == ChConfig.Def_Action_Open

			def SendCancelCrossRealmPKMatch(curPlayer, reason):
			## 发送取消匹配
			def ClientServerMsg_PKMatch(serverGroupID, playerInfoDict, tick):
			## 请求匹配
			seasonID = playerInfoDict["seasonID"] # 赛季ID
			zoneID = playerInfoDict["zoneID"] # 所属赛区

			# 跨服服务器不处理
			playerID = playerInfoDict["playerID"] # 角色ID
			fightPower = playerInfoDict["fightPower"]
			requestType = playerInfoDict.get("requestType", 0)

			isRefresh = requestType == 1
			OnRefreshPKMatch(zoneID, seasonID, playerID, fightPower, serverGroupID, isRefresh)
			return

			def ClientServerMsg_PKOver(serverGroupID, playerInfoDict, tick):
			## 收到子服同步的PK结算

			playerID = playerInfoDict["playerID"] # 角色ID
			tagPlayerID = playerInfoDict["tagPlayerID"] # 目标玩家ID
			isWinner = playerInfoDict["isWinner"] # 是否获胜
			zoneID = playerInfoDict["pkZoneID"]
			seasonID = playerInfoDict["seasonID"]
			playerName = playerInfoDict["playerName"]
			playerJob = playerInfoDict["playerJob"]
			face = playerInfoDict["face"]
			facePic = playerInfoDict["facePic"]
			realmLV = playerInfoDict["realmLV"]
			fightPower = playerInfoDict["fightPower"]
			pkScore = playerInfoDict["pkScore"]
			danLV = playerInfoDict["danLV"]
			cWinCount = playerInfoDict["cWinCount"]

			if playerID not in PyGameData.g_crossPKMatchDict:
			GameWorld.ErrLog("玩家匹配，无法结算跨服PK奖励! tagPlayerID=%s,isWinner=%s,pkScore=%s,cWinCount=%s"
			% (tagPlayerID, isWinner, pkScore, cWinCount), playerID)
			return
			matchIDList = PyGameData.g_crossPKMatchDict[playerID]
			if tagPlayerID not in matchIDList:
			GameWorld.ErrLog("目标玩家ID不在玩家匹配列表里，无法结算跨服PK奖励! tagPlayerID=%s not in %s ,isWinner=%s,pkScore=%s,cWinCount=%s"
			% (tagPlayerID, matchIDList, isWinner, pkScore, cWinCount), playerID)
			return
			matchIndex = matchIDList.index(tagPlayerID)

			addScore = IpyGameDataPY.GetFuncCfg("CrossRealmPKScore2", 2) # 默认失败积分
			if isWinner:
			baseScoreList = IpyGameDataPY.GetFuncEvalCfg("CrossRealmPKScore2", 1)
			baseScore = baseScoreList[matchIndex] if len(baseScoreList) > matchIndex else 0
			wExScore = eval(IpyGameDataPY.GetFuncCompileCfg("CrossRealmPKScore2", 3)) # 胜方附加分
			addScore = baseScore + wExScore
			cWinCount += 1
			else:
			cWinCount = 0

			updScore = pkScore + addScore
			pkDanIpyData = IpyGameDataPY.GetIpyGameData("CrossRealmPKDan", danLV)
			if pkDanIpyData and pkDanIpyData.GetLVUpScore() and updScore >= pkDanIpyData.GetLVUpScore():
			danLV += 1

			GameWorld.Log("结算跨服PK奖励: tagPlayerID=%s,isWinner=%s,pkScore=%s,cWinCount=%s,addScore=%s,updScore=%s,danLV=%s"
			% (tagPlayerID, isWinner, pkScore, cWinCount, addScore, updScore, danLV), playerID)

			# 更新榜单
			groupValue1, groupValue2 = zoneID, seasonID
			name2, type2 = "", playerJob
			value1, value2 = realmLV, danLV
			cmpValue = updScore
			CrossBillboard.UpdCrossBillboard(ShareDefine.Def_CBT_CrossRealmPK, groupValue1, playerID, playerName, name2, type2,
			value1, value2, cmpValue, groupValue2=groupValue2, value3=face, value4=facePic)

			# 通知子服
			pkScore = updScore
			packDataMgr = PyDataManager.GetDBPlayerPackDataManager()
			tagPackObj = packDataMgr.GetPlayerPackObj(tagPlayerID)
			tagPlayerName = tagPackObj.playerName if tagPackObj else ""
			winnerID = playerID if isWinner else tagPlayerID
			timeStr = GameWorld.GetCurrentDataTimeStr()
			playerOverDict = {}
			playerOverDict[playerID] = [zoneID, seasonID, timeStr, winnerID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName]
			serverGroupIDList = [serverGroupID]
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKOverInfo, playerOverDict, serverGroupIDList)

			# 系统重新刷新匹配
			OnRefreshPKMatch(zoneID, seasonID, playerID, fightPower, serverGroupID, True)
			return

			def OnRefreshPKMatch(zoneID, seasonID, playerID, fightPower, serverGroupID, isRefresh):
			# 刷新匹配数据
			# @param isRefresh: 是否强制重新刷新

			if isRefresh or playerID not in PyGameData.g_crossPKMatchDict:
			# 执行匹配逻辑
			matchIDList = __DoPKMatch(zoneID, seasonID, playerID, fightPower)
			if matchIDList: # 有新结果才替换
			PyGameData.g_crossPKMatchDict[playerID] = matchIDList

			packDataMgr = PyDataManager.GetDBPlayerPackDataManager()
			matchIDList = PyGameData.g_crossPKMatchDict.get(playerID, [])
			matchInfoDict = {}
			for matchID in matchIDList:
			packObj = packDataMgr.GetPlayerPackObj(matchID)
			if not packObj:
			continue
			matchInfoDict[matchID] = packObj.GetBaseDict()

			dataMsg = {"playerID":playerID, "matchIDList":matchIDList, "matchInfoDict":matchInfoDict}
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKMatchReqRet, dataMsg, [serverGroupID])
			return

			def __DoPKMatch(zoneID, seasonID, playerID, fightPower):
			## 执行匹配

			if not IsCrossRealmPKMatchState():
			GameWorld.DebugLog("非匹配阶段，不允许刷新匹配! zoneID=%s,seasonID=%s" % (zoneID, seasonID), playerID)
			return

			matchCount = IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch3", 1)
			rankRange = IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch3", 2) # 名次范围段
			totalRange = rankRange * matchCount # 总匹配名次范围

			matchIDList = [] # 匹配ID结果列表

			billboardType = ShareDefine.Def_CBT_CrossRealmPK
			groupValue1, groupValue2 = zoneID, seasonID
			billboardMgr = PyDataManager.GetCrossBillboardManager()
			billboardObj = billboardMgr.GetCrossBillboard(billboardType, groupValue1, groupValue2)
			billDataCount = billboardObj.GetCount()
			playerBillIndex = billboardObj.IndexOfByID(playerID)

			GameWorld.DebugLog("===执行匹配: zoneID=%s,seasonID=%s,playerID=%s,fightPower=%s,playerBillIndex=%s,matchCount=%s"
			% (zoneID, seasonID, playerID, fightPower, playerBillIndex, matchCount), playerID)
			if playerBillIndex <= 0:
			playerBillIndex = billDataCount
			GameWorld.DebugLog("玩家未上积分榜，视为排在榜上最后一名之后! playerBillIndex=%s" % playerBillIndex, playerID)
			billStartIndex = max(0, playerBillIndex - totalRange / 2) # 以自己的排名为中心索引
			billLoopIndexList = range(billStartIndex, billStartIndex + totalRange + 1)
			if playerBillIndex in billLoopIndexList:
			billLoopIndexList.remove(playerBillIndex) # 移除自己
			loopBillPlayerIDList = []
			for index in billLoopIndexList:
			if index >= billDataCount:
			break
			billData = billboardObj.At(index)
			loopBillPlayerIDList.append(int(billData.ID))
			GameWorld.DebugLog("积分榜可匹配的排名玩家ID列表: %s,%s" % (len(loopBillPlayerIDList), loopBillPlayerIDList), playerID)
			randPackPlayerIDList = None # 可随机匹配的打包数据战力排名玩家ID列表

			haveRobot = False
			for matchIndex in range(matchCount):
			GameWorld.DebugLog("匹配第%s个: matchIndex=%s,playerBillIndex=%s,billLoopIndexList=%s" % (matchIndex + 1, matchIndex, playerBillIndex, billLoopIndexList), playerID)
			matchID = 0
			randIDList = []
			# 1. 优先赛季积分排行榜
			if billDataCount:
			__addRandMatchID(playerID, matchIndex, rankRange, randIDList, matchIDList, loopBillPlayerIDList, 1)

			# 有需要用到战力匹配的，加载一次
			if not randIDList and randPackPlayerIDList == None:
			zonePackPlayerIDList = __getZonePackPlayerIDList(zoneID, playerID)
			playerPackIndex = -1
			randPackPlayerIDList = []
			if playerID in zonePackPlayerIDList:
			playerPackIndex = zonePackPlayerIDList.index(playerID)
			startIndex = max(0, playerPackIndex - totalRange / 2) # 以自己的排名为中心索引
			randPackPlayerIDList = [int(packID) for packID in zonePackPlayerIDList[startIndex:totalRange + 1]] # 因为包含自己，所以加1
			if playerID in randPackPlayerIDList:
			randPackPlayerIDList.remove(playerID) # 移除自己
			GameWorld.DebugLog(" 赛区战力榜玩家排名: playerPackIndex=%s,%s,%s" % (playerPackIndex, len(zonePackPlayerIDList), zonePackPlayerIDList), playerID)
			GameWorld.DebugLog(" 赛区战力榜随机玩家: %s,%s" % (len(randPackPlayerIDList), randPackPlayerIDList), playerID)

			# 2. 该范围段没有的话匹配打包数据战力榜
			if not randIDList and randPackPlayerIDList:
			__addRandMatchID(playerID, matchIndex, rankRange, randIDList, matchIDList, randPackPlayerIDList, 2)

			if randIDList:
			matchID = random.choice(randIDList)

			# 3. 最终还没有，直接机器人
			if not matchID:
			matchID = matchIndex + 1 # 机器人ID固定为 matchIndex + 1
			haveRobot = True
			matchIDList.append(matchID)
			GameWorld.DebugLog(" 本段随机匹配结果: matchIndex=%s,matchID=%s,randIDList=%s,matchIDList=%s" % (matchIndex, matchID, randIDList, matchIDList), playerID)

			#最后一个如果不是机器人，则概率直接匹配机器人
			if not haveRobot and GameWorld.CanHappen(IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch3", 3)):
			robotID = matchCount
			matchIDList[-1] = robotID
			GameWorld.DebugLog("没有匹配到机器人，概率直接匹配到机器人: robotID=%s" % robotID, playerID)

			GameWorld.DebugLog("最终匹配结果: matchIDList=%s" % str(matchIDList), playerID)
			return matchIDList

			def __addRandMatchID(playerID, matchIndex, rankRange, randIDList, matchIDList, loopPlayerIDList, sign):
			## 根据所有可循环玩家ID列表，添加对应匹配轮次可随机匹配的玩家
			packDataMgr = PyDataManager.GetDBPlayerPackDataManager()
			indexStart = matchIndex * rankRange
			indexEnd = indexStart + rankRange - 1
			loopIDCount = len(loopPlayerIDList)
			if sign == 1:
			GameWorld.DebugLog(" 匹配赛区积分榜: matchIndex=%s,loopIndex=%s~%s,loopIDCount=%s" % (matchIndex, indexStart, indexEnd, loopIDCount), playerID)
			else:
			GameWorld.DebugLog(" 匹配赛区战力榜: matchIndex=%s,loopIndex=%s~%s,loopIDCount=%s" % (matchIndex, indexStart, indexEnd, loopIDCount), playerID)
			for index in range(indexStart, indexEnd + 1):
			if index >= loopIDCount:
			break
			dataID = loopPlayerIDList[index]
			if not dataID or dataID == playerID or dataID in randIDList:
			GameWorld.DebugLog(" 不可匹配空或自己或已添加: dataID=%s,randIDList=%s" % (dataID, randIDList), playerID)
			continue
			if dataID in matchIDList:
			GameWorld.DebugLog(" 不可添加已匹配过玩家: dataID=%s,randIDList=%s,matchIDList=%s" % (dataID, randIDList, matchIDList), playerID)
			continue
			if not packDataMgr.IsPlayerIn(dataID):
			GameWorld.DebugLog(" 不匹配无打包数据玩家: dataID=%s,randIDList=%s" % (dataID, randIDList), playerID)
			continue
			randIDList.append(dataID)
			GameWorld.DebugLog(" 添加可以随机匹配玩家: dataID=%s,randIDList=%s" % (dataID, randIDList), playerID)

			return

			def __getZonePackPlayerIDList(zoneID, playerID):
			## 获取分区打包数据玩家ID列表
			crossZoneName = GameWorld.GetCrossZoneName()
			zoneIpyData = IpyGameDataPY.GetIpyGameData("CrossZonePK", crossZoneName, zoneID)
			if zoneIpyData:
			packDataMgr = PyDataManager.GetDBPlayerPackDataManager()
			packDataMgr.Sort()
			serverIDList = zoneIpyData.GetServerGroupIDList()
			zonePackPlayerIDList = packDataMgr.GetPlayerIDListByServerIDInfo(zoneIpyData.GetServerGroupIDList())
			GameWorld.DebugLog(" 获得赛区活跃打包数据玩家: zoneID=%s,serverIDList=%s,%s,%s"
			% (zoneID, serverIDList, len(zonePackPlayerIDList), zonePackPlayerIDList), playerID)
			return zonePackPlayerIDList
			return []

			def ClientServerMsg_PKBillboard(serverGroupID, msgData):
			## 收到子服GM同步的设置跨服PK数据

			zoneID = msgData["ZoneID"]
			seasonID = msgData["SeasonID"]
			playerInfoDict = msgData["PlayerInfo"]

			accID = playerInfoDict["accID"]
			playerID = playerInfoDict["playerID"]
			playerName = playerInfoDict["playerName"]
			playerJob = playerInfoDict["playerJob"]
			face = playerInfoDict.get("face", 0)
			facePic = playerInfoDict.get("facePic", 0)
			realmLV = playerInfoDict["realmLV"]
			pkScore = playerInfoDict["pkScore"]
			danLV = playerInfoDict["danLV"]
			cWinCount = playerInfoDict["cWinCount"]

			# 更新排行榜
			groupValue1, groupValue2 = zoneID, seasonID
			name2, type2 = "", playerJob
			value1, value2 = realmLV, danLV
			cmpValue = pkScore
			isOK = CrossBillboard.UpdCrossBillboard(ShareDefine.Def_CBT_CrossRealmPK, groupValue1, playerID, playerName, name2, type2,
			value1, value2, cmpValue, groupValue2=groupValue2, value3=face, value4=facePic)
			GameWorld.Log("GM设置跨服PK榜单玩家数据: isOK=%s,zoneID=%s,seasonID=%s,pkScore=%s,danLV=%s,cWinCount=%s,accID=%s"
			% (isOK, zoneID, seasonID, pkScore, danLV, cWinCount, accID), playerID)
			return
			##================================== 以下是子服逻辑 ==========================================

			def OnGameServerInitOK():

			if GameWorld.IsCrossServer():
			return

			# 非活动中不处理
			if not IsCrossRealmPKMatchState():
			return
			dbZoneID = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)
			dbSeasonID = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
			dbSeasonState = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)
			GameWorld.Log("OnGameServerInitOK dbZoneID=%s,dbSeasonID=%s,dbSeasonState=%s" % (dbZoneID, dbSeasonID, dbSeasonState))

			# # 如果是要登陆到跨服服务器的，不发送取消
			# if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_IsLoginToMergeServer):
			# GameWorld.DebugLog("本次离线为要登陆跨服服务器的自动离线行为，不发送取消匹配！", curPlayer.GetPlayerID())
			# curPlayer.SetDict(ChConfig.Def_PlayerKey_IsLoginToMergeServer, 0)
			# return

			vsRoomID = curPlayer.GetVsRoomId()
			if vsRoomID and PlayerControl.GetCrossRealmState(curPlayer) == 1:
			GameWorld.DebugLog("玩家跨服PK状态，不能取消匹配！vsRoomID=%s" % vsRoomID, curPlayer.GetPlayerID())
			return

			dataMsg = {"accID":curPlayer.GetAccID(), # 账号
			"playerID":curPlayer.GetPlayerID(), # 玩家ID
			"playerName":curPlayer.GetName(), # 跨服子服玩家名
			"reason":reason, # 取消原因
			"vsRoomID":vsRoomID, # 对战房间ID
			}
			CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_PKCancel, dataMsg)
			PlayerControl.SetVsRoomId(curPlayer, 0)
			SetIsCrossPKMatching(curPlayer, 0)
			GameWorld.Log("发送取消跨服PK匹配到跨服服务器：dataMsg=%s" % str(dataMsg), curPlayer.GetPlayerID())
			return

			def ClientServerMsg_PKMatch(serverGroupID, playerInfoDict, tick):
			## 请求匹配

			if not GameWorld.IsCrossServer():
			GameWorld.ErrLog("非跨服服务器不处理跨服PK匹配请求！")
			return

			if not IsCrossRealmPKMatchState():
			GameWorld.Log("跨服匹配PK活动未开启，不允许请求匹配！")
			return

			seasonID = playerInfoDict["seasonID"] # 赛季ID
			pkZoneID = playerInfoDict["pkZoneID"] # 所属赛区
			accID = playerInfoDict["accID"] # 角色账号
			playerID = playerInfoDict["playerID"] # 角色ID
			playerName = playerInfoDict["playerName"] # 玩家名
			job = playerInfoDict["playerJob"] # ְҵ
			playerLV = playerInfoDict["playerLV"] # ְҵ
			maxHP = playerInfoDict["maxHP"] # ְҵ
			fightPower = playerInfoDict["fightPower"] # 战斗力
			realmLV = playerInfoDict["realmLV"] # 境界
			pkScore = playerInfoDict["pkScore"] # 当前积分
			danLV = playerInfoDict["danLV"] # 当前段位
			cWinCount = playerInfoDict["cWinCount"] # 连胜次数
			ondayScore = playerInfoDict["ondayScore"] # 过天时的积分

			zoneMatchPlayerList = PyGameData.g_crossPKZoneMatchPlayerDict.get(pkZoneID, [])
			if playerID in zoneMatchPlayerList:
			GameWorld.Log("玩家正在匹配中，无法重复发起匹配！playerID=%s,accID=%s" % (playerID, accID))
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKMatchReqRet, [playerID, 1], [serverGroupID])
			return
			if playerID in PyGameData.g_crossPKPlayerDict:
			GameWorld.Log("玩家正在战斗中，无法重复发起匹配！playerID=%s,accID=%s" % (playerID, accID))
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKMatchReqRet, [playerID, -2], [serverGroupID])
			return

			pkPlayer = CrossPKPlayer()
			pkPlayer.accID = accID
			pkPlayer.playerID = playerID
			pkPlayer.playerName = playerName
			pkPlayer.playerJob = job
			pkPlayer.playerLV = playerLV
			pkPlayer.maxHP = maxHP
			pkPlayer.pkScore = pkScore
			pkPlayer.danLV = danLV
			pkPlayer.fightPower = fightPower
			pkPlayer.realmLV = realmLV
			pkPlayer.matchTick = tick
			pkPlayer.cWinCount = cWinCount
			pkPlayer.ondayScore = ondayScore
			pkPlayer.serverGroupID = serverGroupID
			pkPlayer.pkZoneID = pkZoneID
			pkPlayer.seasonID = seasonID
			PyGameData.g_crossPKPlayerDict[playerID] = pkPlayer

			# 加入赛区匹配列表
			zoneMatchPlayerList.append(playerID)
			PyGameData.g_crossPKZoneMatchPlayerDict[pkZoneID] = zoneMatchPlayerList

			GameWorld.Log("玩家加入匹配: seasonID=%s,pkZoneID=%s,serverGroupID=%s,accID=%s,playerID=%s,pkScore=%s,fightPower=%s,cWinCount=%s,len(zoneMatchPlayerList)=%s"
			% (seasonID, pkZoneID, serverGroupID, accID, playerID, pkScore, fightPower, cWinCount, len(zoneMatchPlayerList)))

			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKMatchReqRet, [playerID, 1], [serverGroupID])
			return

			def ClientServerMsg_PKCancel(playerInfoDict, tick):
			## 取消匹配

			if not GameWorld.IsCrossServer():
			GameWorld.ErrLog("非跨服服务器不处理取消跨服PK匹配！")
			return

			# 非活动中不处理
			if not IsCrossRealmPKMatchState():
			return

			accID = playerInfoDict["accID"] # 角色账号
			playerID = playerInfoDict["playerID"] # 玩家ID
			reason = playerInfoDict["reason"] # 取消原因
			vsRoomID = playerInfoDict["vsRoomID"] # 所属对战房间ID
			if vsRoomID in PyGameData.g_crossPKRoomDict:
			pkRoom = PyGameData.g_crossPKRoomDict[vsRoomID]
			if pkRoom.isMapOpen or pkRoom.readyTick:
			GameWorld.Log("跨服对战房间已经开启了线路，或者双方数据都已传输完毕，不可再取消匹配！vsRoomID=%s" % vsRoomID)
			return

			GameWorld.Log("玩家取消匹配: reason=%s,accID=%s,playerID=%s,vsRoomID=%s" % (reason, accID, playerID, vsRoomID))

			pkZoneID = 0
			if playerID in PyGameData.g_crossPKPlayerDict:
			pkPlayer = PyGameData.g_crossPKPlayerDict.pop(playerID)
			pkZoneID = pkPlayer.pkZoneID
			GameWorld.Log(" 移除PK玩家: pkZoneID=%s,accID=%s,playerID=%s" % (pkZoneID, accID, playerID))

			zoneMatchPlayerList = PyGameData.g_crossPKZoneMatchPlayerDict.get(pkZoneID, [])
			if playerID in zoneMatchPlayerList:
			zoneMatchPlayerList.remove(playerID)
			GameWorld.Log(" 从匹配队列中删除，匹配队列剩余人数=%s" % (len(zoneMatchPlayerList)))

			#取消所有存在该玩家的房间，子服不一定知道玩家当前最新所属房间ID，故只能通过遍历删除已经为玩家创建的房间
			for roomID, pkRoom in PyGameData.g_crossPKRoomDict.items():
			if playerID not in pkRoom.roomPlayerIDList:
			continue

			for roomPlayerID in pkRoom.roomPlayerIDList:
			if roomPlayerID == playerID:
			GameWorld.Log(" 自己不处理: roomID=%s,playerID=%s" % (roomID, playerID))
			continue

			zoneMatchPlayerList = PyGameData.g_crossPKZoneMatchPlayerDict.get(pkZoneID, [])
			zoneMatchPlayerList.append(roomPlayerID)
			PyGameData.g_crossPKZoneMatchPlayerDict[pkZoneID] = zoneMatchPlayerList
			GameWorld.Log(" 将之前匹配的对手重新加入匹配队列: roomID=%s,roomPlayerID=%s,当前匹配人数=%s"
			% (roomID, roomPlayerID, len(zoneMatchPlayerList)))

			PyGameData.g_crossPKRoomDict.pop(roomID)
			GameWorld.Log(" 移除房间: popRoomID=%s" % (roomID))
			break

			return

			def ClientServerMsg_PKPrepareOK(playerInfoDict, tick):
			## 玩家跨服对战数据准备OK

			if not GameWorld.IsCrossServer():
			GameWorld.ErrLog("非跨服服务器不处理取消跨服PK匹配！")
			return

			accID = playerInfoDict["accID"] # 玩家账号
			playerID = playerInfoDict["playerID"] # 玩家ID
			vsRoomID = playerInfoDict["vsRoomID"] # 所属对战房间ID
			if playerID not in PyGameData.g_crossPKPlayerDict:
			GameWorld.ErrLog("玩家跨服对战数据准备OK, 但找不到该对战玩家信息！vsRoomID=%s,playerID=%s" % (vsRoomID, playerID))
			return
			#pkPlayer = PyGameData.g_crossPKPlayerDict[playerID]

			if vsRoomID not in PyGameData.g_crossPKRoomDict:
			GameWorld.ErrLog("玩家跨服对战数据准备OK, 但找不到该对战房间(%s)！可能对手已取消！" % vsRoomID)
			return
			vsRoom = PyGameData.g_crossPKRoomDict[vsRoomID]

			if vsRoom.roomState != ShareDefine.Def_VsRoom_State_WaitPlayer:
			GameWorld.ErrLog("玩家跨服对战数据准备OK, 但房间状态非等待状态, state=%s！" % vsRoom.roomState)
			return

			if playerID not in vsRoom.readyPlayerIDList:
			vsRoom.readyPlayerIDList.append(playerID)

			GameWorld.Log("玩家跨服PK准备完毕: accID=%s,playerID=%s,vsRoomID=%s" % (accID, playerID, vsRoomID))
			return

			def __ReadyOKRoomPlayerProcess(tick):
			## 玩家跨服PK已准备好的房间处理

			#GameWorld.Log("===已准备好的对战房间处理===")
			serverGroupIDList = []
			sendReadyOKRoomList = []
			for roomID, vsRoom in PyGameData.g_crossPKRoomDict.items():

			# 非等待状态的房间不处理
			if vsRoom.roomState != ShareDefine.Def_VsRoom_State_WaitPlayer:
			continue

			if not vsRoom.roomPlayerIDList:
			continue

			pkZoneID = 0
			isAllReady = True
			roomGroupIDList = []
			readyMemberDict = {} # 已准备好的玩家信息
			for num, roomPlayerID in enumerate(vsRoom.roomPlayerIDList, 1):
			if roomPlayerID not in vsRoom.readyPlayerIDList or roomPlayerID not in PyGameData.g_crossPKPlayerDict:
			isAllReady = False
			break
			roomPlayer = PyGameData.g_crossPKPlayerDict[roomPlayerID]
			pkZoneID = roomPlayer.pkZoneID
			roomGroupIDList.append(roomPlayer.serverGroupID)
			readyMemberDict[roomPlayerID] = {"ServerGroupID":roomPlayer.serverGroupID, "Name":roomPlayer.playerName, "Number":num,
			"Job":roomPlayer.playerJob, "LV":roomPlayer.playerLV, "MaxHP":roomPlayer.maxHP}

			if not isAllReady:
			continue
			vsRoom.roomState = ShareDefine.Def_VsRoom_State_PrepareFight
			vsRoom.readyTick = tick
			GameWorld.Log(" 准备好的房间: pkZoneID=%s,roomID=%s,mapID=%s,readyMemberDict=%s" % (pkZoneID, roomID, vsRoom.mapID, str(readyMemberDict)))

			sendReadyOKRoomList.append([roomID, readyMemberDict])
			serverGroupIDList += roomGroupIDList

			# 将已准备好的房间广播到子服
			if sendReadyOKRoomList:
			GameWorld.Log(" 已准备好的对战房间数: %s" % len(sendReadyOKRoomList))
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKReadyOKRoomList, sendReadyOKRoomList, serverGroupIDList)
			gameWorld = GameWorld.GetGameWorld()
			zoneID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)
			if not zoneID:
			gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID, dbZoneID)
			gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID, dbSeasonID)
			gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState, dbSeasonState)
			GameWorld.Log(" 服务器启动取DB值设置本服赛区赛季信息: ")

			return

			def OnPKMatchProcess(tick):
			## 玩家跨服PK匹配定时处理逻辑

			# 非跨服服务器不处理跨服PK匹配逻辑
			if not GameWorld.IsCrossServer():
			return

			if not IsCrossRealmPKMatchState():
			return

			# 定时更新排行榜
			crossPKBillboardMgr = PyDataManager.GetCrossPKBillboardManager()
			crossPKBillboardMgr.PKBillboardSortByTime(tick)

			processTick = IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch", 1) * 1000
			processTickKey = "PKMatchLastTick"
			lastProcessTick = GameWorld.GetGameWorld().GetDictByKey(processTickKey)
			if tick - lastProcessTick < processTick:
			return
			GameWorld.GetGameWorld().SetDict(processTickKey, tick)

			# 处理超时的房间
			__DoCheckRoomTimeout(tick)
			# 通知已准备好的房间玩家可进入跨服
			__ReadyOKRoomPlayerProcess(tick)

			maxGroupCnt = IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch", 2)
			outTimeTick = IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch", 3) * 1000

			# 每个赛区单独匹配
			for pkZoneID, matchPlayerIDList in PyGameData.g_crossPKZoneMatchPlayerDict.items():
			matchPlayerCount = len(matchPlayerIDList)
			if matchPlayerCount < 2:
			#GameWorld.Log("匹配PK人数不足，不处理！pkZoneID=%s, 总人数:%s" % (pkZoneID, matchPlayerCount))
			continue

			GameWorld.Log("★★★★★★★★★★开始跨服PK匹配(pkZoneID=%s, 总人数:%s)★★★★★★★★★★" % (pkZoneID, matchPlayerCount))

			matchPlayerList = []
			for matchPlayerID in matchPlayerIDList:
			if matchPlayerID not in PyGameData.g_crossPKPlayerDict:
			continue
			matchPlayerList.append(PyGameData.g_crossPKPlayerDict[matchPlayerID])
			# 按匹配时间、积分升序排序
			matchTickSortList = sorted(matchPlayerList, key=operator.attrgetter("matchTick"))
			scoreSortList = sorted(matchPlayerList, key=operator.attrgetter("pkScore"))

			matchPlayerVSList = [] # 成功匹配玩家对战列表

			# 优先匹配等待超时玩家
			__DoMatch_OutTimePlayer(matchTickSortList, scoreSortList, outTimeTick, matchPlayerVSList, tick)

			if len(matchPlayerVSList) < maxGroupCnt:
			# 再按积分段匹配玩家
			__DoMatch_DanScorePlayer(scoreSortList, maxGroupCnt, matchPlayerVSList)

			# 给成功匹配的玩家非配对战房间
			matchPlayerVSList = matchPlayerVSList[:maxGroupCnt]
			__DoSetVSRoom(pkZoneID, matchPlayerVSList, tick)
			GameWorld.Log("==========匹配结束(总匹配队伍:%s)==========" % len(matchPlayerVSList))
			return


			def __DoMatch_OutTimePlayer(matchTickSortList, scoreSortList, outTimeTick, matchPlayerVSList, tick):
			'''匹配超时玩家
			匹配中的玩家按积分排序，最后一个默认匹配上一个，第一个默认匹配下一个，其他匹配前后积分差绝对值较小的一个
			'''
			GameWorld.Log(" ==优先匹配超时等待玩家==最大等待时间:%s, tick=%s" % (outTimeTick, tick))
			GameWorld.Log(" scoreSortListLen=%s" % len(scoreSortList))
			for i, matchPlayer in enumerate(matchTickSortList):
			# 只有一个玩家
			if len(scoreSortList) <= 1:
			GameWorld.Log(" 当前玩家数%s<=1，不再匹配！" % len(scoreSortList))
			break

			if tick - matchPlayer.matchTick < outTimeTick:
			GameWorld.Log(" i=%s,玩家未超时，不再匹配！" % (i))
			break

			GameWorld.Log(" i=%s,超时玩家, %s-%s=%s >= outTimeTick(%s)"
			% (i, tick, matchPlayer.matchTick, tick - matchPlayer.matchTick, outTimeTick))
			# 已经被匹配走了
			if matchPlayer not in scoreSortList:
			GameWorld.Log(" 已经被匹配走了！")
			continue

			outTimeIndex = scoreSortList.index(matchPlayer)
			# 最后一个默认匹配上一个
			if outTimeIndex == len(scoreSortList) - 1:
			vsIndex = outTimeIndex - 1
			GameWorld.Log(" 超时玩家积分排序索引%s,最后一个,默认匹配上一个索引%s！" % (outTimeIndex, vsIndex))
			# 第一个默认匹配下一个
			elif outTimeIndex == 0:
			vsIndex = outTimeIndex + 1
			GameWorld.Log(" 超时玩家积分排序索引%s,第一个,默认匹配下一个索引%s！" % (outTimeIndex, vsIndex))
			# 其他情况匹配积分较近的一个
			else:
			preIndex = outTimeIndex - 1
			nextIndex = outTimeIndex + 1
			prePlayer = scoreSortList[preIndex]
			nextPlayer = scoreSortList[nextIndex]
			preDiff = abs(prePlayer.pkScore - matchPlayer.pkScore)
			nextDiff = abs(matchPlayer.pkScore - nextPlayer.pkScore)
			vsIndex = preIndex if preDiff <= nextDiff else nextIndex
			GameWorld.Log(" 超时玩家积分排序索引-积分(%s-%s),上一个(%s-%s),下一个(%s-%s),preDiff=%s,nextDiff=%s,vsIndex=%s"
			% (outTimeIndex, matchPlayer.pkScore, preIndex, prePlayer.pkScore,
			nextIndex, nextPlayer.pkScore, preDiff, nextDiff, vsIndex))

			if outTimeIndex > vsIndex:
			scoreSortList.pop(outTimeIndex)
			vsPlayer = scoreSortList.pop(vsIndex)
			elif outTimeIndex < vsIndex:
			vsPlayer = scoreSortList.pop(vsIndex)
			scoreSortList.pop(outTimeIndex)
			else:
			continue

			# 加入成功匹配列表
			matchPlayerVSList.append([matchPlayer, vsPlayer])

			return

			def __DoMatch_DanScorePlayer(scoreSortList, maxGroupCnt, matchPlayerVSList):
			''' 匹配积分分段玩家
			匹配中的玩家按段位积分归组，归组后，随机段位顺序，每个段位组中的玩家随机两两PK
			'''
			GameWorld.Log(" ==匹配积分分段玩家== maxGroupCnt=%s,scoreSortListLen=%s" % (maxGroupCnt, len(scoreSortList)))
			danPlayerListDict = {} # 按积分分段列表分散玩家
			for matchPlayer in scoreSortList:
			danLV = matchPlayer.danLV
			danPlayerList = danPlayerListDict.get(danLV, [])
			danPlayerList.append(matchPlayer)
			danPlayerListDict[danLV] = danPlayerList

			# 按分段玩家随机匹配
			danList = danPlayerListDict.keys()
			random.shuffle(danList) # 打乱段位顺序

			GameWorld.Log(" 积分分段个数: %s, %s" % (len(danList), danList))

			# 日志输出分组明细
			for danLV in danList:
			strList = []
			for player in danPlayerListDict[danLV]:
			strList.append((player.playerID, player.pkScore, player.fightPower))
			GameWorld.Log(" 积分段组, danLV=%s, %s" % (danLV, str(strList)))

			doCount = 0
			while len(matchPlayerVSList) < maxGroupCnt and doCount < maxGroupCnt:
			doCount += 1
			isMatchOK = False
			for danLV in danList:
			danPlayerList = danPlayerListDict[danLV]
			danPlayerCount = len(danPlayerList)
			if danPlayerCount < 2:
			GameWorld.Log(" 段位人数少于2个，此段位本轮轮空！doCount=%s,danLV=%s" % (doCount, danLV))
			continue

			vsIndexList = random.sample(xrange(danPlayerCount), 2) # 随机取两个索引对战
			vsIndexList.sort()
			aPlayer = danPlayerList.pop(vsIndexList[1])
			bPlayer = danPlayerList.pop(vsIndexList[0])

			matchPlayerVSList.append([aPlayer, bPlayer])
			isMatchOK = True
			GameWorld.Log(" 成功匹配玩家: aPlayerID=%s,aScore=%s,aFP=%s VS bPlayerID=%s,bScore=%s,bFP=%s"
			% (aPlayer.playerID, aPlayer.pkScore, aPlayer.fightPower, bPlayer.playerID, bPlayer.pkScore, bPlayer.fightPower))

			if len(matchPlayerVSList) >= maxGroupCnt:
			GameWorld.Log(" 已经达到最大匹配数! 已匹配对战数=%s, 不再匹配！doCount=%s" % (len(matchPlayerVSList), doCount))
			break

			if not isMatchOK:
			GameWorld.Log(" 已经没有满足匹配条件的玩家! 不再匹配！doCount=%s" % (doCount))
			break

			return

			def __DoSetVSRoom(pkZoneID, matchPlayerVSList, tick):
			## 设置对战房间

			if not matchPlayerVSList:
			return

			vsRoomDict = {}
			serverGroupIDList = []
			zoneMatchPlayerList = PyGameData.g_crossPKZoneMatchPlayerDict.get(pkZoneID, [])

			mapIDList = IpyGameDataPY.GetFuncCfg("CrossRealmPKMatch", 4)
			GameWorld.Log("===给配对的玩家开房间(pkZoneID=%s,配对数:%s)===" % (pkZoneID, len(matchPlayerVSList)))
			for aPlayer, bPlayer in matchPlayerVSList:

			if not aPlayer or not bPlayer:
			continue

			aPlayerID = aPlayer.playerID
			bPlayerID = bPlayer.playerID
			if aPlayerID not in PyGameData.g_crossPKPlayerDict or bPlayerID not in PyGameData.g_crossPKPlayerDict:
			GameWorld.ErrLog("玩家匹配数据异常！aPlayerID=%s,bPlayerID=%s" % (aPlayerID, bPlayerID))
			continue

			roomID = __GetNewRoomID()
			if not roomID:
			GameWorld.ErrLog("无法创建房间！该房间已经存在！PyGameData.g_crossPKRoomID=%s" % PyGameData.g_crossPKRoomID)
			continue
			mapID = random.choice(mapIDList)

			newRoom = CrossPKRoom()
			newRoom.pkZoneID = pkZoneID
			newRoom.seasonID = aPlayer.seasonID # 因为匹在一起的玩家一定是同一赛区同一赛季的，所以随便取一个玩家的赛季ID信息即可
			newRoom.roomID = roomID
			newRoom.mapID = mapID
			newRoom.openTick = tick
			newRoom.roomPlayerIDList = [aPlayerID, bPlayerID]
			PyGameData.g_crossPKRoomDict[roomID] = newRoom

			aServerGroupID, bServerGroupID = aPlayer.serverGroupID, bPlayer.serverGroupID
			GameWorld.Log(" 开房:pkZoneID=%s,mapID=%s,roomID=%s,aPlayerID=%s,bPlayerID=%s" % (pkZoneID, mapID, roomID, aPlayerID, bPlayerID))
			vsRoomDict[roomID] = [mapID, [[aServerGroupID, aPlayerID], [bServerGroupID, bPlayerID]]]

			serverGroupIDList.append(aServerGroupID)
			serverGroupIDList.append(bServerGroupID)

			# 移除匹配队列
			if aPlayerID in zoneMatchPlayerList:
			zoneMatchPlayerList.remove(aPlayerID)
			if bPlayerID in zoneMatchPlayerList:
			zoneMatchPlayerList.remove(bPlayerID)
			PyGameData.g_crossPKZoneMatchPlayerDict[pkZoneID] = zoneMatchPlayerList

			# 将匹配结果广播到子服
			if vsRoomDict:
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKMatchResult, vsRoomDict, serverGroupIDList)

			return

			def __GetNewRoomID():
			## 获取新房间ID, 房间号直接自增，一定不会重复，除非自增一轮后房间ID还没有释放
			for _ in xrange(100):
			newRoomID = PyGameData.g_crossPKRoomID + 1
			if newRoomID > 65530:
			newRoomID = 1
			PyGameData.g_crossPKRoomID = newRoomID
			if newRoomID not in PyGameData.g_crossPKRoomDict:
			return newRoomID
			return 0

			def __DoCheckRoomTimeout(tick):
			## 处理超时的房间

			timeoutRoomDict = {}
			serverGroupIDList = []
			roomTimeout = IpyGameDataPY.GetFuncCfg("CrossRealmPKCfg", 2) * 1000 # 这个时间尽量长点，目前暂时不确定玩家从准备到进入到地图的时长
			for roomID, pkRoom in PyGameData.g_crossPKRoomDict.items():
			if pkRoom.isMapOpen or not pkRoom.readyTick:
			continue
			if tick - pkRoom.readyTick <= roomTimeout:
			continue
			pkZoneID = pkRoom.pkZoneID
			GameWorld.Log("PK房间等待玩家进来超时，没有玩家进来，关闭该房间！pkZoneID=%s,roomID=%s,openTick=%s,readyTick=%s,tick=%s"
			% (pkZoneID, roomID, pkRoom.openTick, pkRoom.readyTick, tick))
			roomPlayerInfo = []
			for roomPlayerID in pkRoom.roomPlayerIDList:
			pkPlayer = PyGameData.g_crossPKPlayerDict.pop(roomPlayerID, None)
			if not pkPlayer:
			continue
			serverGroupID = pkPlayer.serverGroupID
			GameWorld.Log(" 移除玩家，玩家需重新手动匹配，serverGroupID=%s,roomPlayerID=%s" % (serverGroupID, roomPlayerID))
			serverGroupIDList.append(serverGroupID)
			roomPlayerInfo.append([serverGroupID, roomPlayerID])
			timeoutRoomDict[roomID] = roomPlayerInfo
			PyGameData.g_crossPKRoomDict.pop(roomID)

			# 将超时房间广播到子服
			if timeoutRoomDict:
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKTimeoutRoomList, timeoutRoomDict, serverGroupIDList)
			return

			def MapServer_CrossPKRoomOpen(msgList):
			roomID = msgList[0]
			if roomID not in PyGameData.g_crossPKRoomDict:
			GameWorld.ErrLog("MapServer_CrossPKRoomOpen => PK房间不存在！roomID=%s" % roomID)
			return
			pkRoom = PyGameData.g_crossPKRoomDict[roomID]
			pkRoom.isMapOpen = True
			GameWorld.Log("MapServer_CrossPKRoomOpen => roomID=%s" % roomID)
			return

			def MapServer_CrossPKOver(infoList):
			## 收到MapServer副本跨服PK结果同步

			GameWorld.Log("收到MapServer_跨服PK战斗结果: %s" % str(infoList))

			roomID, winnerID, loserID, roundWinnerIDList, overType = infoList

			if roomID not in PyGameData.g_crossPKRoomDict:
			GameWorld.ErrLog("跨服PK房间数据不存在！roomID=%s" % roomID)
			return
			vsRoom = PyGameData.g_crossPKRoomDict.pop(roomID)
			#vsRoom = PyGameData.g_crossPKRoomDict[roomID]
			roomPlayerIDList = vsRoom.roomPlayerIDList
			if not winnerID and not loserID:
			GameWorld.ErrLog("地图没有结算跨服PK胜负玩家，随机玩家获胜!")
			if not roomPlayerIDList or len(roomPlayerIDList) != 2:
			return
			winnerID, loserID = roomPlayerIDList
			elif not loserID:
			for roomPlayerID in roomPlayerIDList:
			if roomPlayerID != winnerID:
			loserID = roomPlayerID
			break

			if winnerID not in roomPlayerIDList or loserID not in roomPlayerIDList:
			GameWorld.ErrLog("跨服PK房间及玩家不匹配，不结算！roomID=%s,winnerID=%s,loserID=%s,roomPlayerIDList=%s"
			% (roomID, winnerID, loserID, vsRoom.roomPlayerIDList))
			return

			if winnerID not in PyGameData.g_crossPKPlayerDict:
			GameWorld.ErrLog("跨服PK房间获取不到玩家PK数据, roomID=%s,winnerID=%s" % (roomID, winnerID))
			return
			if loserID not in PyGameData.g_crossPKPlayerDict:
			GameWorld.ErrLog("跨服PK房间获取不到玩家PK数据, roomID=%s,loserID=%s" % (roomID, loserID))
			return

			winner = PyGameData.g_crossPKPlayerDict.pop(winnerID)
			loser = PyGameData.g_crossPKPlayerDict.pop(loserID)
			#winner = PyGameData.g_crossPKPlayerDict[winnerID]
			#loser = PyGameData.g_crossPKPlayerDict[loserID]
			zoneID = vsRoom.pkZoneID
			seasonID = vsRoom.seasonID

			cWinCount = winner.cWinCount
			winnerScore, loserScore = winner.pkScore, loser.pkScore
			winnerDanLV, loserDanLV = winner.danLV, loser.danLV
			winnerDayScore, loserDayScore = max(0, winnerScore - winner.ondayScore), max(0, loserScore - loser.ondayScore) # 今日已获得积分，正积分

			GameWorld.Log("winnerDayScore=%s,winnerScore=%s,winnerDanLV=%s,cWinCount=%s" % (winnerDayScore, winnerScore, winnerDanLV, cWinCount))
			GameWorld.Log("loserDayScore=%s,loserScore=%s,loserDanLV=%s" % (loserDayScore, loserScore, loserDanLV))

			winIpyData = IpyGameDataPY.GetIpyGameData("CrossRealmPKDan", winnerDanLV)
			loseIpyData = IpyGameDataPY.GetIpyGameData("CrossRealmPKDan", loserDanLV)
			if not winIpyData or not loseIpyData:
			GameWorld.ErrLog("跨服PK房间段位数据异常! roomID=%s,winnerDanLV=%s,loserDanLV=%s" % (roomID, winnerDanLV, loserDanLV))

			baseScoreList = IpyGameDataPY.GetFuncEvalCfg("CrossRealmPKScore", 2) # 胜负保底分
			wBaseScore = baseScoreList[0] if len(baseScoreList) > 0 else 0
			lBaseScore = baseScoreList[1] if len(baseScoreList) > 1 else 0
			wExScore = eval(IpyGameDataPY.GetFuncCompileCfg("CrossRealmPKScore", 3)) # 胜方附加分
			lExScore = 0

			winnerAddScore = wBaseScore + wExScore
			loserAddScore = lBaseScore + lExScore

			dayMaxScore = IpyGameDataPY.GetFuncCfg("CrossRealmPKScore", 1) # 每日获得积分上限，0为不限制
			if dayMaxScore:
			if winnerAddScore > 0:
			winnerAddScore = min(dayMaxScore - winnerDayScore, winnerAddScore)
			if loserAddScore > 0:
			loserAddScore = min(dayMaxScore - loserDayScore, loserAddScore)

			winner.pkScore += winnerAddScore
			loser.pkScore += loserAddScore

			winner.cWinCount += 1
			loser.cWinCount = 0

			if winIpyData and winIpyData.GetLVUpScore() and winner.pkScore >= winIpyData.GetLVUpScore():
			winner.danLV += 1

			if loseIpyData and loseIpyData.GetLVUpScore() and loser.pkScore >= loseIpyData.GetLVUpScore():
			loser.danLV += 1

			GameWorld.Log("wBaseScore=%s,wExScore=%s,winnerAddScore=%s,updScore=%s,updDanLV=%s,updCWinCount=%s" % (wBaseScore, wExScore, winnerAddScore, winner.pkScore, winner.danLV, winner.cWinCount))
			GameWorld.Log("lBaseScore=%s,lExScore=%s,loserAddScore=%s,updScore=%s,updDanLV=%s,updCWinCount=%s" % (lBaseScore, lExScore, loserAddScore, loser.pkScore, loser.danLV, loser.cWinCount))

			# 更新排行榜
			UpdateCrossPKBillboard(zoneID, seasonID, winner, loser)

			timeStr = GameWorld.GetCurrentDataTimeStr()
			playerOverDict = {}
			# 通知客户端战斗结果
			for playerID in [winnerID, loserID]:
			if playerID == winnerID:
			serverGroupID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName = \
			winner.serverGroupID, winner.pkScore, winner.danLV, winner.cWinCount, winnerAddScore, loser.playerID, loser.playerName
			else:
			serverGroupID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName = \
			loser.serverGroupID, loser.pkScore, loser.danLV, loser.cWinCount, loserAddScore, winner.playerID, winner.playerName

			player = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			notifyState = True if player else False

			playerOverDict[playerID] = [roomID, zoneID, seasonID, timeStr, overType, winnerID, roundWinnerIDList] \
			+ [serverGroupID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName, notifyState]
			if not player:
			continue

			overPack = ChPyNetSendPack.tagGCCrossRealmPKOverInfo()
			overPack.TimeStr = timeStr
			overPack.OverType = overType
			overPack.WinnerID = winnerID
			overPack.RoundWinnerID = roundWinnerIDList
			overPack.RoundCount = len(overPack.RoundWinnerID)
			overPack.AddScore = addScore
			overPack.Score = pkScore
			overPack.DanLV = danLV
			overPack.CWinCnt = cWinCount
			overPack.TagName = tagPlayerName
			overPack.TagNameLen = len(overPack.TagName)
			NetPackCommon.SendFakePack(player, overPack)

			GameWorld.Log("同步玩家PK结果: serverGroupID=%s,roomID=%s,addScore=%s,pkScore=%s,danLV=%s,cWinCount=%s,tagPlayerID=%s"
			% (serverGroupID, roomID, addScore, pkScore, danLV, cWinCount, tagPlayerID), playerID)

			serverGroupIDList = [winner.serverGroupID, loser.serverGroupID]
			GameWorld.Log("同步子服战斗结果: seasonID=%s,timeStr=%s,roomID=%s,overType=%s,winnerID=%s,roundWinnerIDList=%s"
			% (seasonID, timeStr, roomID, overType, winnerID, roundWinnerIDList))
			# 同步子服
			CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKOverInfo, playerOverDict, serverGroupIDList)
			return

			##================================== 以下是子服逻辑 ==========================================

			def OnMapServerInitOK():
			# 通知地图服务器状态
			@@ -1461,7 +756,12 @@
			GameWorld.Log(" zoneID=%s,seasonID=%s,seasonState=%s,matchState=%s" % (zoneID, seasonID, seasonState, matchState))
			if not zoneID:
			return

			if not seasonID:
			dbSeasonID = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
			if dbSeasonID:
			GameWorld.ErrLog(" 已经有分配赛季ID的暂定不能被置为0! dbSeasonID=%s" % dbSeasonID)
			return

			gameWorld = GameWorld.GetGameWorld()
			curSeasonState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)

			@@ -1470,8 +770,23 @@
			gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState, seasonState)
			gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK, matchState)

			# 强制覆盖存DB
			dbZoneID = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)
			dbSeasonID = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
			dbSeasonState = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)
			GameWorld.Log(" before dbZoneID=%s,dbSeasonID=%s,dbSeasonState=%s" % (dbZoneID, dbSeasonID, dbSeasonState))

			PlayerDBGSEvent.SetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID, zoneID)
			PlayerDBGSEvent.SetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID, seasonID)
			PlayerDBGSEvent.SetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState, seasonState)
			dbZoneID = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)
			dbSeasonID = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
			dbSeasonState = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)
			GameWorld.Log(" update dbZoneID=%s,dbSeasonID=%s,dbSeasonState=%s" % (dbZoneID, dbSeasonID, dbSeasonState))

			if curSeasonState == 1 and seasonState == 2:
			PlayerControl.WorldNotify(0, "NotifySeasonOver")
			pass
			#PlayerControl.WorldNotify(0, "NotifySeasonOver")

			# 通知地图服务器状态
			GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID, zoneID)
			@@ -1485,6 +800,8 @@
			seasonStatePack.SeasonID = seasonID
			seasonStatePack.SeasonState = seasonState
			seasonStatePack.MatchState = matchState
			seasonStatePack.CrossZoneName = GameWorld.GetCrossZoneName()
			seasonStatePack.CrossZoneNameLen = len(seasonStatePack.CrossZoneName)
			playerManager = GameWorld.GetPlayerManager()
			for i in xrange(playerManager.GetPlayerCount()):
			curPlayer = playerManager.GetPlayerByIndex(i)
			@@ -1495,182 +812,141 @@

			def CrossServerMsg_PKMatchReqRet(retInfo):
			## 跨服PK匹配请求结果
			playerID, result = retInfo
			playerID = retInfo["playerID"]
			matchIDList = retInfo["matchIDList"]
			matchInfoDict = retInfo["matchInfoDict"]

			curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			if not curPlayer:
			return

			if result == -2:
			PlayerControl.NotifyCode(curPlayer, "InCrossPKing")
			matchOKPack = ChPyNetSendPack.tagGCCrossRealmPKMatchOK()
			matchOKPack.MatchPlayer = []
			for matchID in matchIDList:
			matchPlayer = ChPyNetSendPack.tagGCCrossRealmPKMatchPlayer()
			if matchID not in matchInfoDict:
			matchPlayer.PlayerID = matchID
			matchOKPack.MatchPlayer.append(matchPlayer)
			continue
			matchInfo = matchInfoDict[matchID]
			matchPlayer.PlayerID = matchInfo["playerID"]
			matchPlayer.PlayerName = matchInfo["playerName"]
			matchPlayer.NameLen = len(matchPlayer.PlayerName)
			matchPlayer.Job = matchInfo["job"]
			matchPlayer.LV = matchInfo["lv"]
			matchPlayer.RealmLV = matchInfo["realmLV"]
			matchPlayer.Face = matchInfo["face"]
			matchPlayer.FacePic = matchInfo["facePic"]
			matchPlayer.FightPower = matchInfo["fightPower"] % ChConfig.Def_PerPointValue
			matchPlayer.FightPowerEx = matchInfo["fightPower"] / ChConfig.Def_PerPointValue
			matchOKPack.MatchPlayer.append(matchPlayer)
			matchOKPack.MatchPlayerCount = len(matchOKPack.MatchPlayer)
			NetPackCommon.SendFakePack(curPlayer, matchOKPack)
			return


			#跨服竞技场未通知玩家的比赛结果，注意该类只处理数据逻辑，功能相关逻辑不要写在该类，不然重读脚本不会生效
			class CrossPKUnNotifyOverInfoManager(object):

			def __init__(self):
			self.__unNotifyOverInfoDict = {} # {playerID:tagDBCrossPKUnNotifyOverInfo, ...}
			return

			if result == 1:
			SetIsCrossPKMatching(curPlayer, 1)
			NetPackCommon.SendFakePack(curPlayer, ChPyNetSendPack.tagGCCrossRealmPKStartMatch())

			return

			## 跨服匹配状态
			def SetIsCrossPKMatching(curPlayer, isMatching):
			curPlayer.SetDict(ChConfig.Def_PlayerKey_IsCrossPKMatching, isMatching)
			sysMsg = str(isMatching)
			curPlayer.MapServer_QueryPlayerResult(0, 0, "CrossPKMatching", sysMsg, len(sysMsg))
			return
			def GetIsCrossPKMatching(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_IsCrossPKMatching)

			def CrossServerMsg_PKMatchResult(vsRoomDict):
			## 跨服PK匹配结果
			curServerGroupID = GameWorld.GetServerGroupID()
			actionType = ShareDefine.Def_CrossAction_PK
			mapPosList = IpyGameDataPY.GetFuncEvalCfg("CrossRealmPKMatch", 5)
			GameWorld.Log("=== 收到PK匹配结果处理 === curServerGroupID=%s" % curServerGroupID)
			if not mapPosList:
			GameWorld.ErrLog("没有配置对战地图进入坐标！")
			def AddUnNotifyOverInfo(self, playerID, overInfoData):
			self.__unNotifyOverInfoDict[playerID] = overInfoData
			return

			for roomID, roomInfo in vsRoomDict.items():
			mapID, playerList = roomInfo
			GameWorld.Log(" roomID=%s,playerList=%s" % (roomID, playerList))
			for i, playerInfo in enumerate(playerList):
			serverGroupID, playerID = playerInfo
			if serverGroupID != curServerGroupID:
			GameWorld.DebugLog(" 不是本服玩家，不处理!playerID=%s,serverGroupID=%s" % (playerID, serverGroupID))
			continue
			player = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			if not player:
			GameWorld.DebugLog(" 玩家不在线, playerID=%s" % (playerID))
			continue
			if PlayerControl.GetIsTJG(player):
			GameWorld.DebugLog(" 玩家脱机中, playerID=%s" % (playerID))
			continue
			PlayerControl.SetVsRoomId(player, roomID, True)
			# 通知地图玩家匹配成功, 上传数据, 准备进入跨服服务器
			posX, posY = mapPosList[i] if len(mapPosList) > i else mapPosList[0]
			CrossRealmPlayer.SendCrossRealmReg(player, actionType, mapID, mapID, 0, posX, posY)

			return

			def CrossServerMsg_PKReadyOKRoomList(readyOKRoomList):
			## 子服接收玩家已准备好的PK房间信息, 此房间里的玩家可传送进入跨服
			def GetPlayerUnNotifyOverInfo(self, playerID): return self.__unNotifyOverInfoDict.pop(playerID, None)

			curServerGroupID = GameWorld.GetServerGroupID()
			GameWorld.Log("===收到跨服服务器通知已准备好的对战PK房间信息处理=== curServerGroupID=%s" % curServerGroupID)
			# serverGroupID, playerName, playerJob

			for roomID, readyMemberDict in readyOKRoomList:
			for playerID, playerInfo in readyMemberDict.items():
			serverGroupID = playerInfo["ServerGroupID"]
			playerName = playerInfo["Name"]
			number = playerInfo["Number"]

			if serverGroupID != curServerGroupID:
			GameWorld.DebugLog(" 不是本服玩家，不处理!playerID=%s,serverGroupID=%s" % (playerID, serverGroupID))
			continue

			player = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			if not player:
			GameWorld.DebugLog(" 玩家不在线 , playerID=%s" % (playerID))
			continue
			if PlayerControl.GetIsTJG(player):
			GameWorld.DebugLog(" 玩家脱机中, playerID=%s" % (playerID))
			continue
			player.SetDict(ChConfig.Def_PlayerKey_IsLoginToMergeServer, 1)

			matchPlayer = ChPyNetSendPack.tagGCCrossRealmPKMatchPlayer()
			for readyPlayerID, readyPlayerInfo in readyMemberDict.items():
			if readyPlayerID != playerID:
			matchPlayer.PlayerID = readyPlayerID
			matchPlayer.PlayerName = readyPlayerInfo["Name"]
			matchPlayer.NameLen = len(matchPlayer.PlayerName)
			matchPlayer.Job = readyPlayerInfo["Job"]
			matchPlayer.LV = readyPlayerInfo["LV"]
			matchPlayer.MaxHP = readyPlayerInfo["MaxHP"]
			break
			# 保存数据存数据库和realtimebackup
			def GetSaveData(self):
			savaData = ""
			cntData = ""
			cnt = 0
			for overInfoData in self.__unNotifyOverInfoDict.values():
			cnt += 1
			savaData += overInfoData.getBuffer()

			PlayerControl.SetCrossRealmState(player, 1)
			SetIsCrossPKMatching(player, 0)

			# 通知匹配成功，可进入跨服
			matchOKPack = ChPyNetSendPack.tagGCCrossRealmPKMatchOK()
			matchOKPack.RoomID = roomID
			matchOKPack.PlayerName = playerName
			matchOKPack.NameLen = len(matchOKPack.PlayerName)
			matchOKPack.Number = number
			matchOKPack.MatchPlayer = [matchPlayer]
			matchOKPack.MatchPlayerCount = len(matchOKPack.MatchPlayer)
			NetPackCommon.SendFakePack(player, matchOKPack)
			GameWorld.Log(" 通知玩家进入跨服PK对战房间! roomID=%s,playerID=%s,matchPlayerID=%s" % (roomID, playerID, matchPlayer.PlayerID))

			return

			def CrossServerMsg_PKTimeoutRoomList(timeoutRoomDict):
			## 子服接收已超时的PK房间信息, 此房间里的玩家重置跨服状态
			GameWorld.Log("SaveDBCrossPKUnNotifyOverInfo cnt :%s len=%s" % (cnt, len(savaData)))
			return CommFunc.WriteDWORD(cntData, cnt) + savaData

			curServerGroupID = GameWorld.GetServerGroupID()
			GameWorld.Log("===收到跨服服务器通知已超时的对战PK房间信息处理=== curServerGroupID=%s" % curServerGroupID)
			# 从数据库载入数据
			def LoadPyGameData(self, datas, pos, dataslen):
			cnt, pos = CommFunc.ReadDWORD(datas, pos)
			GameWorld.Log("LoadDBCrossPKUnNotifyOverInfo cnt :%s" % cnt)

			for _ in xrange(cnt):
			overInfoData = PyGameDataStruct.tagDBCrossPKUnNotifyOverInfo()
			overInfoData.clear()
			pos += overInfoData.readData(datas, pos, dataslen)
			self.__unNotifyOverInfoDict[overInfoData.PlayerID] = overInfoData

			return pos

			for roomID, roomPlayerInfo in timeoutRoomDict.items():
			if not roomPlayerInfo:
			continue
			serverGroupID, playerID = roomPlayerInfo

			if serverGroupID != curServerGroupID:
			GameWorld.DebugLog(" 不是本服玩家，不处理!playerID=%s,serverGroupID=%s" % (playerID, serverGroupID))
			continue

			player = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			if not player:
			GameWorld.DebugLog(" 玩家不在线 , playerID=%s" % (playerID))
			continue
			if PlayerControl.GetIsTJG(player):
			GameWorld.DebugLog(" 玩家脱机中, playerID=%s" % (playerID))
			continue
			playerVSRoomID = player.GetVsRoomId()
			if playerVSRoomID and playerVSRoomID != roomID:
			GameWorld.DebugLog(" 房间ID不同, playerID=%s" % (playerID))
			continue
			player.SetDict(ChConfig.Def_PlayerKey_IsLoginToMergeServer, 0)
			PlayerControl.SetCrossRealmState(player, 0)

			return

			def CrossServerMsg_PKOverInfo(playerOverDict):
			## 子服接收跨服PK结果信息

			curServerGroupID = GameWorld.GetServerGroupID()
			GameWorld.Log("===收到跨服服务器同步的跨服PK结果=== curServerGroupID=%s" % curServerGroupID)
			GameWorld.DebugLog("===收到跨服服务器同步的跨服PK结果=== curServerGroupID=%s" % curServerGroupID)

			for playerID, overInfo in playerOverDict.items():
			roomID, zoneID, seasonID, timeStr, overType, winnerID, roundWinnerIDList, \
			serverGroupID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName, notifyState = overInfo
			if serverGroupID != curServerGroupID:
			GameWorld.DebugLog(" 不是本服玩家，不处理!playerID=%s,serverGroupID=%s" % (playerID, serverGroupID))
			zoneID, seasonID, timeStr, winnerID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName = overInfo
			if not PlayerControl.GetDBPlayerAccIDByID(playerID):
			GameWorld.DebugLog(" 不是本服玩家，不处理! playerID=%s" % (playerID))
			continue

			sendMapOverInfo = [roomID, zoneID, seasonID, timeStr, overType, winnerID, roundWinnerIDList, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName, notifyState]
			player = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
			if not player or PlayerControl.GetIsTJG(player):
			GameWorld.Log(" 玩家不在线或脱机中，先缓存，玩家上线后再同步，playerID=%s" % (playerID))
			PyGameData.g_crossPKUnNotifyOverInfo[playerID] = sendMapOverInfo
			GameWorld.DebugLog(" 玩家不在线或脱机中，先缓存，玩家上线后再同步，playerID=%s" % (playerID))
			overInfoData = PyGameDataStruct.tagDBCrossPKUnNotifyOverInfo()
			overInfoData.clear()
			overInfoData.ZoneID = zoneID
			overInfoData.SeasonID = seasonID
			overInfoData.RoomID = 0
			overInfoData.TimeStr = timeStr
			overInfoData.OverType = 0
			overInfoData.PlayerID = playerID
			overInfoData.WinnerID = winnerID
			overInfoData.RoundWinnerInfo = str([])
			overInfoData.RoundWinnerLen = len(overInfoData.RoundWinnerInfo)
			overInfoData.PKScore = pkScore
			overInfoData.DanLV = danLV
			overInfoData.CWinCount = cWinCount
			overInfoData.AddScore = addScore
			overInfoData.TagPlayerID = tagPlayerID
			overInfoData.TagPlayerName = tagPlayerName
			PyDataManager.GetCrossPKUnNotifyOverInfoManager().AddUnNotifyOverInfo(playerID, overInfoData)
			continue

			PlayerControl.SetVsRoomId(player, 0)
			sysMsg = str(sendMapOverInfo)
			sysMsg = str(overInfo)
			player.MapServer_QueryPlayerResult(0, 0, "CrossPKOverInfo", sysMsg, len(sysMsg))
			GameWorld.Log("通知地图跨服PK结算: roomID=%s,zoneID=%s,seasonID=%s,timeStr=%s,overType=%s,winnerID=%s,roundWinnerIDList=%s, pkScore=%s,danLV=%s,cWinCount=%s,addScore=%s,tagPlayerID=%s,notifyState=%s,mapID=%s"
			% (roomID, zoneID, seasonID, timeStr, overType, winnerID, roundWinnerIDList, pkScore, danLV, cWinCount, addScore, tagPlayerID, notifyState, player.GetMapID()), playerID)
			GameWorld.DebugLog("通知地图跨服PK结算: zoneID=%s,seasonID=%s,timeStr=%s,winnerID=%s, pkScore=%s,danLV=%s,cWinCount=%s,addScore=%s,tagPlayerID=%s,mapID=%s"
			% (zoneID, seasonID, timeStr, winnerID, pkScore, danLV, cWinCount, addScore, tagPlayerID, player.GetMapID()), playerID)
			return

			def __OnLoginNotifyPKOverInfo(curPlayer):
			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_crossPKUnNotifyOverInfo:
			overInfoData = PyDataManager.GetCrossPKUnNotifyOverInfoManager().GetPlayerUnNotifyOverInfo(playerID)
			if not overInfoData:
			return
			overInfo = PyGameData.g_crossPKUnNotifyOverInfo.pop(playerID)
			PlayerControl.SetCrossRealmState(curPlayer, 0)
			PlayerControl.SetVsRoomId(curPlayer, 0)
			sysMsg = str(overInfo)
			zoneID = overInfoData.ZoneID
			seasonID = overInfoData.SeasonID
			timeStr = overInfoData.TimeStr
			winnerID = overInfoData.WinnerID
			pkScore = overInfoData.PKScore
			danLV = overInfoData.DanLV
			cWinCount = overInfoData.CWinCount
			addScore = overInfoData.AddScore
			tagPlayerID = overInfoData.TagPlayerID
			tagPlayerName = overInfoData.TagPlayerName
			sysMsg = str([zoneID, seasonID, timeStr, winnerID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName])
			curPlayer.MapServer_QueryPlayerResult(0, 0, "CrossPKOverInfo", sysMsg, len(sysMsg))
			GameWorld.Log("玩家上线通知地图未结算的跨服PK结算: mapID=%s,overInfo=%s" % (curPlayer.GetMapID(), overInfo), playerID)
			GameWorld.DebugLog("玩家上线通知地图未结算的跨服PK结算: zoneID=%s,seasonID=%s,timeStr=%s,winnerID=%s,pkScore=%s,danLV=%s,cWinCount=%s,addScore=%s,tagPlayerID=%s,mapID=%s"
			% (zoneID, seasonID, timeStr, winnerID, pkScore, danLV, cWinCount, addScore, tagPlayerID, curPlayer.GetMapID()), playerID)
			return


			def DR_CrossReamlPK(eventName, dataDict={}):
			drDataDict = {}
			drDataDict.update(dataDict)
			DataRecordPack.SendEventPack("CrossPK_%s" % eventName, drDataDict)
			return