#!/usr/bin/python  
 | 
# -*- coding: GBK -*-  
 | 
#-------------------------------------------------------------------------------  
 | 
#  
 | 
##@package CrossRealmMsg  
 | 
#  
 | 
# @todo:¿ç·þÐÅÏ¢¹ÜÀí  
 | 
# @author hxp  
 | 
# @date 2018-12-21  
 | 
# @version 1.0  
 | 
#  
 | 
# ÏêϸÃèÊö: ¿ç·þÐÅÏ¢¹ÜÀí  
 | 
#  
 | 
#-------------------------------------------------------------------------------  
 | 
#"""Version = 2018-12-21 18:00"""  
 | 
#-------------------------------------------------------------------------------  
 | 
  
 | 
import GameWorld  
 | 
import ShareDefine  
 | 
import PlayerControl  
 | 
import IPY_GameServer  
 | 
import CrossRealmPlayer  
 | 
import PlayerCompensation  
 | 
import GameWorldBoss  
 | 
import CrossRealmPK  
 | 
import PlayerQuery  
 | 
import PlayerTalk  
 | 
import CrossBoss  
 | 
import ChConfig  
 | 
import PlayerFB  
 | 
import GMShell  
 | 
  
 | 
import traceback  
 | 
import cPickle  
 | 
  
 | 
def SendMsgToCrossServer(msgType, dataMsg):  
 | 
    ## ·¢ËÍÐÅÏ¢µ½¿ç·þ·þÎñÆ÷ÉÏ  
 | 
    if GameWorld.IsCrossServer():  
 | 
        return  
 | 
    if not dataMsg:  
 | 
        return  
 | 
      
 | 
    # ÐÒéÒªÓÃ×î¸ß¼¶2£¬¿É¼õÉÙ³¤¶È  
 | 
    srcMsg = {"MsgType":msgType, "Data":dataMsg, "ServerGroupID":GameWorld.GetServerGroupID()}  
 | 
    sendMsg = cPickle.dumps(srcMsg, 2)  
 | 
    if not GameWorld.GetGameWorld().GetDictByKey(ChConfig.Def_WorldKey_GameWorldInitOK):  
 | 
        GameWorld.ErrLog("·þÎñÆ÷δÆô¶¯ºÃ,²»ÔÊÐíÏò¿ç·þ·þÎñÆ÷·¢ËÍÊý¾Ý! %s" % (srcMsg))  
 | 
        return  
 | 
    GameWorld.Log("SendMsgToCrossServer => %s" % (srcMsg))     
 | 
    GameWorld.GetGameWorld().SendMergerChildToCenterStringData(sendMsg, len(sendMsg))  
 | 
    return  
 | 
  
 | 
