#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerViewCache
#
# @todo:Íæ¼Ò»º´æ
# @author hxp
# @date 2025-5-22
# @version 1.0
#
# ÏêϸÃèÊö: Íæ¼Ò»º´æ
#
#-------------------------------------------------------------------------------
#"""Version = 2025-5-22 ÏÂÎç6:37:10"""
#-------------------------------------------------------------------------------

import ChConfig
import GameWorld
import PyMongoMain
import CrossPlayer
import PlayerFamily
import PlayerControl
import NetPackCommon
import ChPyNetSendPack
import IpyGameDataPY
import IPY_GameWorld
import PlayerOnline
import PlayerPreset
import PlayerBeauty
import PlayerGubao
import ShareDefine
import TurnAttack
import DBDataMgr
import CrossMsg

import random
import time

Key_UpdViewCacheTick = "UpdViewCacheTick"

def OnDay():
    DelOutofTimeViewCacheData()
    return

def OnPlayerLogout(curPlayer):
    
    playerID = curPlayer.GetPlayerID()
    curCache = FindViewCache(playerID)
    if not curCache:
        return
    
    UpdPlayerViewCache(curPlayer, True)
    if not IsSaveDBViewCache(curCache):
        DBDataMgr.GetPlayerViewCacheMgr().DelPlayerViewCache(curPlayer.GetPlayerID())
        return
    
    return

def OnCrossPlayerLogout(crossPlayer):
    playerID = crossPlayer.GetPlayerID()
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr()
    curCache = viewCacheMgr.GetPlayerViewCache(playerID)
    if not curCache:
        return
    
    if not IsSaveDBViewCache(curCache):
        viewCacheMgr.DelPlayerViewCache(playerID)
        return
    
    return

def DelOutofTimeViewCacheData():
    ## ɾ³ý¹ýÆڵIJ鿴»º´æÊý¾Ý
    
    crossPlayerMgr = CrossPlayer.GetCrossPlayerMgr()
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr()
    for index in range(viewCacheMgr.GetCount())[::-1]: # ÓÐɾ³ýÐèµ¹Ðò±éÀú
        viewCache = viewCacheMgr.At(index)
        playerID = viewCache.GetPlayerID()
        if playerID < ShareDefine.RealPlayerIDStart:
            continue
        crossPlayer = crossPlayerMgr.FindCrossPlayer(playerID)
        if crossPlayer:
            continue
        if IsSaveDBViewCache(viewCache):
            continue
        viewCacheMgr.DelPlayerViewCache(playerID)
        
    return

def IsSaveDBViewCache(viewCache):
    ## »º´æÊý¾ÝÊÇ·ñÈë¿â
    if not viewCache:
        return False
    
    playerID = viewCache.GetPlayerID()
    if playerID < ShareDefine.RealPlayerIDStart:
        #·ÇÕæʵÍæ¼Ò²»Èë¿â
        return False
        
    isCrossServer = GameWorld.IsCrossServer()
    
    #ij¸ö¹¦ÄÜÖв»ÄÜɾ³ýµÄ
    
    if PlayerFamily.IsFamilyNeedViewPlayer(playerID):
        return True
    
    #ÅÅÐаæÉϵÄĬÈϱ£Áô
    billboardMgr = DBDataMgr.GetBillboardMgr()
    billboardTypeList = ShareDefine.CrossBillboardTypeList if isCrossServer else ShareDefine.BillboardTypeList
    for bType in billboardTypeList:
        if bType in ShareDefine.FamilyBillboardList:
            continue
        groupList = billboardMgr.GetBillboardGroupList(bType)
        for billboardType, groupValue1, groupValue2 in groupList:
            billboardObj = billboardMgr.GetBillboard(billboardType, groupValue1, groupValue2)
            if billboardObj.FindByID(playerID):
                return True
            
    # ÒÔÉÏÊÇÏà¹Ø¹¦ÄÜÐèÒªÓõ½µÄÊý¾Ý£¬±Ø¶¨²»ÄÜɾ³ýµÄ
    
    # ÒÔÏÂÊDZ£Áô½üÆÚ»îÔ¾Íæ¼Ò£¬µÈ¼¶ÏÞÖÆ
    playerLV = viewCache.GetLV()
    if playerLV >= IpyGameDataPY.GetFuncCfg("PlayerViewCache", 1):
        maxDays = IpyGameDataPY.GetFuncCfg("PlayerViewCache", 2)
        if not maxDays:
            maxDays = 7 # ĬÈÏ7Ìì
        MaxTime = maxDays * 3600 * 24
        curTime = int(time.time())
        passTime = curTime - viewCache.GetOffTime()
        if passTime < MaxTime:
            return True
        
    return False

