#!/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 PlayerAssist
import PlayerControl
import CrossLuckyCloudBuy
import IPY_GameServer
import CrossRealmPlayer
import PlayerCompensation
import PlayerActBossTrial
import CrossActionControl
import CrossActAllRecharge
import CrossFamilyFlagwar
import CrossChampionship
import CrossBattlefield
import CrossBillboard
import CrossYaomoBoss
import GameWorldBoss
import CrossRealmPK
import GameWorship
import PlayerQuery
import PlayerTalk
import PyGameData
import CrossBoss
import ChConfig
import PlayerFB
import GMShell

import traceback
import cPickle
import time

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:
        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_LuckyCloudBuy:
            CrossLuckyCloudBuy.ClientServerMsg_LuckyCloudBuy(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_QueryBillboard:
            CrossBillboard.ClientServerMsg_QueryBillboard(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_UpdateBillboard:
            CrossBillboard.ClientServerMsg_UpdateBillboard(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_MailContent:
            PlayerCompensation.ClientServerMsg_MailContent(serverGroupID, msgData, tick)
            
        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 == ShareDefine.ClientServerMsg_CrossAssist:
            PlayerAssist.ClientServerMsg_CrossAssist(serverGroupID, msgData, tick)
            
        elif msgType == ShareDefine.ClientServerMsg_BattlefieldBuyOpen:
            CrossBattlefield.ClientServerMsg_BattlefieldBuyOpen(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_BattlefieldCallJoin:
            CrossBattlefield.ClientServerMsg_BattlefieldCallJoin(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_BattlefieldCallKick:
            CrossBattlefield.ClientServerMsg_BattlefieldCallKick(serverGroupID, msgData)
                        
        elif msgType == ShareDefine.ClientServerMsg_BattlefieldCallChange:
            CrossBattlefield.ClientServerMsg_BattlefieldCallChange(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ChampionshipOfficialApply:
            CrossChampionship.ClientServerMsg_ChampionshipOfficialApply(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ChampionshipOfficialApplyReply:
            CrossChampionship.ClientServerMsg_ChampionshipOfficialApplyReply(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ChampionshipOfficialKick:
            CrossChampionship.ClientServerMsg_ChampionshipOfficialKick(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ChampionshipOfficialLeave:
            CrossChampionship.ClientServerMsg_ChampionshipOfficialLeave(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ChampionshipOfficialChallenge:
            CrossChampionship.ClientServerMsg_ChampionshipOfficialChallenge(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ChampionshipGuess:
            CrossChampionship.ClientServerMsg_ChampionshipGuess(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ChampionshipWorship:
            CrossChampionship.ClientServerMsg_ChampionshipWorship(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_ActAllRechargeValue:
            CrossActAllRecharge.ClientServerMsg_ActAllRechargeValue(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_CrossYaomoBossHurtAward:
            CrossYaomoBoss.ClientServerMsg_CrossYaomoBossHurtAward(serverGroupID, msgData)
            
        elif msgType == ShareDefine.ClientServerMsg_BossTrialSubmit:
            PlayerActBossTrial.ClientServerMsg_BossTrialSubmit(serverGroupID, msgData)
            
        # ÐèÒª·¢Ë͵½µØͼ·þÎñÆ÷´¦ÀíµÄ
        elif msgType in [ShareDefine.ClientServerMsg_Reborn, ShareDefine.ClientServerMsg_CollectNPC]:
            MapServer_CrossServerReceiveMsg(msgType, msgData, serverGroupID)
            
        else:
            GameWorld.ErrLog("ûÓиÃÐÅÏ¢ÀàÐÍÂß¼­´¦Àí£¡")
            
    except:
        GameWorld.RaiseException("¿ç·þ·þÎñÆ÷½ÓÊÕÐÅÏ¢´¦Àí±¨´í \r\n%s" % 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)
    CrossChampionship.Sync_CrossChampionshipDataToClientServer(serverGroupID)
    CrossBattlefield.Sync_CrossBattlefieldDataToClientServer(serverGroupID)
    CrossBoss.Sync_CrossBossInitDataToClientServer(serverGroupID)
    CrossActionControl.Sync_CrossActInfoToClientServer(serverGroupID)
    CrossLuckyCloudBuy.Sync_LuckyCloudBuyDataToClientServer(tick, serverGroupID)
    CrossActAllRecharge.Sync_AllRechargeDataToClientServer(serverGroupID)
    CrossYaomoBoss.Sync_CrossYaomoBossDataToClientServer(serverGroupID)
    PlayerCompensation.Sync_CrossMailPlayerIDToClientServer(serverGroupID)
    GameWorship.Sync_CrossWorshipToClientServer(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=None):
    ''' ¹ã²¥ÐÅÏ¢µ½×Ó·þÎñÆ÷ÉÏ
        @param serverGroupIDList: ·¢ËÍÖ¸¶¨µÄ·þÎñÆ÷×éIDÁÐ±í£¬ÄÚ²¿ÒѾ­Õë¶ÔÁбíÖÐ×éIDÈ¥ÖØ£¬
        ËùÒÔÍⲿÂß¼­¿ÉÖ±½ÓÌí¼Ó£¬²»Óÿ¼ÂÇ×éIDÖظ´ÎÊÌ⣬ûÓÐÖ¸¶¨·þÎñÆ÷×éIDʱ£¬Ä¬ÈϹ㲥ËùÓÐ×Ó·þ
    '''
    if not GameWorld.IsCrossServer():
        return
    #if not dataMsg:
    #    return
    if serverGroupIDList == None:
        serverGroupIDList = []
        
    srcMsg = {"MsgType":msgType, "Data":dataMsg, "CrossServerTime":GameWorld.GetCurrentDataTimeStr()}
    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:
        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", "")
        crossServerTimeStr = msgDict.get("CrossServerTime", "")
        GameWorld.Log("OnClientServerReceiveMsg: %s" % msgDict)
        if crossServerTimeStr:
            curServerTime = int(time.time())
            crossServerTime = GameWorld.ChangeTimeStrToNum(crossServerTimeStr)
            curServerCrossServerTime = GameWorld.ChangeTimeStrToNum(GameWorld.GetCrossServerTimeStr())
            diffSeconds = curServerCrossServerTime - crossServerTime# ±¾·þ¼ÆËãÎó²î
            
            _, _, syncMapTime = PyGameData.g_crossServerTimeInfo
            PyGameData.g_crossServerTimeInfo = [crossServerTime, curServerTime, syncMapTime]
            if curServerTime - syncMapTime >= 600 or abs(diffSeconds) >= 30 or msgType == ShareDefine.CrossServerMsg_CrossServerTime: # Ò»¶¨Ê±¼äͬ²½µØͼһ´Î »ò¼ÆËã Îó²î³¬¹ý30Ãë »òÇ¿ÖÆͬ²½Ê±¼äµÄ
                GameWorld.DebugLog("ͬ²½µØͼ¿ç·þ·þÎñÆ÷ʱ¼äʱ£¬±¾·þÓë¿ç·þ·þÎñÆ÷ʱ¼ä¼ÆËãÎó²î£¡ diffSeconds=%s" % (diffSeconds))
                syncMapTime = curServerTime
                PyGameData.g_crossServerTimeInfo = [crossServerTime, curServerTime, syncMapTime]
                GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_CrossServerTime, PyGameData.g_crossServerTimeInfo)
                
        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_LuckyCloudBuyLottery:
            CrossLuckyCloudBuy.CrossServerMsg_LuckyCloudBuyLottery(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_LuckyCloudBuyNum:
            CrossLuckyCloudBuy.CrossServerMsg_LuckyCloudBuyNum(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_BattlefieldState:
            CrossBattlefield.CrossServerMsg_BattlefieldState(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_BattlefieldBuy:
            CrossBattlefield.CrossServerMsg_BattlefieldBuy(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_BattlefieldOver:
            CrossBattlefield.CrossServerMsg_BattlefieldOver(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_FamilyFlagwarOver:
            CrossFamilyFlagwar.CrossServerMsg_FamilyFlagwarOver(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossBossTrialFamilyAward:
            PlayerActBossTrial.CrossServerMsg_CrossBossTrialFamilyAward(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_Worship:
            GameWorship.CrossServerMsg_Worship(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_ChampionshipState:
            CrossChampionship.CrossServerMsg_ChampionshipState(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_ChampionshipPlayer:
            CrossChampionship.CrossServerMsg_ChampionshipPlayer(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_ChampionshipGroup:
            CrossChampionship.CrossServerMsg_ChampionshipGroup(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_ChampionshipGuess:
            CrossChampionship.CrossServerMsg_ChampionshipGuess(msgData, tick)
            
        elif msgType == ShareDefine.CrossServerMsg_ChampionshipOfficial:
            CrossChampionship.CrossServerMsg_ChampionshipOfficial(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_ChampionshipDailyOfficial:
            CrossChampionship.CrossServerMsg_ChampionshipDailyOfficial(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_ActAllRechargeInfo:
            CrossActAllRecharge.CrossServerMsg_ActAllRechargeInfo(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossDailyActionState:
            CrossActionControl.CrossServerMsg_CrossDailyActionState(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossYaomoBossHurtInfo:
            CrossYaomoBoss.CrossServerMsg_CrossYaomoBossHurtInfo(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_SyncBillboard:
            CrossBillboard.CrossServerMsg_SyncBillboard(msgData, tick)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossBossInfo:
            CrossBoss.CrossServerMsg_CrossBossInfo(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossBossState:
            CrossBoss.CrossServerMsg_CrossBossState(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossAssist:
            PlayerAssist.CrossServerMsg_CrossAssist(msgData, tick)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossActInfo:
            CrossActionControl.CrossServerMsg_CrossActInfo(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_EnterVSRoomRet:
            PlayerFB.CrossServerMsg_EnterVSRoomRet(msgData, tick)
            
        elif msgType == ShareDefine.CrossServerMsg_SendMail:
            PlayerCompensation.CrossServerMsg_SendMail(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_MailPlayerIDList:
            PlayerCompensation.CrossServerMsg_MailPlayerIDList(msgData)
            
        elif msgType == ShareDefine.CrossServerMsg_MailContent:
            PlayerCompensation.CrossServerMsg_MailContent(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)
            
        elif msgType == ShareDefine.CrossServerMsg_CrossServerTime:
            playerID = msgData.get("PlayerID")
            if playerID:
                tagPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
                if tagPlayer:
                    GameWorld.DebugAnswer(tagPlayer, "¿ç·þ·þÎñÆ÷ʱ¼ä: %s" % GameWorld.GetCrossServerTimeStr())
            
        elif msgType == ShareDefine.CrossServerMsg_DebugAnswer:
            GameWorld.CrossServerMsg_DebugAnswer(msgData)
            
        else:
            GameWorld.ErrLog("ûÓиÃÐÅÏ¢ÀàÐÍÂß¼­´¦Àí£¡")
            
    except:
        GameWorld.RaiseException("×Ó·þ·þÎñÆ÷½ÓÊÕÐÅÏ¢´¦Àí±¨´í\r\n%s" % 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