def OnCrossServerReceiveMsg(recvMsg, tick):  
 | 
    ## ¿ç·þ·þÎñÆ÷ÊÕµ½ÐÅÏ¢´¦Àí  
 | 
    try:  
 | 
        GameWorld.Log("ÊÕµ½OnCrossServerReceiveMsg" )  
 | 
        if not GameWorld.GetGameWorld().GetDictByKey(ChConfig.Def_WorldKey_GameWorldInitOK):  
 | 
            GameWorld.Log("·þÎñÆ÷δÆô¶¯ºÃ£¬²»´¦Àí×Ó·þÐÅÏ¢!")  
 | 
            return  
 | 
        msgDict = cPickle.loads(recvMsg)  
 | 
          
 | 
        GameWorld.Log("OnCrossServerReceiveMsg: %s" % msgDict)  
 | 
          
 | 
        msgType = msgDict.get("MsgType", -1)      
 | 
        msgData = msgDict.get("Data", "")  
 | 
        serverGroupID = msgDict.get("ServerGroupID", 0)  
 | 
          
 | 
        if msgType == ShareDefine.ClientServerMsg_PKMatch:  
 | 
            CrossRealmPK.ClientServerMsg_PKMatch(serverGroupID, msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_PKRobotOver:  
 | 
            CrossRealmPK.ClientServerMsg_PKRobotOver(serverGroupID, msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_PKCancel:  
 | 
            CrossRealmPK.ClientServerMsg_PKCancel(msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_PKPrepareOK:  
 | 
            CrossRealmPK.ClientServerMsg_PKPrepareOK(msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_PKBillboard:  
 | 
            CrossRealmPK.ClientServerMsg_PKBillboard(serverGroupID, msgData)  
 | 
                          
 | 
        elif msgType == ShareDefine.ClientServerMsg_ChatCrossWorld:  
 | 
            PlayerTalk.ClientServerMsg_ChatCrossWorld(serverGroupID, msgData, tick)  
 | 
                          
 | 
        elif msgType == ShareDefine.ClientServerMsg_GMCMD:  
 | 
            GMShell.ClientServerMsg_GMCMD(msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_ServerInitOK:  
 | 
            ClientServerMsg_ServerInitOK(serverGroupID, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_ViewPlayerCache:  
 | 
            CrossRealmPlayer.ClientServerMsg_ViewPlayerCache(serverGroupID, msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_QueryNPCInfo:  
 | 
            PlayerQuery.ClientServerMsg_QueryNPCInfo(serverGroupID, msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_EnterFB:  
 | 
            PlayerFB.ClientServerMsg_EnterFB(serverGroupID, msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_SetPlayerAttrValue:  
 | 
            MapServer_CrossSetPlayerAttrValue(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.ClientServerMsg_AddBuff:  
 | 
            MapServer_CrossAddBuff(msgData)  
 | 
              
 | 
        # ÐèÒª·¢Ë͵½µØÍ¼·þÎñÆ÷´¦ÀíµÄ  
 | 
        elif msgType in [ShareDefine.ClientServerMsg_Reborn, ShareDefine.ClientServerMsg_CollectNPC]:  
 | 
            MapServer_CrossServerReceiveMsg(msgType, msgData, serverGroupID)  
 | 
              
 | 
        else:  
 | 
            GameWorld.ErrLog("ûÓиÃÐÅÏ¢ÀàÐÍÂß¼´¦Àí£¡")  
 | 
              
 | 
    except:  
 | 
        GameWorld.ErrLog("OnCrossServerReceiveMsg:%s; except:%s" % (cPickle.loads(recvMsg), traceback.format_exc()))  
 | 
        if GameWorld.GetGameWorld().GetDebugLevel():  
 | 
            raise BaseException(str(traceback.format_exc()))  
 | 
    return  
 | 
  
 | 
def ClientServerMsg_ServerInitOK(serverGroupID, tick):  
 | 
    ''' ÊÕµ½×Ó·þÁ¬½Ó³É¹¦Í¨Öª   
 | 
         µ±×Ó·þÆô¶¯³É¹¦ºó£¬¿Éͬ²½Ò»´Î¿ç·þ·þÎñÆ÷»î¶¯×´Ì¬¼°»î¶¯Êý¾Ý¸ø×Ó·þ  
 | 
    '''  
 | 
    GameWorld.Log("ÊÕµ½¿ç·þ×Ó·þÁ¬½Ó³É¹¦Í¨Öª! serverGroupID=%s" % serverGroupID)  
 | 
    Sync_CrossServerInitDataToClientServer(tick, serverGroupID)  
 | 
    return  
 | 
  
 | 
def Sync_CrossServerInitDataToClientServer(tick, serverGroupID=0):  
 | 
    ''' Í¬²½¿ç·þ¹¦ÄÜÊý¾Ýµ½×Ó·þ·þÎñÆ÷  
 | 
        ±¾º¯Êýµ÷ÓÃʱ»ú£º  
 | 
        1.¿ç·þ·þÎñÆ÷Æô¶¯³É¹¦£¬Ö÷¶¯¹ã²¥Í¬²½ËùÓÐ×Ó·þ£¬´ËʱÉèÖàserverGroupID Îª 0  
 | 
        2.×Ó·þÆô¶¯³É¹¦£¬ÓÉ×Ó·þÖ÷¶¯·¢ÆðÇëÇóͬ²½×îÐÂÊý¾Ý£¬´ËʱÓÐÖ¸¶¨×Ó·þ serverGroupID  
 | 
        3.×Ó·þÖØÐÂÁ¬½Ó¿ç·þ·þÎñÆ÷³É¹¦£¬Â߼ͬ2  
 | 
        @param serverGroupID: ×Ó·þ·þÎñÆ÷×éID£¬Îª0ʱΪȫ²¿×Ó·þÎñÆ÷×é  
 | 
    '''  
 | 
    CrossRealmPlayer.Sync_CrossCommInitDataToClientServer(serverGroupID)  
 | 
    CrossRealmPK.Sync_CrossPKInitDataToClientServer(tick, serverGroupID)  
 | 
    CrossBoss.Sync_CrossBossInitDataToClientServer(serverGroupID)  
 | 
    return  
 | 
  
 | 
def MapServer_CrossServerReceiveMsg(msgType, msgData, serverGroupID):  
 | 
    ## ÊÕµ½×Ó·þÐÅÏ¢£¬ÐèÒª·¢Ë͵½µØÍ¼·þÎñÆ÷´¦Àí  
 | 
      
 | 
    if not isinstance(msgData, dict):  
 | 
        return  
 | 
    tagPlayerID = msgData.get("PlayerID")  
 | 
    if not tagPlayerID:  
 | 
        return  
 | 
    tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(tagPlayerID)  
 | 
    if not tagPlayer:  
 | 
        return  
 | 
    msgInfo = str([msgType, msgData, serverGroupID])  
 | 
    tagPlayer.MapServer_QueryPlayerResult(0, 0, "CrossServerReceiveMsg", msgInfo, len(msgInfo))  
 | 
    return  
 | 
  
 | 
def MapServer_CrossSetPlayerAttrValue(msgData):  
 | 
    for playerID, setAttrInfoList in msgData.items():  
 | 
        player = GameWorld.GetPlayerManager().FindPlayerByID(playerID)  
 | 
        if not player:  
 | 
            return  
 | 
        msgInfo = str(setAttrInfoList)  
 | 
        player.MapServer_QueryPlayerResult(0, 0, "CrossSetPlayerAttrValue", msgInfo, len(msgInfo))  
 | 
    return  
 | 
  
 | 
def MapServer_CrossAddBuff(msgData):  
 | 
    ## ÊÕµ½×Ó·þÐÅÏ¢£¬Ìí¼Óbuff  
 | 
    tagPlayerID = msgData.get("PlayerID")  
 | 
    if not tagPlayerID:  
 | 
        return  
 | 
    tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(tagPlayerID)  
 | 
    if not tagPlayer:  
 | 
        return  
 | 
    buffID = msgData.get("buffID")  
 | 
    if not buffID:  
 | 
        return  
 | 
    sendMsg = str(buffID)  
 | 
    tagPlayer.MapServer_QueryPlayerResult(0, 0, 'AddBuff', sendMsg, len(sendMsg))  
 | 
    return  
 | 
## ================================================================================================  
 | 
  
 | 
def SendMsgToClientServer(msgType, dataMsg, serverGroupIDList=[]):  
 | 
    ''' ¹ã²¥ÐÅÏ¢µ½×Ó·þÎñÆ÷ÉÏ  
 | 
        @param serverGroupIDList: ·¢ËÍÖ¸¶¨µÄ·þÎñÆ÷×éIDÁÐ±í£¬ÄÚ²¿ÒѾÕë¶ÔÁбíÖÐ×éIDÈ¥ÖØ£¬  
 | 
        ËùÒÔÍⲿÂß¼¿ÉÖ±½ÓÌí¼Ó£¬²»Óÿ¼ÂÇ×éIDÖØ¸´ÎÊÌ⣬ûÓÐÖ¸¶¨·þÎñÆ÷×éIDʱ£¬Ä¬ÈϹ㲥ËùÓÐ×Ó·þ  
 | 
    '''  
 | 
    if not GameWorld.IsCrossServer():  
 | 
        return  
 | 
    if not dataMsg:  
 | 
        return  
 | 
      
 | 
    srcMsg = {"MsgType":msgType, "Data":dataMsg}  
 | 
    sendMsg = cPickle.dumps(srcMsg, 2)  
 | 
    if not GameWorld.GetGameWorld().GetDictByKey(ChConfig.Def_WorldKey_GameWorldInitOK):  
 | 
        GameWorld.ErrLog("¿ç·þ·þÎñÆ÷δÆô¶¯ºÃ,²»ÔÊÐíÏò×Ó·þ·¢ËÍÊý¾Ý! serverGroupIDList=%s, srcMsg=%s" % (serverGroupIDList, srcMsg))  
 | 
        return  
 | 
    GameWorld.Log("SendMsgToClientServer => serverGroupIDList=%s, srcMsg=%s" % (serverGroupIDList, srcMsg))  
 | 
    if not serverGroupIDList:  
 | 
        GameWorld.GetGameWorld().SendBroadcastMergeClient(sendMsg, len(sendMsg))  
 | 
    else:  
 | 
        serverGroupIDList = list(set(serverGroupIDList)) # È¥ÖØ  
 | 
        #for serverGroupID in serverGroupIDList:  
 | 
        #    GameWorld.GetGameWorld().SendMergeMsgToClientByGroupID(serverGroupID, sendMsg, len(sendMsg))  
 | 
        jsonGroupIDInfo = cPickle.dumps(serverGroupIDList, 2)  
 | 
        GameWorld.GetGameWorld().SendMergeMsgToClientByGroupList(jsonGroupIDInfo, len(jsonGroupIDInfo), sendMsg, len(sendMsg))  
 | 
    return  
 | 
  
 | 
def OnClientServerReceiveMsg(index, tick):  
 | 
    ## ×Ó·þÊÕµ½¿ç·þ·þÎñÆ÷ÐÅÏ¢  
 | 
    dataPack = IPY_GameServer.IPY_MGBroadcastMergeClient()  
 | 
    dataMsg = dataPack.GetData()  
 | 
      
 | 
    try:  
 | 
        GameWorld.Log("ÊÕµ½OnClientServerReceiveMsg" )  
 | 
        if not GameWorld.GetGameWorld().GetDictByKey(ChConfig.Def_WorldKey_GameWorldInitOK):  
 | 
            GameWorld.Log("·þÎñÆ÷δÆô¶¯ºÃ£¬²»´¦Àí¿ç·þÐÅÏ¢!")  
 | 
            return  
 | 
          
 | 
        msgDict = cPickle.loads(dataMsg)  
 | 
        msgType = msgDict.get("MsgType", -1)      
 | 
        msgData = msgDict.get("Data", "")  
 | 
        GameWorld.Log("OnClientServerReceiveMsg: %s" % msgDict)  
 | 
          
 | 
        if msgType == ShareDefine.CrossServerMsg_ExitCrossServer:  
 | 
            CrossRealmPlayer.CrossServerMsg_ExitCrossServer(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_Notify:  
 | 
            PlayerControl.CrossServerMsg_Notify(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_ChatCrossWorld:  
 | 
            PlayerTalk.CrossServerMsg_ChatCrossWorld(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_ViewPlayerCacheRet:  
 | 
            CrossRealmPlayer.CrossServerMsg_ViewPlayerCacheRet(msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PKMatchReqRet:  
 | 
            CrossRealmPK.CrossServerMsg_PKMatchReqRet(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PKMatchResult:  
 | 
            CrossRealmPK.CrossServerMsg_PKMatchResult(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PKReadyOKRoomList:  
 | 
            CrossRealmPK.CrossServerMsg_PKReadyOKRoomList(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PKTimeoutRoomList:  
 | 
            CrossRealmPK.CrossServerMsg_PKTimeoutRoomList(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PKOverInfo:  
 | 
            CrossRealmPK.CrossServerMsg_PKOverInfo(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PKSeasonInfo:  
 | 
            CrossRealmPK.CrossServerMsg_PKSeasonInfo(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PKSyncBillboard:  
 | 
            CrossRealmPK.CrossServerMsg_PKSyncBillboard(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_CrossBossInfo:  
 | 
            CrossBoss.CrossServerMsg_CrossBossInfo(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_CrossBossState:  
 | 
            CrossBoss.CrossServerMsg_CrossBossState(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_PutInItem:  
 | 
            CrossRealmPlayer.CrossServerMsg_PutInItem(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_GiveMoney:  
 | 
            CrossRealmPlayer.CrossServerMsg_GiveMoney(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_DropGoodItem:  
 | 
            GameWorldBoss.CrossServerMsg_DropGoodItem(msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_NPCInfoRet:  
 | 
            PlayerQuery.CrossServerMsg_NPCInfoRet(msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_EnterFBRet:  
 | 
            PlayerFB.CrossServerMsg_EnterFBRet(msgData, tick)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_SendMail:  
 | 
            PlayerCompensation.CrossServerMsg_SendMail(msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_FBPlayerCount:  
 | 
            PlayerFB.CrossServerMsg_FBPlayerCount(msgData)  
 | 
              
 | 
        # ÐèÒª·¢Ë͵½µØÍ¼·þÎñÆ÷´¦ÀíµÄ  
 | 
        elif msgType in [ShareDefine.CrossServerMsg_RebornRet, ShareDefine.CrossServerMsg_CollectNPCOK, ShareDefine.CrossServerMsg_FBEnd,  
 | 
                         ShareDefine.CrossServerMsg_NPCAttackCount]:  
 | 
            MapServer_ClientServerReceiveMsg(msgType, msgData)  
 | 
              
 | 
        elif msgType == ShareDefine.CrossServerMsg_CrossServerState:  
 | 
            CrossRealmPlayer.CrossServerMsg_CrossServerState(msgData)  
 | 
              
 | 
        else:  
 | 
            GameWorld.ErrLog("ûÓиÃÐÅÏ¢ÀàÐÍÂß¼´¦Àí£¡")  
 | 
              
 | 
    except:  
 | 
        GameWorld.ErrLog("OnClientServerReceiveMsg:%s; except:%s" % (cPickle.loads(dataMsg), traceback.format_exc()))  
 | 
        if GameWorld.GetGameWorld().GetDebugLevel():  
 | 
            raise BaseException(str(traceback.format_exc()))  
 | 
          
 | 
    return  
 | 
  
 | 
def MapServer_ClientServerReceiveMsg(msgType, msgData):  
 | 
    ## ÊÕµ½¿ç·þ·þÎñÆ÷ÐÅÏ¢£¬ÐèÒª·¢Ë͵½µØÍ¼·þÎñÆ÷´¦Àí  
 | 
      
 | 
    if msgType in [ShareDefine.CrossServerMsg_FBEnd]:  
 | 
        curServerGroupID = GameWorld.GetServerGroupID()  
 | 
        for tagPlayerID, msgInfo in msgData.items():  
 | 
            if not msgInfo:  
 | 
                continue  
 | 
            serverGroupID = msgInfo[0]  
 | 
            if curServerGroupID != serverGroupID:  
 | 
                continue  
 | 
            tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(tagPlayerID)  
 | 
            if not tagPlayer:  
 | 
                continue  
 | 
            msgInfo = str([msgType, msgInfo[1:]])  
 | 
            tagPlayer.MapServer_QueryPlayerResult(0, 0, "ClientServerReceiveMsg", msgInfo, len(msgInfo))  
 | 
              
 | 
        return  
 | 
      
 | 
    if not isinstance(msgData, dict):  
 | 
        return  
 | 
    tagPlayerID = msgData.get("PlayerID")  
 | 
    if not tagPlayerID:  
 | 
        return  
 | 
    tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(tagPlayerID)  
 | 
    if not tagPlayer:  
 | 
        return  
 | 
    msgInfo = str([msgType, msgData])  
 | 
    tagPlayer.MapServer_QueryPlayerResult(0, 0, "ClientServerReceiveMsg", msgInfo, len(msgInfo))  
 | 
    return  
 | 
  
 | 
# Á¬½Ó¿ç·þ·þÎñÆ÷״̬  
 | 
# 1 ÎªÁ¬½Ó³É¹¦; ÆäËûΪʧ°Ü£¬Ê§°Ü»áÑÓ³Ù֪ͨ  
 | 
def OnConnCorossServer(index, tick):  
 | 
    ## ×Ó·þÊÕµ½¿ç·þ·þÎñÆ÷ÐÅÏ¢  
 | 
    dataPack = IPY_GameServer.IPY_LGCrossLoginResult()  
 | 
    result = dataPack.GetResult()  
 | 
    connState = 1 if result == 1 else 0  
 | 
    GameWorld.GetGameWorld().SetDict(ShareDefine.Def_Notify_WorldKey_CrossServerConnState, connState)  
 | 
      
 | 
    if result != 1:  
 | 
        GameWorld.Log("===Óë¿ç·þ·þÎñÆ÷¶Ï¿ªÁ¬½Ó!")  
 | 
        CrossRealmPlayer.CrossServerMsg_CrossServerState({"isOpen":0})  
 | 
        return  
 | 
      
 | 
    GameWorld.Log("===Óë¿ç·þ·þÎñÆ÷Á¬½Ó³É¹¦!")  
 | 
    if not GameWorld.GetGameWorld().GetDictByKey(ChConfig.Def_WorldKey_GameWorldInitOK):  
 | 
        GameWorld.Log("    ·þÎñÆ÷»¹Î´Æô¶¯ºÃ£¬Ôݲ»´¦Àí! µÈ·þÎñÆ÷Æô¶¯ºÃºóÔÙ´¦Àí£¡")  
 | 
        return  
 | 
      
 | 
    serverGroupID = GameWorld.GetServerGroupID()  
 | 
    if GameWorld.IsCrossRealmOpen() and not GameWorld.IsCrossServer():  
 | 
        GameWorld.Log("֪ͨ¿ç·þÖ÷·þÎñÆ÷Á´½Ó³É¹¦, ¿É½ÓÊÕ×îпç·þ»î¶¯×´Ì¬¼°Êý¾Ý...")  
 | 
        dataMsg = {"ServerGroupID":serverGroupID}  
 | 
        SendMsgToCrossServer(ShareDefine.ClientServerMsg_ServerInitOK, dataMsg)  
 | 
          
 | 
    return  
 | 
  
 | 
def OnGameServerInitOK():  
 | 
    ## ·þÎñÆ÷Æô¶¯³É¹¦  
 | 
      
 | 
    tick = GameWorld.GetGameWorld().GetTick()  
 | 
      
 | 
    if GameWorld.IsCrossServer():  
 | 
        Sync_CrossServerInitDataToClientServer(tick, serverGroupID=0) # ÕâÀïÉèÖÃΪ0£¬¹ã²¥ËùÓÐ×Ó·þÎñÆ÷×é  
 | 
        return  
 | 
      
 | 
    serverGroupID = GameWorld.GetServerGroupID()  
 | 
    if GameWorld.IsCrossRealmOpen() and not GameWorld.IsCrossServer():  
 | 
        GameWorld.Log("֪ͨ¿ç·þÖ÷·þÎñÆ÷Æô¶¯³É¹¦, ¿É½ÓÊÕ×îпç·þ»î¶¯×´Ì¬¼°Êý¾Ý...")  
 | 
        dataMsg = {"ServerGroupID":serverGroupID}  
 | 
        SendMsgToCrossServer(ShareDefine.ClientServerMsg_ServerInitOK, dataMsg)  
 | 
    return  
 | 
  
 | 
  
 | 
     
 |