def FindBattleViewCache(playerID):
    ## »ñÈ¡¿ÉÕ½¶·µÄÍæ¼Ò»º´æ
    # @return: None-ÎÞ£»curCache-Óзµ»Ø¸Ã»º´æ¶ÔÏó
    curCache = FindViewCache(playerID)
    if not curCache:
        return
    plusDict = curCache.GetPlusDict()
    if "Lineup" not in plusDict:
        return
    return curCache

def FindViewCache(playerID):
    '''²éÕÒÍæ¼Ò»º´æ£¬Èç¹û²»´æÔÚ£¬Ôò»áÓжîÍâÂß¼­£¬Èç´Óredis¡¢dbÖ±½ÓÕÒ£¬
            ±¾·þÍæ¼ÒÀíÂÛÉÏÒ»¶¨Óв鿴»º´æ£¬ÒòΪÈç¹û²»´æÔÚ»áÖ±½Ó´Ódb¶Á£¬³ý·Ç¸ÃÍæ¼ÒÊý¾Ý±»É¾³ý
            ¿ç·þÍæ¼ÒÀíÂÛÉÏÒ²Ò»¶¨Óлº´æ£¬Ö»ÊÇͨ¹ý¿ç·þ»ò´Ó×Ó·þ²éѯ£¬ÑÓ³Ù»ñµÃ
            ¡¾×¢¡¿Íâ²ãµ÷ÓÃÒÀȻҪÅжÏÊÇ·ñÓÐÊý¾Ý
    '''
    
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr()
    curCache = viewCacheMgr.GetPlayerViewCache(playerID)
    if curCache:
        updCache = __CheckUpdViewCache(playerID)
        if updCache:
            curCache = updCache
            
    # ÕæʵÍæ¼Ò£¬½öÓÎÏ··þ¸üУ¬¿ç·þÖ±½ÓʹÓÃÓÎÏ··þͬ²½µÄ¼òÒªÐÅÏ¢£¬ÐèÒªÏêϸÐÅÏ¢µÄʱºòÖ±½ÓÈ¥Íæ¼ÒËùÔÚ·þ²éѯ
    elif playerID >= ShareDefine.RealPlayerIDStart and GameWorld.IsMainServer():
        curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
        # ±¾·þÔÚÏßÍæ¼Ò£¬Ö±½ÓÉú³ÉÐÂÊý¾Ý
        if curPlayer:
            curCache = viewCacheMgr.AddPlayerViewCache(playerID)
            UpdPlayerViewCache(curPlayer)
            
        # ±¾·þÀëÏßÍæ¼Ò
        elif GameWorld.GetDBPlayerAccIDByID(playerID):
            # ±¾·þÍæ¼Ò£¬´Óredis»òdb¶ÁÈ¡ÖØмÓÔضÁÈ¡£¬»»¾ä»°Ëµ£¬±¾·þÍæ¼ÒÖ»Òª»ñÈ¡Ò»¶¨Óв鿴»º´æÊý¾Ý
            curCache = UpdPlayerViewCacheByDB(playerID)
            
        # ¿ç·þÍæ¼Ò
        else:
            pass
            # ¿ç·þÍæ¼Ò£¬ÓÎÏ··þ²»´¦Àí£¬½ö¿ç·þ·þÎñÆ÷Ö§³Ö»ñÈ¡»ù´¡ÐÅÏ¢£¬ÓÎÏ··þÈç¹ûÒª²é¿´¿ç·þÍæ¼Ò£¬Ö±½ÓÈ¥Íæ¼ÒËùÔÚ·þ²éѯ
            
    # »úÆ÷ÈË
    #elif ShareDefine.RobotIDStart <= playerID <= ShareDefine.RobotIDMax:
    elif IpyGameDataPY.GetIpyGameDataNotLog("Robot", playerID):
        GameWorld.DebugLog("¼ÓÔØ»úÆ÷ÈË»º´æ: %s" % playerID)
        curCache = viewCacheMgr.AddPlayerViewCache(playerID)
        curCache = UpdRobotViewCache(curCache, playerID)
        
    # ¼ÙÍæ¼Ò£¬Ä¬ÈÏÌí¼Ó
    elif ShareDefine.FackPlayerIDStart <= playerID <= ShareDefine.FackPlayerIDMax:
        GameWorld.DebugLog("¼ÓÔؼÙÍæ¼Ò»º´æ: %s" % playerID)
        # Ëæ»ú¸´ÖƸö»úÆ÷ÈËÊý¾Ý
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        robotIpyData = ipyDataMgr.GetRobotByIndex(random.randint(0, ipyDataMgr.GetRobotCount() - 1))
        
        curCache = viewCacheMgr.AddPlayerViewCache(playerID)
        curCache = UpdRobotViewCache(curCache, robotIpyData.GetID())
        
        # ÔÙ¸²¸Ç²¿·ÖÊý¾Ý
        serverID = playerID % 100 + 1 # 1 ~ 100 ·þ
        accID = "fake%s@test@s%s" % (playerID, serverID)
        #fightPower = random.randint(1000000, 100000000) # ÏÈËæ»ú£¬Íâ²ãÓÐÐèÒªµÄ»°ÔÙ×Ô¼ºÉèÖÃ
        
        curCache.SetPlayerName("%s%s" % (GameWorld.GbkToCode("Ö÷¹«"), playerID))
        curCache.SetAccID(accID)
        curCache.SetServerID(serverID)
        #curCache.SetLV(random.randint(100, 200))
        #curCache.SetJob(random.randint(1, 2))
        #curCache.SetRealmLV(random.randint(5, 15))
        #curCache.SetFightPowerTotal(fightPower)
        curCache.SetOffTime(int(time.time()) - random.randint(1, 3600 * 24 * 10)) # Ëæ»úÀëÏß 0~10Ìì
        
    return curCache

