#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#
|
#
|
##@package PlayerViewCache.py
|
#
|
# @todo:Íæ¼ÒÊý¾Ý»º´æ
|
#
|
# @author NathanShaw
|
# @date 2010-01-01 21:30
|
# @version 1.3
|
# @note:
|
#
|
# @change: "2014-11-05 11:20" xmnathan Íæ¼ÒÊý¾Ý»º´æ¹ÜÀí
|
# @change: "2014-12-09 17:30" xmnathan Íæ¼ÒÊý¾Ý»º´æ
|
# @change: "2016-05-18 16:00" hxp Õ½ÃËÓйÙÔ±³ÉÔ±»º´æ²»Çå³ý
|
#---------------------------------------------------------------------
|
#"""Version = 2016-05-18 16:00"""
|
#---------------------------------------------------------------------
|
|
import GameWorld
|
import GameWorship
|
import GameXiangong
|
import PlayerControl
|
import NetPackCommon
|
import GameWorldArena
|
import ChPyNetSendPack
|
import PlayerFBHelpBattle
|
import GameWorldSkyTower
|
import CrossChampionship
|
import CrossBattlefield
|
import CrossRealmPlayer
|
import PyGameDataStruct
|
import PlayerPackData
|
import IpyGameDataPY
|
import PyDataManager
|
import CrossRealmMsg
|
import ShareDefine
|
import PyGameData
|
import ChPlayer
|
import ChConfig
|
|
import json
|
import time
|
import random
|
|
TempCache = PyGameDataStruct.tagPlayerViewCachePy()
|
|
def DoOnDayEx():
|
DelOutofTimeViewCacheData()
|
return
|
|
def IsSaveDBViewCache(viewCache):
|
## »º´æÊý¾ÝÊÇ·ñÈë¿â
|
if not viewCache:
|
return False
|
|
playerID = viewCache.PlayerID
|
if PlayerFBHelpBattle.IsInHelpBattleCheckInList(playerID):
|
return True
|
|
if GameWorldArena.IsArenaBattlePlayer(playerID):
|
return True
|
|
if CrossBattlefield.IsBattlefieldCallPlayer(playerID):
|
return True
|
|
if CrossChampionship.IsChampionshipPlayer(playerID):
|
return True
|
|
if GameWorship.IsWorshipPlayer(playerID):
|
return True
|
|
if PyDataManager.GetDBPyFuncTeamManager().IsTeamPlayer(playerID):
|
return True
|
|
if GameXiangong.IsXiangongPlayer(playerID):
|
return True
|
|
if GameWorldSkyTower.IsSkyTowerPassPlayer(playerID):
|
return True
|
|
if PlayerPackData.IsPackDataPlayer(playerID):
|
return True
|
|
#¿ç·þ°ñµ¥ÉϵÄĬÈϱ£Áô
|
if GameWorld.IsCrossServer():
|
billboardMgr = PyDataManager.GetCrossBillboardManager()
|
for billboardType in ShareDefine.CrossBillboardTypeList:
|
groupList = billboardMgr.GetBillboardGroupList(billboardType)
|
for billboardType, groupValue1, groupValue2 in groupList:
|
billboardObj = billboardMgr.GetCrossBillboard(billboardType, groupValue1, groupValue2)
|
if billboardObj.FindByID(playerID):
|
return True
|
|
else:
|
NeedCheckBillBoardType = IpyGameDataPY.GetFuncEvalCfg("PlayerViewCache", 2)
|
#УÑéÍæ¼ÒÊÇ·ñÉÏÅÅÐаñ
|
billboardMgr = GameWorld.GetBillboard()
|
for BillBoardType in NeedCheckBillBoardType:
|
curBillboard = billboardMgr.FindBillboard(BillBoardType)
|
if not curBillboard:
|
continue
|
if curBillboard.FindByID(playerID):
|
return True
|
|
# ÒÔÉÏÊÇÏà¹Ø¹¦ÄÜÐèÒªÓõ½µÄÊý¾Ý£¬±Ø¶¨²»ÄÜɾ³ýµÄ
|
|
# ÒÔÏÂÊDZ£Áô½üÆÚ»îÔ¾Íæ¼Ò£¬µÈ¼¶ÏÞÖÆ
|
playerLV = viewCache.LV
|
offTime = viewCache.OffTime
|
if not playerLV and not offTime:
|
# ¿ç·þ·þÎñÆ÷֮ǰijЩÇé¿öûÓд洢LV¼°OffTime£¬·ÀÖ¹Îóɾ£¬×ö¾ÉÊý¾Ý¼æÈÝÓÃ
|
return True
|
|
SaveDBLimitLV = IpyGameDataPY.GetFuncCfg("PlayerViewCache", 1)
|
if playerLV >= SaveDBLimitLV:
|
maxDays = IpyGameDataPY.GetFuncCfg("PlayerViewCache", 3)
|
if not maxDays:
|
maxDays = 7 # ĬÈÏ7Ìì
|
MaxTime = maxDays * 3600 * 24
|
curTime = int(time.time())
|
passTime = curTime - viewCache.OffTime
|
if passTime < MaxTime:
|
return True
|
|
return False
|
|
def DelOutofTimeViewCacheData():
|
## ɾ³ý¹ýÆڵIJ鿴»º´æÊý¾Ý
|
|
PlayerPackData.DelOutofTimePackData()
|
|
pyViewCacheMgr = PyDataManager.GetPlayerViewCachePyManager()
|
playerViewCachePyDict = pyViewCacheMgr.playerViewCachePyDict
|
for playerID, viewCache in playerViewCachePyDict.items():
|
if IsSaveDBViewCache(viewCache):
|
continue
|
playerViewCachePyDict.pop(playerID)
|
|
PyGameData.g_crossPlayerViewCache = {} # ÿÈÕÖ±½ÓÇå¿Õ¿ç·þÍæ¼Ò²é¿´»º´æ
|
return
|
|
def DeleteViewCache(playerID):
|
## ɾ³ýÍæ¼Ò»º´æ
|
pyViewCacheMgr = PyDataManager.GetPlayerViewCachePyManager()
|
playerViewCachePyDict = pyViewCacheMgr.playerViewCachePyDict
|
playerViewCachePyDict.pop(playerID, None)
|
GameWorld.DebugLog("ɾ³ý²é¿´»º´æ!", playerID)
|
return
|
|
def FindViewCache(playerID, isAddNew=False, newPropData={}):
|
## ²éÕÒÍæ¼Ò»º´æ
|
# @param newPropData: ÐÂÊý¾Ý³õʼPropData {}, key: LV,RealmLV,Job,VIPLV,Name,FamilyID,FamilyName,FightPower
|
curCache = None
|
pyViewCacheMgr = PyDataManager.GetPlayerViewCachePyManager()
|
playerViewCachePyDict = pyViewCacheMgr.playerViewCachePyDict
|
if playerID in playerViewCachePyDict:
|
curCache = playerViewCachePyDict[playerID]
|
elif isAddNew or playerID < 10000:
|
# ÄÚÍø²âÊÔ¼ÙÍæ¼Ò
|
if playerID < 10000 and not newPropData:
|
openJobList = IpyGameDataPY.GetFuncEvalCfg("OpenJob", 1)
|
fakeName = "ÉñÃصÀÓÑ".decode(ShareDefine.Def_Game_Character_Encoding).encode(GameWorld.GetCharacterEncoding())
|
fakeName = "%s%s" % (fakeName, playerID)
|
serverID = playerID % 200 + 1 # 1 ~ 200 ·þ
|
serverGroupID = serverID
|
if serverID < 50:
|
serverGroupID = serverGroupID / 10 + 1 # Ç°50·þÿ10·þ1Ö÷·þ
|
isOnline = True if playerID % 2 == 0 else False
|
olMgr = ChPlayer.GetOnlinePlayerMgr()
|
olMgr.SetOnlineState(playerID, isOnline, serverGroupID)
|
accID = "fake%s@test@s%s" % (playerID, serverID)
|
newPropData = {
|
"AccID":accID,
|
"PlayerID":playerID,
|
"Name":fakeName,
|
"Job":random.choice(openJobList) if openJobList else 1,
|
"LV":random.randint(100, 200),
|
"RealmLV":random.randint(5, 15),
|
"FightPower":random.randint(1000000, 100000000),
|
"ServerGroupID":serverGroupID,
|
}
|
curCache = PyGameDataStruct.tagPlayerViewCachePy()
|
curCache.PlayerID = playerID
|
curCache.OffTime = int(time.time())
|
if newPropData:
|
curCache.PropData = json.dumps(newPropData, ensure_ascii=False).replace(" ", "")
|
curCache.PropDataSize = len(curCache.PropData)
|
playerViewCachePyDict[playerID] = curCache
|
return curCache
|
|
def GetCachePropDataDict(curCache):
|
## »ñÈ¡»º´æ»ù´¡ÊôÐÔ×ÖµäÐÅÏ¢
|
if not curCache:
|
return {}
|
if not hasattr(curCache, "PropDataDict"):
|
curCache.PropDataDict = {}
|
if not curCache.PropDataDict and curCache.PropData:
|
curCache.PropDataDict = eval(curCache.PropData)
|
return curCache.PropDataDict
|
|
def GetShotCacheDict(playerID, *exAttrs):
|
## »ñÈ¡Íæ¼Ò¼ò¶ÌµÄ»º´æÐÅÏ¢×Öµä
|
viewCache = FindViewCache(playerID)
|
cacheDict = GetCachePropDataDict(viewCache)
|
if not cacheDict:
|
return {}
|
shotCacheDict = {
|
"Name":cacheDict["Name"],
|
"Job":cacheDict["Job"],
|
"LV":cacheDict["LV"],
|
"RealmLV":cacheDict["RealmLV"],
|
}
|
for attrName in exAttrs:
|
if attrName == "PlayerID":
|
shotCacheDict["PlayerID"] = playerID
|
elif attrName == "ServerID":
|
shotCacheDict["ServerID"] = GameWorld.GetAccIDServerID(cacheDict["AccID"])
|
elif attrName == "OfflineValue":
|
olMgr = ChPlayer.GetOnlinePlayerMgr()
|
shotCacheDict["OfflineValue"] = olMgr.GetOfflineValue(playerID, viewCache)
|
# ¸½´øÍâ¹ÛÄ£ÐÍչʾÏà¹Ø
|
elif attrName == "Model":
|
shotCacheDict.update({
|
"TitleID":cacheDict.get("TitleID", 0),
|
"EquipShowSwitch":cacheDict.get("EquipShowSwitch", 0),
|
"EquipShowID":cacheDict.get("EquipShowID", []),
|
})
|
elif attrName in cacheDict:
|
shotCacheDict[attrName] = cacheDict[attrName]
|
return shotCacheDict
|
|
def GetSyncCrossCacheBase(curPlayer):
|
## »ñȡͬ²½¿ç·þ»ù´¡²é¿´»º´æ£¬Ö÷ÒªÓÃÓÚ¸ö±ð¹¦ÄÜÐèÒªÌáÇ°ÏÈͬ²½Íæ¼Ò»ù´¡»º´æµ½¿ç·þ£¬ÒòΪ¿ç·þ²»Ò»¶¨ÓÐÍæ¼Ò»º´æ£¬ÐèÒªÌáǰͬ²½
|
playerID = curPlayer.GetPlayerID()
|
cacheDict = GetCachePropDataDict(FindViewCache(playerID))
|
cacheBase = {
|
"AccID":curPlayer.GetAccID(),
|
"LV":curPlayer.GetLV(),
|
"RealmLV":curPlayer.GetOfficialRank(),
|
"Job":curPlayer.GetJob(),
|
"VIPLV":curPlayer.GetVIPLv(),
|
"Name":CrossRealmPlayer.GetCrossPlayerName(curPlayer),
|
"Face":curPlayer.GetFace(),
|
"FacePic":curPlayer.GetFacePic(),
|
"FamilyID":curPlayer.GetFamilyID(),
|
"FamilyName":cacheDict.get("FamilyName", ""),
|
"TitleID":cacheDict.get("TitleID", 0),
|
"FightPower":PlayerControl.GetFightPower(curPlayer),
|
"EquipShowSwitch":cacheDict.get("EquipShowSwitch", 0),
|
"EquipShowID":cacheDict.get("EquipShowID", []),
|
"ServerGroupID":PlayerControl.GetPlayerServerGroupID(curPlayer),
|
}
|
return cacheBase
|
|
def UpdCrossCacheBase(playerID, cacheBase, isLogout=False):
|
## ¸üÐÂͬ²½¿ç·þ»ù´¡²é¿´»º´æ
|
curCache = FindViewCache(playerID, True, cacheBase)
|
if not curCache:
|
return {}
|
curCache.LV = cacheBase.get("LV", 0)
|
curCache.OffTime = int(time.time()) # ÿ´Î¶¼¸üУ¬×îºóÒ»´Î¿ÉÊÓΪ¿ç·þÍæ¼ÒµÄ×î½üÒ»´ÎÀëÏßʱ¼ä
|
cacheDict = GetCachePropDataDict(curCache)
|
if not cacheBase:
|
return cacheDict
|
for k, v in cacheBase.items():
|
cacheDict[k] = v
|
if isLogout:
|
if not IsSaveDBViewCache(curCache):
|
DeleteViewCache(playerID)
|
return {}
|
return cacheDict
|
|
ItemDataClassMax = 20 # ×î´ó×°±¸½×Êý
|
#//04 01 µØͼͬ²½Íæ¼Ò»º´æÊý¾Ýµ½GameServer#tagMGUpdatePlayerCache
|
#
|
#struct tagMGUpdatePlayerCache
|
#{
|
# tagHead Head;
|
# DWORD PlayerID; //Íæ¼ÒID
|
# WORD PlayerLV; //Íæ¼ÒµÈ¼¶
|
# BYTE IsLogouting; //±¾´ÎÊÇ·ñΪÏÂÏßͬ²½
|
# DWORD OffTime; // ÏÂÏßʱ¼ä´Á
|
# WORD PropDataSize;
|
# char PropData[PropDataSize]; //ÊôÐԼǼ
|
# WORD PlusDataSize;
|
# char PlusData[PlusDataSize]; //À©Õ¹¼Ç¼
|
# WORD ItemDataSize1;
|
# char ItemData1[ItemDataSize1]; //1½××°±¸Êý¾Ý
|
# ... ...
|
# WORD ItemDataSize20;
|
# char ItemData20[ItemDataSize20];
|
# BYTE PackDataSyncState; // ´ò°üÊý¾Ýͬ²½×´Ì¬£º 0-²»Í¬²½£»¸öλ-ÊÇ·ñͬ²½±¾·þ£»Ê®Î»-ÊÇ·ñͬ²½¿ç·þ
|
# DWORD PackDataLen;
|
# char PackData[PackDataLen];
|
# WORD PackMsgLen;
|
# char PackMsg[PackMsgLen];
|
#};
|
def OnMGUpdatePlayerCache(routeIndex, mapID, curPackData, tick):
|
playerID = curPackData.PlayerID
|
#playerLV = curPackData.PlayerLV
|
isLogout = curPackData.IsLogouting
|
packDataSyncState = curPackData.PackDataSyncState
|
packDataLen = curPackData.PackDataLen
|
GameWorld.DebugLog('µØͼͬ²½Íæ¼Ò»º´æ: isLogout=%s,packDataSyncState=%s,packDataLen=%s'
|
% (isLogout, packDataSyncState, packDataLen), playerID)
|
|
curCache = FindViewCache(playerID, True)
|
if not curCache:
|
return
|
curCache.LV = curPackData.PlayerLV
|
curCache.OffTime = curPackData.OffTime
|
curCache.PropDataDict = {} # ÿ´Î¸üÐÂÊý¾Ýʱ£¬ÖØÖÃ×ֵ仺´æ£¬Ï´λñȡʱÖØÐÂeval»º´æ
|
curCache.PropData = curPackData.PropData
|
curCache.PropDataSize = curPackData.PropDataSize
|
curCache.PlusData = curPackData.PlusData
|
curCache.PlusDataSize = curPackData.PlusDataSize
|
|
#GameWorld.DebugLog(" ¸üÐÂPropÊý¾Ý: size=%s, %s" % (curCache.PropDataSize, curCache.PropData), playerID)
|
#GameWorld.DebugLog(" ¸üÐÂPlusÊý¾Ý: size=%s, %s" % (curCache.PlusDataSize, curCache.PlusData), playerID)
|
|
# ×°±¸Êý¾Ý´æ´¢£¬Ö»¸üÐÂÓÐͬ²½µÄ½×£¬Ö»Òª¸Ã½×ÓÐͬ²½£¬ÔòÖÁÉÙÊÇ {}
|
for classLV in xrange(1, ItemDataClassMax + 1):
|
itemDataSize = getattr(curPackData, "ItemDataSize%s" % classLV)
|
if not itemDataSize:
|
continue
|
itemData = getattr(curPackData, "ItemData%s" % classLV)
|
setattr(curCache, "ItemData%s" % classLV, itemData)
|
setattr(curCache, "ItemDataSize%s" % classLV, itemDataSize)
|
#GameWorld.DebugLog(" ¸üÐÂItemÊý¾Ý: classLV=%s,size=%s, %s" % (classLV, itemDataSize, itemData), playerID)
|
|
msgInfo = eval(curPackData.PackMsg) if curPackData.PackMsg else {} # ´ò°üÊý¾Ý¸½´øµÄÐÅÏ¢
|
|
# ÐèҪͬ²½¿ç·þ
|
if packDataSyncState&pow(2, 2):
|
dataMsg = {"playerID":playerID, "cacheBuffer":curCache.getBuffer(), "msgInfo":msgInfo}
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_PushPlayerCache, dataMsg)
|
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
# ÔÚ¿ÉÄÜɾ³ý֮ǰִÐдò°üÊý¾ÝÏà¹ØÂß¼
|
PlayerPackData.OnMGUpdatePlayerPackData(curPlayer, curPackData, msgInfo)
|
|
if isLogout:
|
#²»ÐèÒª±£´æÀëÏßÊý¾ÝµÄ£¬Ö±½Óɾ³ý»º´æÊý¾Ý
|
if not IsSaveDBViewCache(curCache):
|
DeleteViewCache(playerID)
|
return
|
if curPlayer:
|
curCache.GeTuiID = curPlayer.GetGeTuiClientID()
|
curCache.GeTuiIDSize = len(curCache.GeTuiID)
|
|
#GameWorld.DebugLog(" %s" % curCache.outputString())
|
# ͬ²½¸üÐÂÖúÕ½ÐÅÏ¢
|
if PlayerFBHelpBattle.IsInHelpBattleCheckInList(playerID):
|
PropDataDict = GetCachePropDataDict(curCache)
|
fightPower = PropDataDict.get("FightPower", 0)
|
familyID = PropDataDict.get("FamilyID", 0)
|
playerName = PropDataDict.get("Name", "")
|
PlayerFBHelpBattle.UpdateCheckInPlayerInfo(playerID, fightPower, familyID, playerName)
|
|
return
|
|
#//04 02 µØͼ²éѯÍæ¼Ò»º´æÊý¾Ý#tagMGQueryPlayerCache
|
#struct tagMGQueryPlayerCache
|
#{
|
# tagHead Head;
|
# DWORD PlayerID; //Íæ¼ÒID
|
# DWORD FindPlayerID; //Òª²éѯµÄÍæ¼ÒID
|
# BYTE EquipClassLV; //´óÓÚ0Ϊ²é¿´Ö¸¶¨¾³½ç½××°±¸ÐÅÏ¢, 0Ϊ²é¿´Ä¬ÈÏÐÅÏ¢
|
#};
|
def OnMGQueryPlayerCache(routeIndex, mapID, curPackData, tick):
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPackData.PlayerID)
|
findPlayerID = curPackData.FindPlayerID
|
equipClassLV = curPackData.EquipClassLV
|
OnQueryPlayerCache(curPlayer, findPlayerID, equipClassLV)
|
return
|
|
#// C0 02 ²é¿´¿ç·þÍæ¼ÒÐÅÏ¢ #tagCGViewCrossPlayerInfo
|
#
|
#struct tagCGViewCrossPlayerInfo
|
#{
|
# tagHead Head;
|
# DWORD PlayerID; // ¿ç·þÍæ¼ÒID
|
# BYTE EquipClassLV; //´óÓÚ0Ϊ²é¿´Ö¸¶¨¾³½ç½××°±¸ÐÅÏ¢, 0Ϊ²é¿´Ä¬ÈÏÐÅÏ¢
|
#};
|
def OnViewCrossPlayerInfo(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
tagPlayerID = clientData.PlayerID
|
equipClassLV = clientData.EquipClassLV
|
OnQueryPlayerCache(curPlayer, tagPlayerID, equipClassLV)
|
return
|
|
#===============================================================================
|
# //B3 06 ²éѯÍæ¼ÒµÄ¼ò¶ÌÐÅÏ¢ #tagCGViewPlayerShortInfo
|
# struct tagCGViewPlayerShortInfo
|
# {
|
# tagHead Head;
|
# DWORD PlayerID;
|
# };
|
#===============================================================================
|
def OnViewPlayerShortInfo(index, clientPack, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
tagPlayerID = clientPack.PlayerID
|
tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(tagPlayerID)
|
if tagPlayer:
|
answerPack = ChPyNetSendPack.tagGCAnswerPlayerShortInfo()
|
answerPack.Clear()
|
answerPack.PlayerID = clientPack.PlayerID
|
answerPack.PlayerName = tagPlayer.GetName()
|
answerPack.Job = tagPlayer.GetJob()
|
answerPack.LV = tagPlayer.GetLV()
|
answerPack.RealmLV = tagPlayer.GetOfficialRank()
|
answerPack.OnlineType = ChConfig.Def_Online
|
answerPack.IsInTeam = tagPlayer.GetTeamID() > 0
|
answerPack.ServerGroupID = PlayerControl.GetPlayerServerGroupID(tagPlayer)
|
answerPack.Face = tagPlayer.GetFace()
|
answerPack.FacePic = tagPlayer.GetFacePic()
|
NetPackCommon.SendFakePack(curPlayer, answerPack)
|
else:
|
OnQueryPlayerCache(curPlayer, tagPlayerID, isShort=1)
|
return
|
|
def OnQueryPlayerCache(curPlayer, tagPlayerID, equipClassLV=0, isShort=0):
|
'''²éѯÍæ¼Ò»º´æ£¬Ö§³ÖÖ±½ÓÔÚ±¾·þ»ò¿ç·þ²éѯÈÎÒâ·þÎñÆ÷Íæ¼Ò
|
@param tagPlayerID: Ä¿±êÍæ¼ÒID
|
@param equipClassLV: Ö¸¶¨²é¿´Ä³Ò»½××°±¸ÐÅÏ¢
|
@param isShort: ÊÇ·ñ²é¿´¼ò¶ÌÐÅÏ¢
|
'''
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.DebugLog("²é¿´Íæ¼Ò: tagPlayerID=%s,equipClassLV=%s,isShort=%s" % (tagPlayerID, equipClassLV, isShort), playerID)
|
# ÔÚ¿ç·þ·þÎñÆ÷²éѯ
|
if GameWorld.IsCrossServer():
|
curCache = FindViewCache(tagPlayerID)
|
if curCache:
|
GameWorld.DebugLog(" ÔÚ¿ç·þ²é¿´Íæ¼Ò¿ç·þÓÐÊý¾Ý£¬Ö±½Ó»Ø°ü! tagPlayerID=%s" % tagPlayerID, playerID)
|
Sync_PlayerCache(curPlayer, curCache, equipClassLV, isShort)
|
else:
|
GameWorld.DebugLog(" ÔÚ¿ç·þ²é¿´Íæ¼Ò¿ç·þÎÞÊý¾Ý£¬´Ó×Ó·þÀÈ¡! tagPlayerID=%s" % tagPlayerID, playerID)
|
viewFrom = 0
|
msgInfo = {"playerID":playerID, "tagPlayerID":tagPlayerID, "equipClassLV":equipClassLV, "isShort":isShort, "viewFrom":viewFrom}
|
dataMsg = {"tagPlayerID":tagPlayerID, "msgInfo":msgInfo}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PullPlayerViewCache, dataMsg)
|
|
# ÔÚ×Ó·þ·þÎñÆ÷²éѯ
|
else:
|
# ͬdbÍæ¼Ò
|
if PlayerControl.GetDBPlayerAccIDByID(tagPlayerID):
|
GameWorld.DebugLog(" ²é¿´Íæ¼Ò±¾·þÓÐÊý¾Ý£¬Ö±½Ó»Ø°ü! tagPlayerID=%s" % tagPlayerID, playerID)
|
curCache = FindViewCache(tagPlayerID)
|
Sync_PlayerCache(curPlayer, curCache, equipClassLV, isShort)
|
else:
|
if tagPlayerID in PyGameData.g_crossPlayerViewCache:
|
tick = GameWorld.GetGameWorld().GetTick()
|
curCache, cacheTick = PyGameData.g_crossPlayerViewCache[tagPlayerID]
|
if tick - cacheTick <= 1 * 60 * 1000:
|
GameWorld.DebugLog(" 1·ÖÖÓÄÚÖظ´²é¿´¿ç·þÍæ¼ÒÇÒ±¾·þÓÐÊý¾Ý£¬Ö±½Ó»Ø°ü! tagPlayerID=%s" % tagPlayerID, playerID)
|
Sync_PlayerCache(curPlayer, curCache, equipClassLV, isShort)
|
return
|
|
GameWorld.DebugLog(" ²é¿´Íæ¼Ò±¾·þûÓÐÊý¾Ý£¬·¢¿ç·þ²é! tagPlayerID=%s" % tagPlayerID, playerID)
|
viewFrom = GameWorld.GetServerGroupID()
|
dataMsg = {"playerID":playerID, "tagPlayerID":tagPlayerID, "equipClassLV":equipClassLV, "isShort":isShort, "viewFrom":viewFrom}
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_ViewPlayerCache, dataMsg)
|
return
|
|
def Sync_PlayerCache(curPlayer, curCache, equipClassLV=0, isShort=0):
|
## ͬ²½Íæ¼Ò»º´æ
|
|
if isShort:
|
Sync_PlayerShortInfo(curPlayer, curCache)
|
return
|
if not curCache:
|
PlayerControl.NotifyCode(curPlayer, "ViewPlayer_OffLine")
|
return
|
if equipClassLV:
|
itemData = ""
|
if hasattr(curCache, "ItemDataSize%s" % equipClassLV):
|
itemData = getattr(curCache, "ItemData%s" % equipClassLV)
|
sendPack = ChPyNetSendPack.tagSCPlayerEquipCacheResult()
|
sendPack.PlayerID = curCache.PlayerID
|
sendPack.EquipClassLV = equipClassLV
|
sendPack.ItemData = itemData
|
sendPack.ItemDataSize = len(sendPack.ItemData)
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
#»Ø°ü¿Í»§¶Ë
|
sendPack = ChPyNetSendPack.tagSCQueryPlayerCacheResult()
|
sendPack.PlayerID = curCache.PlayerID
|
sendPack.PropData = curCache.PropData
|
sendPack.PropDataSize = len(sendPack.PropData)
|
sendPack.PlusData = curCache.PlusData
|
sendPack.PlusDataSize = len(sendPack.PlusData)
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
def Sync_PlayerShortInfo(curPlayer, curCache):
|
if not curCache:
|
PlayerControl.NotifyCode(curPlayer, "ViewPlayer_OffLine")
|
return
|
answerPack = ChPyNetSendPack.tagGCAnswerPlayerShortInfo()
|
answerPack.Clear()
|
cacheDict = GetCachePropDataDict(curCache)
|
answerPack.PlayerID = curCache.PlayerID
|
answerPack.PlayerName = cacheDict["Name"]
|
answerPack.Job = cacheDict["Job"]
|
answerPack.LV = cacheDict["LV"]
|
answerPack.RealmLV = cacheDict["RealmLV"]
|
answerPack.OnlineType = ChConfig.Def_Offline
|
answerPack.Face = cacheDict.get("Face", 0)
|
answerPack.FacePic = cacheDict.get("FacePic", 0)
|
|
if GameWorld.IsCrossServer():
|
answerPack.ServerGroupID = cacheDict.get("ServerGroupID", 0)
|
else:
|
answerPack.ServerGroupID = GameWorld.GetServerGroupID()
|
NetPackCommon.SendFakePack(curPlayer, answerPack)
|
return
|
|
def OnPlayerFamilyChange(playerID, familyID, familyName):
|
GameWorld.DebugLog("ViewCache->OnPlayerFamilyChange", playerID)
|
curCache = FindViewCache(playerID)
|
if not curCache:
|
return
|
PropData = GetCachePropDataDict(curCache)
|
PropData["FamilyID"] = familyID
|
PropData["FamilyName"] = familyName
|
PropData = json.dumps(PropData, ensure_ascii=False).replace(" ", "")
|
curCache.PropData = PropData
|
curCache.PropDataSize = len(curCache.PropData)
|
return
|
|
def ClientServerMsg_ViewPlayerCache(serverGroupID, msgData):
|
playerID = msgData["playerID"]
|
tagPlayerID = msgData["tagPlayerID"]
|
GameWorld.DebugLog("ÊÕµ½×Ó·þ²é¿´¿ç·þÍæ¼ÒÐÅÏ¢: serverGroupID=%s,playerID=%s,tagPlayerID=%s" % (serverGroupID, playerID, tagPlayerID))
|
|
curCache = FindViewCache(tagPlayerID)
|
if curCache:
|
Send_CrossServerMsg_ViewPlayerCacheRet(curCache, msgData, serverGroupID)
|
else:
|
dataMsg = {"tagPlayerID":tagPlayerID, "msgInfo":msgData}
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_PullPlayerViewCache, dataMsg)
|
return
|
|
def Send_CrossServerMsg_ViewPlayerCacheRet(curCache, msgData, serverGroupID):
|
## ·¢ËͲ鿴Íæ¼Ò»º´æ½á¹û¸øÄ¿±ê×Ó·þ
|
msgData["cacheBuffer"] = curCache.getBuffer() if curCache else ""
|
CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_ViewPlayerCacheRet, msgData, [serverGroupID])
|
return
|
|
def ClientServerMsg_PushPlayerCache(serverGroupID, msgData):
|
## ÊÕµ½×Ó·þÍÆËÍÍæ¼Ò»º´æÐÅÏ¢
|
|
playerID = msgData["playerID"]
|
cacheBuffer = msgData["cacheBuffer"]
|
msgInfo = msgData.get("msgInfo", {})
|
|
curCache = None
|
if not cacheBuffer:
|
GameWorld.DebugLog("×Ó·þÍÆË͵ÄÍæ¼Ò»º´æÊý¾ÝΪ¿Õ! playerID=%s" % playerID, serverGroupID)
|
else:
|
curCache = FindViewCache(playerID, True)
|
__updCacheBufferToCacheObj(playerID, cacheBuffer, curCache)
|
|
if not msgInfo:
|
return
|
|
viewFrom = msgInfo.get("viewFrom", 0)
|
if viewFrom != 0:
|
# ÆäËû×Ó·þ²éѯµÄ£¬ÍÆË͸øÄ¿±ê·þÎñÆ÷
|
Send_CrossServerMsg_ViewPlayerCacheRet(curCache, msgInfo, viewFrom)
|
return
|
|
# ÔÚ¿ç·þ²éѯµÄ£¬Ö±½Ó»Ø°ü
|
viewPlayerID = msgInfo.get("playerID", 0)
|
if not viewPlayerID:
|
return
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(viewPlayerID)
|
if not curPlayer:
|
return
|
equipClassLV = msgInfo.get("equipClassLV", 0)
|
isShort = msgInfo.get("isShort", 0)
|
Sync_PlayerCache(curPlayer, curCache, equipClassLV, isShort)
|
return
|
|
def __updCacheBufferToCacheObj(playerID, cacheBuffer, cacheObj):
|
try:
|
TempCache.clear()
|
if TempCache.readData(cacheBuffer) == -1:
|
GameWorld.ErrLog("Íæ¼Ò»º´æÊý¾ÝreadDataʧ°Ü! playerID=%s" % playerID)
|
return
|
except:
|
GameWorld.ErrLog("Íæ¼Ò»º´æÊý¾ÝreadDataÒì³£! playerID=%s" % playerID)
|
return
|
if TempCache.PlayerID != playerID:
|
GameWorld.ErrLog("Íæ¼Ò»º´æÊý¾ÝreadDataºóÍæ¼ÒID²»Ò»ÖÂ! playerID=%s != cachePlayerID=%s" % (playerID, TempCache.PlayerID))
|
return
|
|
cacheObj.PropDataDict = {} # ÿ´Î¸üÐÂÊý¾Ýʱ£¬ÖØÖÃ×ֵ仺´æ£¬Ï´λñȡʱÖØÐÂeval»º´æ
|
cacheObj.PlayerID = TempCache.PlayerID
|
cacheObj.GeTuiIDSize = TempCache.GeTuiIDSize
|
cacheObj.GeTuiID = TempCache.GeTuiID
|
cacheObj.LV = TempCache.LV
|
cacheObj.OffTime = TempCache.OffTime
|
cacheObj.PropData = TempCache.PropData
|
cacheObj.PropDataSize = TempCache.PropDataSize
|
cacheObj.PlusData = TempCache.PlusData
|
cacheObj.PlusDataSize = TempCache.PlusDataSize
|
for classLV in xrange(1, ItemDataClassMax + 1):
|
itemDataSize = getattr(TempCache, "ItemDataSize%s" % classLV)
|
if not itemDataSize:
|
continue
|
itemData = getattr(TempCache, "ItemData%s" % classLV)
|
setattr(cacheObj, "ItemData%s" % classLV, itemData)
|
setattr(cacheObj, "ItemDataSize%s" % classLV, itemDataSize)
|
|
return True
|
|
def CrossServerMsg_ViewPlayerCacheRet(msgData, tick):
|
## ÊÕµ½¿ç·þ·þÎñÆ÷»Ø¸´µÄ²é¿´Íæ¼ÒÐÅÏ¢
|
playerID = msgData["playerID"]
|
tagPlayerID = msgData["tagPlayerID"]
|
cacheBuffer = msgData["cacheBuffer"]
|
equipClassLV = msgData["equipClassLV"]
|
isShort = msgData["isShort"]
|
|
curCache = None
|
if cacheBuffer:
|
if tagPlayerID in PyGameData.g_crossPlayerViewCache:
|
curCache = PyGameData.g_crossPlayerViewCache[tagPlayerID][0]
|
else:
|
curCache = PyGameDataStruct.tagPlayerViewCachePy()
|
if __updCacheBufferToCacheObj(tagPlayerID, cacheBuffer, curCache):
|
PyGameData.g_crossPlayerViewCache[tagPlayerID] = [curCache, tick] # ¸üÐÂÐÅÏ¢
|
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if curPlayer:
|
Sync_PlayerCache(curPlayer, curCache, equipClassLV, isShort)
|
return
|
|
def CrossServerMsg_PullPlayerViewCache(msgData):
|
## ÊÕµ½¿ç·þ·þÎñÆ÷ÀÈ¡Íæ¼ÒÍæ¼Ò»º´æÊý¾Ý
|
msgInfo = msgData["msgInfo"]
|
tagPlayerID = msgData["tagPlayerID"]
|
DoPullPlayerViewCache(tagPlayerID, msgInfo)
|
return
|
|
def DoPullPlayerViewCache(playerID, msgInfo):
|
if not PlayerControl.GetDBPlayerAccIDByID(playerID):
|
# ²»ÊDZ¾·þdbÍæ¼Ò²»´¦Àí
|
return
|
|
curCache = FindViewCache(playerID)
|
if curCache:
|
GameWorld.DebugLog("±¾·þÓлº´æÍæ¼ÒÊý¾Ý£¬Ö±½ÓÍƸø¿ç·þ!", playerID)
|
dataMsg = {"playerID":playerID, "cacheBuffer":curCache.getBuffer(), "msgInfo":msgInfo}
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_PushPlayerCache, dataMsg)
|
return
|
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
GameWorld.DebugLog("±¾·þÎÞ»º´æÍæ¼ÒÊý¾ÝÇÒ²»ÔÚÏߣ¬Ö±½Ó»Ø¿ÕÊý¾Ý¸ø¿ç·þ!", playerID)
|
dataMsg = {"playerID":playerID, "cacheBuffer":"", "msgInfo":msgInfo}
|
CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_PushPlayerCache, dataMsg)
|
return
|
|
GameWorld.DebugLog("Íæ¼ÒÔÚÏߵķ¢¸øµØͼͬ²½»º´æÊý¾Ý!", playerID)
|
# ÔÚÏßµÄת·¢¸øµØͼ
|
PlayerPackData.QueryPlayerResult_PlayerMirror(curPlayer, "PullPlayerViewCache", msgInfo)
|
return
|
