#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package CrossRealmPK
|
#
|
# @todo:¿ç·þPK¾º¼¼³¡
|
# @author hxp
|
# @date 2018-12-21
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ¿ç·þPK¾º¼¼³¡
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2018-12-21 18:00"""
|
#-------------------------------------------------------------------------------
|
|
import GameWorld
|
import PlayerControl
|
import CrossRealmMsg
|
import DataRecordPack
|
import ChPyNetSendPack
|
import PyGameDataStruct
|
import PlayerDBGSEvent
|
import CrossBillboard
|
import PyDataManager
|
import NetPackCommon
|
import IpyGameDataPY
|
import ShareDefine
|
import PyGameData
|
import CommFunc
|
import ChConfig
|
|
import datetime
|
import operator
|
import random
|
import time
|
|
#¿ç·þPKÅÅÐаñ¹ÜÀí£¬×¢Òâ¸ÃÀàÖ»´¦ÀíÊý¾ÝÂß¼£¬¹¦ÄÜÏà¹ØÂß¼²»ÒªÐ´ÔÚ¸ÃÀ࣬²»È»ÖضÁ½Å±¾²»»áÉúЧ
|
class CrossPKBillboardManager(object):
|
|
DBKEY_CrossPKFinalBillboardData = "CrossPKFinalBillboard_%s_%s" # ÊÇ·ñÊÕµ½ÈüÇøÈü¼¾×îÖÕ°ñµ¥Í¬²½£¬²ÎÊý£¨zoneID, seasonID£©
|
|
def __init__(self):
|
self.__ZoneSeasonDataList = "ZoneSeasonDataList_%s_%s" # ·ÖÇøÈü¼¾ÅÅÐÐÊý¾ÝÁбí [tagDBCrossPKBillboard, ...]
|
self.__ZoneSeasonPlayerOrderDict = "ZoneSeasonPlayerOrderDict_%s_%s" # ·ÖÇøÈü¼¾ÅÅÐÐÊý¾Ý×Öµä {playerID:rank, ...}
|
self.__ZoneSeasonList = [] # ·ÖÇøÈü¼¾Áбí [(zoneID, seasonID), ...]
|
self.__UnSortZoneSeasonTimeDict = {} # δÅÅÐòµÄ·ÖÇøÈü¼¾ÅÅÐÐ {(zoneID, seasonID):tick, ...}
|
return
|
|
def GetCrossPKBillboardInfo(self, zoneID, seasonID, isSort=False):
|
## »ñÈ¡¿ç·þPKÅÅÐаñÐÅÏ¢
|
# @return: billboardList, orderDict
|
listAttrName = self.__ZoneSeasonDataList % (zoneID, seasonID)
|
orderDictAttrName = self.__ZoneSeasonPlayerOrderDict % (zoneID, seasonID)
|
if not hasattr(self, listAttrName):
|
setattr(self, listAttrName, [])
|
setattr(self, orderDictAttrName, {})
|
self.__ZoneSeasonList.append((zoneID, seasonID))
|
billboardList = getattr(self, listAttrName)
|
if isSort:
|
self.__PKBillboardSort(zoneID, seasonID, billboardList)
|
orderDict = getattr(self, orderDictAttrName)
|
return billboardList, orderDict
|
|
def __PKBillboardSort(self, zoneID, seasonID, billboardList):
|
## ÅÅÐò
|
if (zoneID, seasonID) not in self.__UnSortZoneSeasonTimeDict:
|
return
|
self.__UnSortZoneSeasonTimeDict.pop((zoneID, seasonID))
|
billboardList.sort(key=operator.attrgetter("PKScore", "Time"), reverse=True)
|
orderDict = {}
|
for order, billboardData in enumerate(billboardList, 1):
|
orderDict[billboardData.PlayerID] = order # »º´æÈü¼¾Íæ¼ÒÅÅÃû
|
orderDictAttrName = self.__ZoneSeasonPlayerOrderDict % (zoneID, seasonID)
|
setattr(self, orderDictAttrName, orderDict)
|
GameWorld.DebugLog("¿ç·þPK°ñµ¥ÅÅÐò: zoneID=%s,seasonID=%s,orderDict=%s" % (zoneID, seasonID, orderDict))
|
return
|
|
def PKBillboardSortByTime(self, tick):
|
## ¶¨Ê±ÅÅÐò
|
if not self.__UnSortZoneSeasonTimeDict:
|
return
|
sortCD = 60 * 1000 # ³¬¹ý1·ÖÖÓÇ¿ÖÆÅÅÐò
|
for key, updTick in self.__UnSortZoneSeasonTimeDict.items():
|
zoneID, seasonID = key
|
if tick - updTick < sortCD:
|
continue
|
self.GetCrossPKBillboardInfo(zoneID, seasonID, True)
|
return
|
|
def SetNeedSort(self, zoneID, seasonID):
|
if (zoneID, seasonID) not in self.__UnSortZoneSeasonTimeDict:
|
self.__UnSortZoneSeasonTimeDict[(zoneID, seasonID)] = GameWorld.GetGameWorld().GetTick()
|
return
|
## ===========================================================================================
|
|
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):
|
savaData = ""
|
cntData = ""
|
cnt = 0
|
for zoneID, seasonID in self.__ZoneSeasonList:
|
billboardList = self.GetCrossPKBillboardInfo(zoneID, seasonID)[0]
|
for billboardData in billboardList:
|
cnt += 1
|
savaData += billboardData.getBuffer()
|
|
GameWorld.Log("SaveCrossPKBillboard cnt :%s len=%s" % (cnt, len(savaData)))
|
return CommFunc.WriteDWORD(cntData, cnt) + savaData
|
|
# ´ÓÊý¾Ý¿âÔØÈëÊý¾Ý
|
def LoadPyGameData(self, datas, pos, dataslen):
|
cnt, pos = CommFunc.ReadDWORD(datas, pos)
|
GameWorld.Log("LoadCrossPKBillboard cnt :%s" % cnt)
|
|
for _ in xrange(cnt):
|
billboardData = PyGameDataStruct.tagDBCrossPKBillboard()
|
billboardData.clear()
|
pos += billboardData.readData(datas, pos, dataslen)
|
|
zoneID = billboardData.ZoneID
|
seasonID = billboardData.SeasonID
|
billboardList = self.GetCrossPKBillboardInfo(zoneID, seasonID)[0]
|
billboardList.append(billboardData)
|
|
# ÅÅÐò
|
for zoneID, seasonID in self.__ZoneSeasonList:
|
self.SetNeedSort(zoneID, seasonID)
|
billboardList = self.GetCrossPKBillboardInfo(zoneID, seasonID, True)[0]
|
GameWorld.Log(" zoneID=%s, seasonID=%s, count=%s" % (zoneID, seasonID, len(billboardList)))
|
|
self.CopyToCrossBillboard()
|
return pos
|
|
def MapServer_QueryCrossPKSeasonOrder(curPlayer, msgList):
|
## µØͼ·þÎñÆ÷²éѯÍæ¼ÒÈüÇøÈü¼¾PK°ñÅÅÃû
|
playerID = curPlayer.GetPlayerID()
|
zoneID, seasonID, eventName, eventData = msgList
|
funcData = {"zoneID":zoneID, "seasonID":seasonID, "eventName":eventName, "eventData":eventData}
|
CrossBillboard.OnQueryPlayerBillboardRank(playerID, "QueryCrossPKSeasonOrder", funcData, ShareDefine.Def_CBT_CrossRealmPK, zoneID, seasonID)
|
return
|
|
def OnQueryCrossPKSeasonOrderRet(playerID, funcData, orderIndex):
|
## ²éѯÅÅÃû·µ»Ø
|
queryPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not queryPlayer:
|
return
|
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 __GetCrossPKZoneSeasonTimeInfo():
|
key = "CrossPKZoneSeasonTimeInfo"
|
openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
|
ZoneSeasonTimeInfo = IpyGameDataPY.GetConfigEx(key)
|
|
if ZoneSeasonTimeInfo and ZoneSeasonTimeInfo[0] == openServerDay:
|
#GameWorld.DebugLog("ÒѾ¼ÓÔعý±¾ÈÕ¿ç·þPKÈü¼¾´¦ÀíÐÅÏ¢£¡openServerDay=%s" % openServerDay)
|
return ZoneSeasonTimeInfo[1]
|
|
GameWorld.Log("¼ÓÔØ¿ç·þPKÈü¼¾Ê±¼äÐÅÏ¢: openServerDay=%s" % (openServerDay))
|
|
zoneSeasonTimeDict = {}
|
serverTime = GameWorld.GetServerTime()
|
crossZoneName = GameWorld.GetCrossZoneName()
|
crossZoneList = IpyGameDataPY.GetIpyGameDataByCondition("CrossZonePK", {"CrossZoneName":crossZoneName}, True)
|
if not crossZoneList:
|
return zoneSeasonTimeDict
|
|
for zoneIpyData in crossZoneList:
|
zoneID = zoneIpyData.GetZoneID()
|
|
# ¹æ¶¨Ã¿¸öÈüÇøµÄÈü¼¾Ê±¼äÐ谴˳ÐòÅäÖÃ
|
seasonIpyDataList = IpyGameDataPY.GetIpyGameDataList("CrossRealmPKSeason", crossZoneName, zoneID)
|
if not seasonIpyDataList:
|
continue
|
|
for i, seasonIpyData in enumerate(seasonIpyDataList):
|
seasonID = seasonIpyData.GetSeasonID()
|
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 i == len(seasonIpyDataList) - 1:
|
nextSeasonIpyData = None
|
else:
|
nextSeasonIpyData = seasonIpyDataList[i + 1]
|
|
if serverTime < startDateTime:
|
GameWorld.Log(" Èü¼¾Î´¿ªÊ¼! zoneID=%s,seasonID=%s,startDateStr=%s,endDateStr=%s" % (zoneID, seasonID, startDateStr, endDateStr))
|
break
|
|
elif startDateTime <= serverTime <= endDateTime:
|
pass
|
|
elif endDateTime < serverTime:
|
if nextSeasonIpyData:
|
nestStartDateStr = nextSeasonIpyData.GetStartDate()
|
nextStartDateTime = datetime.datetime.strptime("%s 00:00:00" % (nestStartDateStr), ChConfig.TYPE_Time_Format)
|
if serverTime >= nextStartDateTime:
|
GameWorld.Log(" Èü¼¾ÒѹýÆÚ! zoneID=%s,seasonID=%s,startDateStr=%s,endDateStr=%s" % (zoneID, seasonID, startDateStr, endDateStr))
|
continue
|
else:
|
pass
|
|
else:
|
continue
|
|
nextSeasonID = 0 if not nextSeasonIpyData else nextSeasonIpyData.GetSeasonID()
|
zoneSeasonTimeDict[zoneID] = [seasonIpyData]
|
GameWorld.Log(" Èü¼¾»î¶¯ÖÐ! zoneID=%s,seasonID=%s,startDateStr=%s,endDateStr=%s,nextSeasonID=%s" % (zoneID, seasonID, startDateStr, endDateStr, nextSeasonID))
|
break
|
|
ZoneSeasonTimeInfo = IpyGameDataPY.SetConfigEx(key, [openServerDay, zoneSeasonTimeDict])
|
GameWorld.Log("¿ç·þPKÈü¼¾Ê±¼äÐÅÏ¢¼ÓÔØÍê±Ï!")
|
GameWorld.Log("=============================================================")
|
return ZoneSeasonTimeInfo[1]
|
|
def OnMinuteProcess():
|
## ÿ·ÖÖÓ´¦Àí
|
|
if not GameWorld.IsCrossServer():
|
return
|
|
zoneSeasonTimeDict = __GetCrossPKZoneSeasonTimeInfo()
|
if not zoneSeasonTimeDict:
|
return
|
|
gameWorld = GameWorld.GetGameWorld()
|
serverTime = GameWorld.GetServerTime()
|
crossZoneName = GameWorld.GetCrossZoneName()
|
for zoneID, seasonTimeInfo in zoneSeasonTimeDict.items():
|
zoneIpyData = IpyGameDataPY.GetIpyGameData("CrossZonePK", crossZoneName, zoneID)
|
if not zoneIpyData:
|
continue
|
|
curSeasonIpyData = seasonTimeInfo[0]
|
if not curSeasonIpyData:
|
continue
|
|
seasonID = curSeasonIpyData.GetSeasonID()
|
startDateStr = curSeasonIpyData.GetStartDate()
|
endDateStr = curSeasonIpyData.GetEndDate()
|
endTimeStr = curSeasonIpyData.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)
|
|
seasonState = 0
|
if startDateTime <= serverTime < endDateTime:
|
seasonState = 1
|
elif serverTime >= endDateTime:
|
seasonState = 2
|
|
zoneSeasonIDDictName = ChConfig.Def_WorldKey_CrossPKZoneSeasonID % zoneID
|
seasonStateDictName = ChConfig.Def_WorldKey_CrossPKZoneSeasonState % zoneID
|
dictSeasonID = gameWorld.GetDictByKey(zoneSeasonIDDictName)
|
curSeasonState = gameWorld.GetDictByKey(seasonStateDictName)
|
if curSeasonState == seasonState and dictSeasonID == seasonID:
|
#ÒѾÊÇÕâ¸ö״̬ÁË
|
continue
|
gameWorld.SetDict(zoneSeasonIDDictName, seasonID)
|
gameWorld.SetDict(seasonStateDictName, seasonState)
|
GameWorld.Log("¿ç·þPKÈü¼¾×´Ì¬±ä¸ü: zoneID=%s,seasonID=%s,seasonState=%s" % (zoneID, seasonID, seasonState))
|
|
serverGroupIDList = zoneIpyData.GetServerGroupIDList()
|
# Èü¼¾½áÊø
|
if seasonState == 2:
|
PyGameData.g_crossPKMatchDict = {}
|
|
# ¹ã²¥µ±Ç°ÈüÇøµÄËùÓÐ×Ó·þ¿ç·þPKÈü¼¾×´Ì¬±ä¸ü
|
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, serverGroupIDList)
|
|
return
|
|
def OnCrossRealmPKDailyActionStateChange(isOpen):
|
## ¿ç·þPKÿÈջƥÅä״̬±ä¸ü
|
|
if not GameWorld.IsCrossServer():
|
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)
|
|
# Æ¥Åä״̬´Ó¹Ø±Õµ½¿ªÆô
|
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Èü¼¾×´Ì¬±ä¸ü
|
serverGroupIDList = zoneIpyData.GetServerGroupIDList()
|
seasonID = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonID % zoneID)
|
seasonState = gameWorld.GetDictByKey(ChConfig.Def_WorldKey_CrossPKZoneSeasonState % zoneID)
|
seasonInfo = {"ZoneID":zoneID, "SeasonID":seasonID, "SeasonState":seasonState, "MatchState":isOpen}
|
GameWorld.Log("¿ç·þPKÆ¥Åä״̬±ä¸ü: zoneID=%s,seasonID=%s,seasonState=%s,matchState=%s" % (zoneID, seasonID, seasonState, isOpen))
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PKSeasonInfo, seasonInfo, serverGroupIDList)
|
|
return
|
|
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()
|
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 GetCrossPKServerGroupZone(serverGroupID):
|
## »ñÈ¡·þÎñÆ÷×éID¶ÔÓ¦µÄ¿ç·þPKËùÊôÈüÇø£¬·µ»Ø0´ú±í¸Ã·þÎñÆ÷ûÓзÖÅäÈüÇø
|
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
|
return
|
|
def OnPlayerLogin(curPlayer):
|
# ±¾·þµÇ¼´¦Àí
|
|
# ±¾·þûÓзÖÅäÈüÇø²»´¦Àí
|
if not GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID):
|
return
|
__OnLoginNotifyPKOverInfo(curPlayer)
|
|
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)
|
|
# ͬ²½±¾·þÈü¼¾×´Ì¬
|
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():
|
## ¿ç·þPKÆ¥ÅäÈüÊÇ·ñ¿ªÆô
|
return GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState \
|
% ShareDefine.DailyActionID_CrossReamPK) == ChConfig.Def_Action_Open
|
|
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Áбí
|
|
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
|
matchIDList.append(matchID)
|
GameWorld.DebugLog(" ±¾¶ÎËæ»úÆ¥Åä½á¹û: matchIndex=%s,matchID=%s,randIDList=%s,matchIDList=%s" % (matchIndex, matchID, randIDList, matchIDList), 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
|
|
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))
|
|
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 OnMapServerInitOK():
|
# ֪ͨµØͼ·þÎñÆ÷״̬
|
|
if GameWorld.IsCrossServer():
|
return
|
|
gameWorld = GameWorld.GetGameWorld()
|
zoneID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID)
|
seasonID = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID)
|
seasonState = gameWorld.GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState)
|
matchState = GameWorld.GetGameWorld().GetDictByKey(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK)
|
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID, zoneID)
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID, seasonID)
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState, seasonState)
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK, matchState)
|
return
|
|
def CrossServerMsg_PKSeasonInfo(seasonInfo):
|
## ÊÕµ½¿ç·þ·þÎñÆ÷ͬ²½µÄÈü¼¾ÐÅÏ¢
|
#seasonInfo = {"ZoneID":zoneID, "SeasonID":seasonID, "SeasonState":seasonState, "MatchState":matchState}
|
GameWorld.Log("ÊÕµ½¿ç·þ·þÎñÆ÷ͬ²½µÄÈü¼¾ÐÅÏ¢...")
|
if not seasonInfo:
|
return
|
zoneID = seasonInfo.get("ZoneID", 0)
|
seasonID = seasonInfo.get("SeasonID", 0)
|
seasonState = seasonInfo.get("SeasonState", 0)
|
matchState = seasonInfo.get("MatchState", 0)
|
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)
|
|
gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID, zoneID)
|
gameWorld.SetDict(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID, seasonID)
|
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:
|
pass
|
#PlayerControl.WorldNotify(0, "NotifySeasonOver")
|
|
# ֪ͨµØͼ·þÎñÆ÷״̬
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossPKZoneID, zoneID)
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonID, seasonID)
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossPKSeasonState, seasonState)
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossDailyActionState % ShareDefine.DailyActionID_CrossReamPK, matchState)
|
|
# ¹ã²¥Íæ¼ÒÈü¼¾Ïà¹Ø״̬±ä¸ü
|
seasonStatePack = ChPyNetSendPack.tagGCCrossRealmPKSeasonState()
|
seasonStatePack.ZoneID = zoneID
|
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)
|
if curPlayer == None or not curPlayer.GetInitOK():
|
continue
|
NetPackCommon.SendFakePack(curPlayer, seasonStatePack)
|
return
|
|
def CrossServerMsg_PKMatchReqRet(retInfo):
|
## ¿ç·þPKÆ¥ÅäÇëÇó½á¹û
|
playerID = retInfo["playerID"]
|
matchIDList = retInfo["matchIDList"]
|
matchInfoDict = retInfo["matchInfoDict"]
|
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
return
|
|
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
|
|
def AddUnNotifyOverInfo(self, playerID, overInfoData):
|
self.__unNotifyOverInfoDict[playerID] = overInfoData
|
return
|
|
def GetPlayerUnNotifyOverInfo(self, playerID): return self.__unNotifyOverInfoDict.pop(playerID, None)
|
|
# ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
|
def GetSaveData(self):
|
savaData = ""
|
cntData = ""
|
cnt = 0
|
for overInfoData in self.__unNotifyOverInfoDict.values():
|
cnt += 1
|
savaData += overInfoData.getBuffer()
|
|
GameWorld.Log("SaveDBCrossPKUnNotifyOverInfo cnt :%s len=%s" % (cnt, len(savaData)))
|
return CommFunc.WriteDWORD(cntData, cnt) + savaData
|
|
# ´ÓÊý¾Ý¿âÔØÈëÊý¾Ý
|
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
|
|
def CrossServerMsg_PKOverInfo(playerOverDict):
|
## ×Ó·þ½ÓÊÕ¿ç·þPK½á¹ûÐÅÏ¢
|
|
curServerGroupID = GameWorld.GetServerGroupID()
|
GameWorld.DebugLog("===ÊÕµ½¿ç·þ·þÎñÆ÷ͬ²½µÄ¿ç·þPK½á¹û=== curServerGroupID=%s" % curServerGroupID)
|
|
for playerID, overInfo in playerOverDict.items():
|
zoneID, seasonID, timeStr, winnerID, pkScore, danLV, cWinCount, addScore, tagPlayerID, tagPlayerName = overInfo
|
if not PlayerControl.GetDBPlayerAccIDByID(playerID):
|
GameWorld.DebugLog(" ²»ÊDZ¾·þÍæ¼Ò£¬²»´¦Àí! playerID=%s" % (playerID))
|
continue
|
|
player = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not player or PlayerControl.GetIsTJG(player):
|
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
|
|
sysMsg = str(overInfo)
|
player.MapServer_QueryPlayerResult(0, 0, "CrossPKOverInfo", sysMsg, len(sysMsg))
|
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()
|
overInfoData = PyDataManager.GetCrossPKUnNotifyOverInfoManager().GetPlayerUnNotifyOverInfo(playerID)
|
if not overInfoData:
|
return
|
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.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
|