#def ResetCacheUpdTickByPresetSwitch(curPlayer, batPresetID):
#    for batPresetType in ChConfig.MapDefBatPresetTypeDict.values():
#        if batPresetID == PlayerPreset.GetBatPresetID(curPlayer, batPresetType):
#            curPlayer.SetDict(Key_UpdViewCacheTick, 0)
#            GameWorld.DebugLogEx("¹¦ÄÜÕ½¶·»º´æÓõ½¸ÃÁ÷ÅÉÔ¤É裬ÖØÖûº´æË¢ÐÂCD! batPresetType=%s,batPresetID=%s", batPresetType, batPresetID)
#            break
#    return

def __CheckUpdViewCache(playerID):
    if playerID < ShareDefine.RealPlayerIDStart:
        return
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
    if not curPlayer:
        return
    lastUpdTick = curPlayer.GetDictByKey(Key_UpdViewCacheTick)
    tick = GameWorld.GetGameWorld().GetTick()
    if lastUpdTick and tick - lastUpdTick < 60000:
        #GameWorld.DebugLog("1·ÖÖÓÄÚÖ»¸üÐÂÒ»´ÎÍæ¼Ò»º´æ", playerID)
        return
    curPlayer.SetDict(Key_UpdViewCacheTick, tick)
    return UpdPlayerViewCache(curPlayer)

