#!/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 CrossRealmPK
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
                
        if CrossRealmPK.IsCrossRealmPKPlayer(playerID, checkPreSeason=True):
            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