Project_SG_ServerCode.git

#!/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 PlayerControl 
import NetPackCommon 
import ChPyNetSendPack 
import IpyGameDataPY 
import IPY_GameWorld 
import ShareDefine 
import TurnAttack 
import DBDataMgr 
 
import random 
import time 
 
Key_UpdViewCacheTick = "UpdViewCacheTick" 
 
def OnDay(): 
    DelOutofTimeViewCacheData() 
    return 
 
def OnPlayerLogout(curPlayer): 
    if curPlayer.GetLV() < IpyGameDataPY.GetFuncCfg("PlayerViewCache", 1): 
        return 
     
    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 DelOutofTimeViewCacheData(): 
    ## É¾³ý¹ýÆÚµÄ²é¿´»º´æÊý¾Ý 
     
    playerManager = GameWorld.GetPlayerManager() 
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr() 
    for index in range(viewCacheMgr.GetCount())[::-1]: # ÓÐÉ¾³ýÐèµ¹Ðò±éÀú 
        viewCache = viewCacheMgr.At(index) 
        playerID = viewCache.GetPlayerID() 
        if playerID < ShareDefine.RealPlayerIDStart: 
            continue 
        curPlayer = playerManager.FindPlayerByID(playerID) 
        if curPlayer: 
            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 
     
    #Ä³¸ö¹¦ÄÜÖÐ²»ÄÜÉ¾³ýµÄ 
    #... 
     
     
    #ÅÅÐÐ°æÉÏµÄÄ¬ÈÏ±£Áô 
    billboardMgr = DBDataMgr.GetBillboardMgr() 
    for bType in ShareDefine.BillboardTypeAllList: 
        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 
             
    # ÒÔÉÏÊÇÏà¹Ø¹¦ÄÜÐèÒªÓÃµ½µÄÊý¾Ý£¬±Ø¶¨²»ÄÜÉ¾³ýµÄ 
     
    # ÒÔÏÂÊÇ±£Áô½üÆÚ»îÔ¾Íæ¼Ò£¬µÈ¼¶ÏÞÖÆ 
    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 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: 
        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: 
        curCache = UpdRobotViewCache(playerID) 
         
    # ¼ÙÍæ¼Ò£¬Ä¬ÈÏÌí¼Ó 
    elif ShareDefine.FackPlayerIDStart <= playerID <= ShareDefine.FackPlayerIDMax: 
        serverID = playerID % 100 + 1 # 1 ~ 100 ·þ 
        accID = "fake%s@test@s%s" % (playerID, serverID) 
        fightPower = random.randint(1000000, 100000000) # ÏÈËæ»ú£¬Íâ²ãÓÐÐèÒªµÄ»°ÔÙ×Ô¼ºÉèÖÃ 
         
        curCache = viewCacheMgr.AddPlayerViewCache(playerID) 
        curCache.SetPlayerName("%s%s" % (GameWorld.GbkToCode("ÉñÃØµÀÓÑ"), playerID)) 
        curCache.SetAccID(accID) 
        curCache.SetLV(random.randint(100, 200)) 
        curCache.SetJob(random.randint(1, 2)) 
        curCache.SetRealmLV(random.randint(5, 15)) 
        curCache.SetFightPowerTotal(fightPower) 
        curCache.SetServerID(serverID) 
        curCache.SetOffTime(int(time.time()) - random.randint(1, 3600 * 24 * 10)) # Ëæ»úÀëÏß 0~10Ìì 
         
    return curCache 
 
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 
     
    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.SetFamilyID(curPlayer.GetFamilyID()) 
    curCache.SetFamilyName(curPlayer.GetFamilyName()) 
    curCache.SetFamilyEmblemID(PlayerControl.GetFamilyEmblemID(curPlayer)) 
    curCache.SetTitleID(PlayerControl.GetTitleID(curPlayer)) 
    curCache.SetFightPowerTotal(PlayerControl.GetFightPower(curPlayer)) 
    curCache.SetServerID(GameWorld.GetPlayerServerID(curPlayer)) 
    if isOffline: 
        curCache.SetOffTime(int(time.time())) 
         
    # ×°±¸ 
    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()} 
         
    # ÕóÈÝ 
    lineupDict = {} 
    for lineupID in ShareDefine.LineupList: 
        lineupInfo = TurnAttack.GetPlayerLineupInfo(curPlayer, lineupID) 
        if not lineupInfo: 
            continue 
        lineupDict["%s" % lineupID] = lineupInfo 
     
    # ÆäËû 
     
    plusDict= {"Equip":equipDict, "Lineup":lineupDict} 
    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.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(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 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(), 
                 "ModelMark" : curCache.GetModelMark(), 
                 "FightPower" : curCache.GetFightPowerTotal(), 
                 "PlusData" : curCache.GetPlusDict(), 
                 } 
    return robotDict 
 
def UpdRobotViewCache(robotID): 
    ## ¸üÐÂ»úÆ÷ÈË²é¿´»º´æ 
    robotIpyData = IpyGameDataPY.GetIpyGameData("Robot", robotID) 
    if not robotIpyData: 
        return 
    try: 
        robotInfo = eval(robotIpyData.GetViewCache()) 
    except: 
        return 
     
    viewCacheMgr = DBDataMgr.GetPlayerViewCacheMgr() 
    curCache = viewCacheMgr.GetPlayerViewCache(robotID) 
    if not curCache: 
        curCache = viewCacheMgr.AddPlayerViewCache(robotID) 
    #curCache.SetAccID(dbPlayer.AccID) 
     
    curCache.SetPlayerName(robotInfo.get("PlayerName", "p%s" % robotID)) 
    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.SetModelMark(robotInfo.get("ModelMark", 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; 
#    BYTE        EquipClassLV;    //´óÓÚ0Îª²é¿´Ö¸¶¨¾³½ç½××°±¸ÐÅÏ¢,  0Îª²é¿´Ä¬ÈÏÐÅÏ¢ 
#}; 
def OnCMViewPlayerInfo(index, clientPack, tick): 
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index) 
     
    findPlayerID = clientPack.PlayerID 
    #equipClassLV = clientPack.EquipClassLV 
     
    clientPack = GetPack_ViewCache(findPlayerID) 
    if clientPack: 
        NetPackCommon.SendFakePack(curPlayer, clientPack) 
        return 
    if GameWorld.GetDBPlayerAccIDByID(findPlayerID): 
        PlayerControl.NotifyCode(curPlayer, "ViewPlayer_OffLine") 
        return 
     
    # ¿ç·þÍæ¼Ò·¢ËÍ¿ç·þ²éÑ¯£¬´ýÀ©Õ¹... 
     
    return 
 
def GetPack_ViewCache(playerID): 
    ## »ñÈ¡Í¬²½·â°ü - Íæ¼Ò²é¿´»º´æ 
    curCache = FindViewCache(playerID) 
    if not curCache: 
        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.TitleID = curCache.GetTitleID() 
    clientPack.ServerID = curCache.GetServerID() 
    clientPack.FightPower = curCache.GetFightPower() 
    clientPack.FightPowerEx = curCache.GetFightPowerEx() 
    clientPack.FamilyID = curCache.GetFamilyID() 
    clientPack.FamilyName = curCache.GetFamilyName() 
    clientPack.FamilyEmblemID = curCache.GetFamilyEmblemID() 
    clientPack.PlusData = curCache.GetPlusData() 
    clientPack.PlusDataSize = len(clientPack.PlusData) 
    return clientPack