def UpdPlayerViewCache(curPlayer, isOffline=False):
    '''¸üÐÂÍæ¼Ò²é¿´»º´æÊý¾Ý£¬¸üÐÂʱ»úÓÉÍâ²ã×Ô¼ºÅжϣ¬ÕâÀïÖ»×ö¸üÐÂÂß¼­
    1. ÏÂÏßʱǿÖƸüÐÂÒ»´Î£¬ÉÏÏßÔݲ»¸üУ¬ÉÏÏßʱÓɸ÷¹¦ÄÜÈç¹ûÓÐÐèÒªÓõ½´¥·¢¸üÐÂ
    2. ÓÐÐèÒªÓõ½»º´æÊý¾Ýʱ£¬Èç¹ûÍæ¼ÒÔÚÏߣ¬1·ÖÖÓÄÚ¶à´Î»ñȡʱ×î¶à¸üÐÂÒ»´Î£¬Ã»ÓлñÈ¡»º´æÊý¾ÝÔò²»¸üÐÂ
    '''
    if not curPlayer:
        return
    
    playerID = curPlayer.GetPlayerID()
    curCache = DBDataMgr.GetPlayerViewCacheMgr().GetPlayerViewCache(playerID)
    if not curCache:
        return
    
    familyID = curPlayer.GetFamilyID()
    #familyBase = DBDataMgr.GetFamilyMgr().GetFamilyViewBase(familyID)
    
    tick = GameWorld.GetGameWorld().GetTick()
    curPlayer.SetDict(Key_UpdViewCacheTick, tick)
    #GameWorld.DebugLog("¸üÐÂÍæ¼Ò²é¿´»º´æÊý¾Ý! isOffline=%s" % isOffline, playerID)
    curCache.SetAccID(curPlayer.GetAccID())
    curCache.SetPlayerName(curPlayer.GetPlayerName())
    curCache.SetLV(curPlayer.GetLV())
    curCache.SetJob(curPlayer.GetJob())
    curCache.SetRealmLV(curPlayer.GetOfficialRank())
    curCache.SetFace(curPlayer.GetFace())
    curCache.SetFacePic(curPlayer.GetFacePic())
    curCache.SetModelMark(curPlayer.GetModelMark())
    curCache.SetEquipShowSwitch(curPlayer.GetEquipShowSwitch())
    curCache.SetTitleID(PlayerControl.GetTitleID(curPlayer))
    curCache.SetFamilyID(familyID)
    #¹«»áÐÅÏ¢Óɹ«»áˢиüУ¬Íæ¼Ò³£¹æ¸üв»¸üй«»áÐÅÏ¢
    #curCache.SetFamilyName(familyBase.GetName())
    #curCache.SetFamilyEmblemID(familyBase.GetEmblemID())
    #curCache.SetFamilyEmblemWord(familyBase.GetEmblemWord())
    curCache.SetFightPowerTotal(PlayerControl.GetFightPower(curPlayer))
    curCache.SetServerID(GameWorld.GetPlayerServerID(curPlayer))
    curCache.SetOffTime(int(time.time()) if isOffline else 0)
    
    # ×°±¸
    equipDict = {}
    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    for equipPlace in ChConfig.Def_MainEquipPlaces:
        equipIndex = equipPlace - 1
        if equipIndex < 0 or equipIndex >= equipPack.GetCount():
            continue
        curEquip = equipPack.GetAt(equipIndex)
        if not curEquip or curEquip.IsEmpty():
            continue
        equipDict["%s" % equipIndex] = {"ItemID":curEquip.GetItemTypeID(), "UserData":curEquip.GetUserData()}
        
    olPlayer = PlayerOnline.GetOnlinePlayer(curPlayer)
    
    # Ô¤Éè¡¢ÕóÈÝ
    batPresetDict = {} # Õ½¶·Ô¤Éè·½°¸×éºÏ {"Õ½¶·¹¦ÄÜÔ¤Éè":{"¹¦ÄÜ·½°¸Ô¤Éè":¹¦ÄÜÔ¤ÉèID, ...}, ...}
    lineupDict, mgPresetDict = {}, {}
    for batPresetType in ShareDefine.NeedCacheBatPresetList:
        batPresetID = PlayerPreset.GetBatPresetID(curPlayer, batPresetType)
        #Î佫·½°¸°üº¬ÔÚ lineupInfo ÀïÁË£¬ËùÒÔ²»ÓÃÔÙÈ¡Î佫ԤÉè·½°¸
        #heroPresetID = PlayerPreset.GetFuncPresetID(curPlayer, batPresetID, ShareDefine.FuncPreset_Hero)
        mgPresetID = PlayerPreset.GetFuncPresetID(curPlayer, batPresetID, ShareDefine.FuncPreset_Mingge)
        
        # Õ½¶·Ô¤Éè·½°¸×éºÏ {"Õ½¶·¹¦ÄÜÔ¤Éè":{"¹¦ÄÜ·½°¸Ô¤Éè":¹¦ÄÜÔ¤ÉèID, ...}, ...}
        batPresetDict["%s" % batPresetType] = {str(ShareDefine.FuncPreset_Battle):batPresetID,
                                               str(ShareDefine.FuncPreset_Mingge):mgPresetID,
                                               }
        
        lineupInfo = TurnAttack.GetPlayerLineupInfo(curPlayer, batPresetType)
        if lineupInfo:
            batPresetID = lineupInfo.get("BatPresetID", batPresetID)
            if str(batPresetID) not in lineupDict:
                lineupDict["%s" % batPresetID] = lineupInfo
                
        # Ãü¸ñ·½°¸
        attrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Mingge, mgPresetID)
        skillLVDict = olPlayer.GetCalcSpecInfo(ChConfig.Def_CalcAttr_Mingge, mgPresetID)
        mgPresetDict["%s" % mgPresetID] = {"Attr":{str(k):v for k, v in attrDict.items()}, "Skill":skillLVDict}
        
    # Ãü¸ñ£º¸ÐÎò¾³½çµÈ¼¶¡¢ÊôÐÔ¡¢ÒѼ¤»îÒâÏóЧ¹ûºÍ²ãÊý
    minggeDict = {"GWLV":curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MGGanwuLV), "Preset":mgPresetDict}
    
    # ¹Å±¦£ºÊýÁ¿¡¢ÊôÐÔ
    attrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Gubao)
    actCnt = PlayerGubao.GetGubaoTotalCnt(curPlayer)
    gubaoDict = {"Cnt":actCnt, "Attr":{str(k):v for k, v in attrDict.items()}}
    
    # ºìÑÕ
    attrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Beauty)
    actCnt = PlayerBeauty.GetBeautyActCnt(curPlayer)
    beautyDict = {"Cnt":actCnt, "Attr":{str(k):v for k, v in attrDict.items()}}
    
    # ×øÆï
    attrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Horse)
    horseLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorseLV)
    classLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorseClassLV)
    horseDict = {"LV":horseLV, "ClassLV":classLV, "Attr":{str(k):v for k, v in attrDict.items()}}
    
    plusDict = {"Equip":equipDict, "BatPreset":batPresetDict, "Lineup":lineupDict, "Mingge":minggeDict, 
                "Beauty":beautyDict, "Horse":horseDict, "Gubao":gubaoDict}
    curCache.SetPlusDict(plusDict)
    
    return curCache

def UpdPlayerViewCacheByDB(playerID):
    '''¸üÐÂÍæ¼Ò²é¿´»º´æÊý¾Ý£¬Ö±½Ó´ÓdbÊý¾Ý¸üУ¬½ö¸üÐÂdbPlayer±íÓеÄÊôÐÔ£¬
    '''
    curCache = None
    dbPlayer = PyMongoMain.GetUserCtrlDB().findDBPlayer(playerID)
    if not dbPlayer:
        GameWorld.ErrLog("UpdPlayerViewCacheByDBÕÒ²»µ½Íæ¼Ò!", playerID)
        return curCache
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr()
    curCache = viewCacheMgr.GetPlayerViewCache(playerID)
    if not curCache:
        curCache = viewCacheMgr.AddPlayerViewCache(playerID)
    familyID = dbPlayer.FamilyID
    GameWorld.DebugLog("db²éÕÒÖ±½Ó¸üÐÂÍæ¼Ò²é¿´»º´æÊý¾Ý!", playerID)
    curCache.SetAccID(dbPlayer.AccID)
    curCache.SetPlayerName(dbPlayer.PlayerName)
    curCache.SetLV(dbPlayer.LV)
    curCache.SetJob(dbPlayer.Job)
    curCache.SetRealmLV(dbPlayer.OfficialRank)
    curCache.SetFace(dbPlayer.Face)
    curCache.SetFacePic(dbPlayer.FacePic)
    curCache.SetModelMark(dbPlayer.ModelMark)
    curCache.SetEquipShowSwitch(dbPlayer.EquipShowSwitch)
    curCache.SetTitleID(dbPlayer.ExAttr3)
    curCache.SetFamilyID(familyID)
    #familyBase = DBDataMgr.GetFamilyMgr().GetFamilyViewBase(familyID)
    #curCache.SetFamilyName(familyBase.GetName())
    #curCache.SetFamilyEmblemID(familyBase.GetEmblemID())
    #curCache.SetFamilyEmblemWord(familyBase.GetEmblemWord())
    curCache.SetFightPowerTotal(dbPlayer.FightPowerEx * ChConfig.Def_PerPointValue + dbPlayer.FightPower)
    curCache.SetServerID(GameWorld.GetAccIDServerID(dbPlayer.AccID))
    curCache.SetOffTime(GameWorld.ChangeTimeStrToNum(dbPlayer.LogoffTime) if dbPlayer.LogoffTime else 0)
    return curCache

def UpdPlayerViewFamilyInfo(playerID, familyID, familyName, emblemID, emblemWord):
    ## Íæ¼Ò¹«»áË¢ÐÂʱ¸üУ¬¼æÈݱ¾·þ»ò¿ç·þ»Ø´«»ØÀ´¸üУ¬¿ç·þ×Ô¼ºÒ²¸üУ¬±¾·þÒ²¸üÐÂ
    curCache = DBDataMgr.GetPlayerViewCacheMgr().GetPlayerViewCache(playerID)
    if not curCache:
        return
    curCache.SetFamilyID(familyID)
    curCache.SetFamilyName(familyName)
    curCache.SetFamilyEmblemID(emblemID)
    curCache.SetFamilyEmblemWord(emblemWord)
    return

def GetPlayerBaseViewInfo(playerID, curPlayer=None):
    ## »ñÈ¡Íæ¼Ò»ù´¡²é¿´ÐÅÏ¢
    baseInfo = {}
    if not curPlayer:
        curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
    if curPlayer:
        baseInfo = {
                    "Name":curPlayer.GetPlayerName(),
                    "LV":curPlayer.GetLV(),
                    "Job":curPlayer.GetJob(),
                    "RealmLV":curPlayer.GetOfficialRank(),
                    "Face":curPlayer.GetFace(),
                    "FacePic":curPlayer.GetFacePic(),
                    "TitleID":PlayerControl.GetTitleID(curPlayer),
                    "FamilyID":curPlayer.GetFamilyID(),
                    "ServerID":GameWorld.GetPlayerServerID(curPlayer),
                    "FightPower":PlayerControl.GetFightPower(curPlayer),
                    }
    else:
        viewCache = FindViewCache(playerID)
        if viewCache:
            baseInfo = {
                        "Name":viewCache.GetPlayerName(),
                        "LV":viewCache.GetLV(),
                        "Job":viewCache.GetJob(),
                        "RealmLV":viewCache.GetRealmLV(),
                        "Face":viewCache.GetFace(),
                        "FacePic":viewCache.GetFacePic(),
                        "TitleID":viewCache.GetTitleID(),
                        "FamilyID":viewCache.GetFamilyID(),
                        "ServerID":viewCache.GetServerID(),
                        "FightPower":viewCache.GetFightPowerTotal(),
                        }
    return baseInfo

def UpdPlayerBaseViewInfo(playerID, baseInfo, isOffline):
    ## ¸üÐÂÍæ¼Ò»ù´¡²é¿´ÐÅÏ¢£¬Ò»°ã¿ç·þ·þÎñÆ÷Óã¬ÓÉÓÎÏ··þͬ²½¹ýÀ´
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr()
    curCache = viewCacheMgr.GetPlayerViewCache(playerID)
    if not curCache:
        curCache = viewCacheMgr.AddPlayerViewCache(playerID)
    curCache.SetPlayerName(baseInfo.get("Name", curCache.GetPlayerName()))
    curCache.SetLV(baseInfo.get("LV", curCache.GetLV()))
    curCache.SetJob(baseInfo.get("Job", curCache.GetJob()))
    curCache.SetRealmLV(baseInfo.get("RealmLV", curCache.GetRealmLV()))
    curCache.SetFace(baseInfo.get("Face", curCache.GetFace()))
    curCache.SetFacePic(baseInfo.get("FacePic", curCache.GetFacePic()))
    curCache.SetTitleID(baseInfo.get("TitleID", curCache.GetTitleID()))
    curCache.SetFamilyID(baseInfo.get("FamilyID", curCache.GetFamilyID()))
    curCache.SetServerID(baseInfo.get("ServerID", curCache.GetServerID()))
    curCache.SetFightPowerTotal(baseInfo.get("FightPower", curCache.GetFightPowerTotal()))
    curCache.SetOffTime(int(time.time()) if isOffline else 0)
    return curCache

def GetRobotByViewCache(curCache):
    ## ¸ù¾Ý»º´æÄÚÈÝ»ñÈ¡»úÆ÷ÈËÊý¾Ý
    if not curCache:
        return
    robotDict = {
                 "PlayerName" : curCache.GetPlayerName(),
                 "LV" : curCache.GetLV(),
                 "Job" : curCache.GetJob(),
                 "RealmLV" : curCache.GetRealmLV(),
                 "Face" : curCache.GetFace(),
                 "FacePic" : curCache.GetFacePic(),
                 "TitleID" : curCache.GetTitleID(),
                 "ModelMark" : curCache.GetModelMark(),
                 "EquipShowSwitch" : curCache.GetEquipShowSwitch(),
                 "FightPower" : curCache.GetFightPowerTotal(),
                 "PlusData" : curCache.GetPlusDict(),
                 }
    return robotDict

def LoadRobot():
    ## ¼ÓÔØ»úÆ÷ÈË»º´æ£¬ÔÚ·þÎñÆ÷Æô¶¯¡¢ÖضÁÅäÖÃʱ¼ÓÔØ
    robotFPSortList = []
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr()
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in range(ipyDataMgr.GetRobotCount()):
        ipyData = ipyDataMgr.GetRobotByIndex(index)
        robotPlayerID = ipyData.GetID()
        curCache = viewCacheMgr.GetPlayerViewCache(robotPlayerID)
        if not curCache:
            curCache = viewCacheMgr.AddPlayerViewCache(robotPlayerID)
        if not curCache:
            continue
        UpdRobotViewCache(curCache, robotPlayerID, ipyData)
        robotFPSortList.append([curCache.GetFightPowerTotal(), robotPlayerID])
    robotFPSortList.sort(reverse=True) # Õ½Á¦µ¹ÐòÅÅÐò
    IpyGameDataPY.SetConfigEx("robotFPSortList", robotFPSortList)
    GameWorld.Log("¼ÓÔØ»úÆ÷ÈËÕ½Á¦ÅÅÐò: %s, %s" % (len(robotFPSortList), robotFPSortList))
    return robotFPSortList

def GetRobotFightPowerSortList():
    ## »úÆ÷ÈËÕ½Á¦µ¹ÐòÅÅÐòÁбí
    # @return: µ¹ÐòÅÅÐòÁбí [[Õ½Á¦, »úÆ÷ÈËID], ...]£¬ÍⲿʹÓÿÉËæ»úÐ޸ģ¬²»»á´òÂÒԭʼÅÅÐò
    sortList = []
    robotFPSortList = IpyGameDataPY.GetConfigEx("robotFPSortList")
    if not robotFPSortList:
        robotFPSortList = LoadRobot()
    if robotFPSortList:
        sortList += robotFPSortList
    return sortList

def UpdRobotViewCache(curCache, robotID, robotIpyData=None):
    ## ¸üлúÆ÷È˲鿴»º´æ
    if not robotIpyData:
        robotIpyData = IpyGameDataPY.GetIpyGameData("Robot", robotID)
    if not robotIpyData:
        return
    try:
        robotInfo = eval(robotIpyData.GetViewCache())
    except:
        return
    
    #curCache.SetAccID(dbPlayer.AccID)
    
    curCache.SetPlayerName(GameWorld.GbkToCode(robotIpyData.GetRobotName()))
    curCache.SetLV(robotInfo.get("LV", 1))
    curCache.SetJob(robotInfo.get("Job", 1))
    curCache.SetRealmLV(robotInfo.get("RealmLV", 0))
    curCache.SetFace(robotInfo.get("Face", 0))
    curCache.SetFacePic(robotInfo.get("FacePic", 0))
    curCache.SetTitleID(robotInfo.get("TitleID", 0))
    curCache.SetModelMark(robotInfo.get("ModelMark", 0))
    curCache.SetEquipShowSwitch(robotInfo.get("EquipShowSwitch", 0))
    #»úÆ÷ÈËÔݶ¨Ã»ÓÐÏÉÃË¡¢³ÆºÅ
    #curCache.SetFamilyID(familyID)
    #family = DBDataMgr.GetFamilyMgr().FindFamily(familyID)
    #curCache.SetFamilyName(family.GetName() if family else "")
    #curCache.SetFamilyEmblemID(family.GetEmblemID() if family else 0)
    #curCache.SetTitleID(PlayerControl.GetTitleID(curPlayer))
    curCache.SetFightPowerTotal(robotInfo.get("FightPower", 1))
    curCache.SetServerID(GameWorld.GetGameWorld().GetServerID()) # ĬÈϱ¾·þ
    curCache.SetPlusDict(robotInfo.get("PlusData", {}))
    #curCache.SetOffTime(0)
    return curCache

#//A2 12 ²é¿´Íæ¼ÒÏêϸÐÅÏ¢#tagCMViewPlayerInfo
#struct tagCMViewPlayerInfo
#{
#    tagHead        Head;
#    DWORD        PlayerID;
#    DWORD        ServerID;        //Íæ¼Ò·þÎñÆ÷ID£¬·¢0ĬÈϱ¾·þÍæ¼Ò
#};
def OnCMViewPlayerInfo(index, clientPack, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    
    tagPlayerID = clientPack.PlayerID
    tagServerID = clientPack.ServerID
    
    # ±¾·þ»òÖ÷·þÊDZ¾·þ
    if not tagServerID or tagServerID == GameWorld.GetGameWorld().GetServerID():
        NetPackCommon.SendFakePack(curPlayer, GetPack_ViewCache(tagPlayerID))
        return
    
    # Ö±½ÓȥĿ±ê·þÎñÆ÷²éѯ
    CrossMsg.SendToServer(ShareDefine.S2S_ViewTagPlayer, {"tagPlayerID":tagPlayerID}, [tagServerID], ShareDefine.dirType_All, playerID)
    return

def S2S_ViewTagPlayer(dataMsg, fromServerID, playerID):
    tagPlayerID = dataMsg["tagPlayerID"]
    CrossPlayer.SendFakePackByID(playerID, GetPack_ViewCache(tagPlayerID), fromServerID)
    return

def GetPack_ViewCache(playerID):
    ## »ñȡͬ²½·â°ü - Íæ¼Ò²é¿´»º´æ
    curCache = FindViewCache(playerID)
    if not curCache:
        GameWorld.ErrLog("²é¿´Íæ¼ÒÕÒ²»µ½Ä¿±ê! playerID=%s" % playerID)
        return
    clientPack = ChPyNetSendPack.tagSCQueryPlayerCacheResult()
    clientPack.PlayerID = curCache.GetPlayerID()
    clientPack.PlayerName = curCache.GetPlayerName()
    clientPack.LV = curCache.GetLV()
    clientPack.Job = curCache.GetJob()
    clientPack.RealmLV = curCache.GetRealmLV()
    clientPack.Face = curCache.GetFace()
    clientPack.FacePic = curCache.GetFacePic()
    clientPack.ModelMark = curCache.GetModelMark()
    clientPack.EquipShowSwitch = curCache.GetEquipShowSwitch()
    clientPack.TitleID = curCache.GetTitleID()
    clientPack.ServerID = curCache.GetServerID()
    clientPack.FightPower = curCache.GetFightPower()
    clientPack.FightPowerEx = curCache.GetFightPowerEx()
    familyID = curCache.GetFamilyID()
    familyDataServerID = DBDataMgr.GetFamilyMgr().GetCurCrossServerID()
    if familyDataServerID <= 0:
        familyDataServerID = GameWorld.GetGameWorld().GetServerID() # ¹«»áδ¿ç·þʱĬÈϾÍÊÇÍæ¼ÒËùÔÚ·þ
    clientPack.FamilyID = familyID
    clientPack.FamilyName = curCache.GetFamilyName()
    clientPack.FamilyEmblemID = curCache.GetFamilyEmblemID()
    clientPack.FamilyEmblemWord = curCache.GetFamilyEmblemWord()
    clientPack.FamilyDataServerID = familyDataServerID
    clientPack.PlusData = curCache.GetPlusData()
    clientPack.PlusDataSize = len(clientPack.PlusData)
    return clientPack