5722 【后端】【1.5】跨服BOSS开发（支持跨服复活）

hxp

2019-01-10 94c9b0759bfa49e66bfce3f790c40f15d362ba1a

5722 【后端】【1.5】跨服BOSS开发（支持跨服复活）

 ServerPython/CoreServerGroup/GameServer/Script/ChConfig.py

@@ -636,7 +636,7 @@
Def_PlayerKey_IsStopSendDBCommand = "StopSendDBCom"  #是否停止发送数据库操作命令

Def_PlayerKey_SendDBComTick = "SendDBComTick"  #发送DB命令时间



Def_PlayerKey_CrossRegisterType = "CrossRegisterType"  #当前上传数据的活动类型

Def_PlayerKey_CrossRegisterMap = "CrossRegisterMap"  #跨服注册活动地图, dataMapID

Def_PlayerKey_MergeRegisterRoomID = "MergeRegisterRoomID"  #当前上传数据的roomID

Def_PlayerKey_IsLoginToMergeServer = "IsLoginToMergeServer"  #是否要登陆跨服服务器

Def_PlayerKey_IsCrossPKMatching = "IsCrossPKMatching"  #是否跨服匹配中


 ServerPython/CoreServerGroup/GameServer/Script/GameWorldLogic/CrossRealmMsg.py

@@ -49,7 +49,7 @@
        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)

            

@@ -71,6 +71,10 @@
        elif msgType == ShareDefine.ClientServerMsg_ViewPlayerCache:

            CrossRealmPlayer.ClientServerMsg_ViewPlayerCache(serverGroupID, msgData)

            

        # 需要发送到地图服务器处理的

        elif msgType in [ShareDefine.ClientServerMsg_Reborn]:

            MapServer_CrossServerReceiveMsg(msgType, msgData, serverGroupID)

            
        else:

            GameWorld.ErrLog("没有该信息类型逻辑处理！")

            

@@ -88,6 +92,21 @@
    CrossRealmPlayer.ClientServerMsg_ServerInitOK(serverGroupID)

    CrossRealmPK.ClientServerMsg_ServerInitOK(serverGroupID, tick)

    CrossBoss.ClientServerMsg_ServerInitOK(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



## ================================================================================================

@@ -169,6 +188,10 @@
        elif msgType == ShareDefine.CrossServerMsg_DropGoodItem:

            GameWorldBoss.CrossServerMsg_DropGoodItem(msgData, tick)

            

        # 需要发送到地图服务器处理的

        elif msgType in [ShareDefine.CrossServerMsg_RebornRet]:

            MapServer_ClientServerReceiveMsg(msgType, msgData)

            
        elif msgType == ShareDefine.CrossServerMsg_CrossServerState:

            CrossRealmPlayer.CrossServerMsg_CrossServerState(msgData)

            

@@ -182,6 +205,20 @@
        

    return



def MapServer_ClientServerReceiveMsg(msgType, msgData):

    ## 收到跨服服务器信息，需要发送到地图服务器处理

    
    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 为连接成功; 其他为失败，失败会延迟通知


 ServerPython/CoreServerGroup/GameServer/Script/GameWorldLogic/CrossRealmPK.py

@@ -1774,7 +1774,7 @@
                    matchPlayer.MaxProDef = readyPlayerInfo["MaxProDef"]

                    break

                

            PlayerControl.SetCrossRealmState(player, 1)

            PlayerControl.SetCrossRealmState(player, ChConfig.Def_FBMapID_CrossRealmPK)

            SetIsCrossPKMatching(player, 0)

            

            # 通知匹配成功，可进入跨服


 ServerPython/CoreServerGroup/GameServer/Script/Player/CrossRealmPlayer.py

@@ -155,15 +155,15 @@
    PlayerControl.SetCrossRealmState(curPlayer, 0)

    return



def SendCrossRealmReg(curPlayer, registerType, mapID=0, dataMapID=0, copyMapID=0, posX=0, posY=0):

def SendCrossRealmReg(curPlayer, registerMap, mapID=0, dataMapID=0, copyMapID=0, posX=0, posY=0):

    # 发送跨服账号注册上传数据

    

    # 设置上传数据的活动类型

    curPlayer.SetDict(ChConfig.Def_PlayerKey_CrossRegisterType, registerType)

    sysMsg = str([registerType, mapID, dataMapID, copyMapID, posX, posY])

    curPlayer.SetDict(ChConfig.Def_PlayerKey_CrossRegisterMap, registerMap)

    sysMsg = str([registerMap, mapID, dataMapID, copyMapID, posX, posY])

    curPlayer.MapServer_QueryPlayerResult(0, 0, "CrossRealmReg", sysMsg, len(sysMsg))            

    GameWorld.Log("SendCrossRealmReg registerType=%s,mapID=%s,dataMapID=%s,copyMapID=%s,posX=%s,posY=%s" 
                  % (registerType, mapID, dataMapID, copyMapID, posX, posY), curPlayer.GetPlayerID())

    GameWorld.Log("SendCrossRealmReg registerMap=%s,mapID=%s,dataMapID=%s,copyMapID=%s,posX=%s,posY=%s" 
                  % (registerMap, mapID, dataMapID, copyMapID, posX, posY), curPlayer.GetPlayerID())

    return



def OnCrossRealmRegOK(playerID, msgList, tick): 

@@ -176,16 +176,16 @@
    if not IsCrossServerOpen():

        return

    

    registerType = msgList[0]

    playerRegisterType = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CrossRegisterType)

    if playerRegisterType and registerType != playerRegisterType:

    registerMap = msgList[0]

    playerRegisterMap = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CrossRegisterMap)

    if playerRegisterMap and registerMap != playerRegisterMap:

        return

    curPlayer.SetDict(ChConfig.Def_PlayerKey_CrossRegisterType, 0)

    curPlayer.SetDict(ChConfig.Def_PlayerKey_CrossRegisterMap, 0)

    

    GameWorld.Log("跨服报名成功 , registerType=%s" % (registerType), playerID)

    GameWorld.Log("跨服报名成功 , registerMap=%s" % (registerMap), playerID)

    

    # 跨服PK上传数据完毕，通知跨服服务器，准备完毕

    if registerType == ChConfig.Def_FBMapID_CrossRealmPK:

    if registerMap == ChConfig.Def_FBMapID_CrossRealmPK:

        regVSRoomID = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MergeRegisterRoomID) 

        vsRoomID = curPlayer.GetVsRoomId()

        

@@ -204,13 +204,13 @@
        

    # 其他的，在上传数据完毕后，使用通用的通知可进入跨服

    else:

        NotifyCanEnterMergeServer(curPlayer, registerType)

        NotifyCanEnterMergeServer(curPlayer, registerMap)

        

    # hxp 2015.09.10 跨服boss，后面的暂时不需要

    return





def NotifyCanEnterMergeServer(curPlayer, registerType):

def NotifyCanEnterMergeServer(curPlayer, registerMap):

    # 通用包，通知客户端可进入跨服服务器

    return




 ServerPython/CoreServerGroup/GameServer/Script/Player/PlayerControl.py

@@ -302,7 +302,7 @@
    ''' 设置玩家跨服状态

    @param isExitCrossRealm: 非跨服状态时是否通知前端退出跨服服务器

    '''

    curPlayer.SetExAttr5(value)

    curPlayer.SetExAttr5(1 if value else 0)

    SetMapServerPlayerAttrValue(curPlayer, "SetExAttr5", value)

    return




 ServerPython/CoreServerGroup/GameServer/Script/ShareDefine.py

@@ -1204,6 +1204,7 @@
CrossServerMsg_PutInItem = "PutInItem"                  # 获得物品

CrossServerMsg_GiveMoney = "GiveMoney"                  # 获得货币

CrossServerMsg_DropGoodItem = "DropGoodItem"            # 掉落好物品

CrossServerMsg_RebornRet = "RebornRet"                  # 复活结果



# 子服发送跨服信息定义

ClientServerMsg_ServerInitOK = "ServerInitOK"           # 子服启动成功

@@ -1213,6 +1214,7 @@
ClientServerMsg_PKCancel = "PKCancel"                   # 跨服PK取消匹配

ClientServerMsg_PKPrepareOK = "PKPrepareOK"             # 跨服PK准备完毕

ClientServerMsg_PKBillboard = "PKBillboard"             # 跨服PK排行榜

ClientServerMsg_Reborn = "Reborn"                       # 复活



#角色改名结果

(


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ChConfig.py

@@ -2855,14 +2855,12 @@
Def_RebornPos_Area_Range = 3



#复活类型(需要和C++统一)

RebornTypeCount = 8

RebornTypeCount = 6

Def_RebornTypeList = [ 

rebornType_City,          #回城虚弱复活

rebornType_Skill,         #技能复活

rebornType_Health,        #原地健康复活

rebornType_UseItem,       #使用还阳咒复活

rebornType_FBGold,        #副本元宝复活

rebornType_FBUseItem,     #副本使用道具复活

rebornType_City,          #回城虚弱复活 0

rebornType_Skill,         #技能复活 1

rebornType_Health,        #原地健康复活 2

rebornType_UseItem,       #使用道具复活 3

rebornType_MainCity,      #回主城复活

rebornType_System,        #系统复活

] = range(0, RebornTypeCount)

@@ -3228,9 +3226,6 @@
Def_PlayerKey_CalcAddAttrType = "CalcAType_%s_%s_%s"   # 刷属性类型, 参数[funcIndex, attrIndex, 缓存编号]

Def_PlayerKey_CalcAddAttrValue = "CalcAValue_%s_%s_%s"   # 刷属性值, 参数[funcIndex, attrIndex, 缓存编号]



Def_PlayerKey_CrossRegisterType = "CrossRegisterType"  #跨服注册活动类型

Def_PlayerKey_IsCrossPKMatching = "IsCrossPKMatching"  #是否跨服匹配中



Def_PDict_QueryTechLVUPState = "QueryTechLVUPState"  # 查询科技等级提升状态



Def_PDict_PKStateTick = "PKStateTick"  # PK状态tick，只要有一方发起攻击，双方均进入PK状态

@@ -3332,6 +3327,9 @@
Def_Player_Dict_FromPosY = 'FromPosY'    # 最后一次离开的非中立常规地图，坐标X

Def_Player_Dict_FromLineID = 'FromLineID'    # 最后一次离开的非中立常规地图，线路ID



Def_PlayerKey_CrossRegisterMap = "CrossRegisterMap"  #跨服注册活动地图, dataMapID

Def_PlayerKey_CrossMapID = "CrossMapID"  #玩家所在跨服地图ID

Def_PlayerKey_IsCrossPKMatching = "IsCrossPKMatching"  #是否跨服匹配中



Def_Player_Dict_FamilyTechLV = "FamilyTechLV_%s"    #家族科技等级, 参数(科技ID)

Def_Player_Dict_RouteServerInitOK = "RouteServerInitOK_33"     #RouteServer初始化成功(仅登陆一次)

@@ -3405,7 +3403,6 @@
Def_Player_Dict_SignDayCnt = "SignDayCnt_151"  # 签到次数

Def_Player_Dict_ForbidFamilyAction = 'ForbidFamilyAction_168'  # 玩家是否能参加家族活动

Def_Player_Dict_ForbidFamilyAward = "ForbidFamilyAward" # 当日家族相关活动是否领奖受限, 按位存储

Def_Player_Dict_RoomID = 'RoomID_184'  # 房间ID

Def_Player_Dict_HasApplyVIPClub = 'HasApplyVIPClub_185'  # 是否申请过贵宾俱乐部

Def_Player_Dict_HasVIPClubNote = 'HasVIPClubNote_186'  # 是否提示过vip升级可加入贵宾俱乐部信息

Def_Player_Dict_PyPlayerAction = 'PyPlayerAction_187'  # py自定义玩家状态


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/ChPlayer.py

@@ -376,7 +376,7 @@
    # ！！！必要发送的数据要注意位置

    if GameWorld.IsCrossServer():

        curPlayer.SetForbiddenSyncClientState(False)

        PlayerControl.SetCrossRealmState(curPlayer, 1) # 因为主服上传数据之前该值为0，所以登录跨服后在跨服服务器要设置为1

        PlayerControl.SetCrossRealmState(curPlayer, curPlayer.GetMapID()) # 因为主服上传数据之前该值为0，所以登录跨服后在跨服服务器要设置为1

        

    return



@@ -2323,31 +2323,76 @@
    #根据玩家选择重生选项重生

    sendPack = IPY_GameWorld.IPY_CCliectReborn()

    #复活类型

    playerRebornType = sendPack.GetType()

    rebornType = sendPack.GetType()

    GameWorld.DebugLog("玩家点击复活: rebornType=%s" % rebornType, curPlayer.GetPlayerID())

    

    if curPlayer.GetHP() > 0:

        # 当血量大于0收到复活请求包时，一般是前后端复活状态不一致的情况下导致的

        # 由于前端需要根据复活状态判断复活界面相关逻辑，所以这里需要做一些特殊处理，防止某些情况下前后端复活状态不一致导致的一些异常问题

        
        # 后端非死亡状态的情况，补同步一次复活包给前端

        if curPlayer.GetPlayerAction() != IPY_GameWorld.paDie:

            SyncPlayerReborn(curPlayer, playerRebornType)

        # 后端也是死亡状态的情况，直接重新触发一次复活

        else:

            PlayerRebornByType(curPlayer, playerRebornType, tick)

        #生命值不为0 , 不能重生

#        GameWorld.Log("玩家点击: 重生失败,生命值不为0 , 不能重生" , curPlayer.GetPlayerID())

    if GameWorld.IsCrossServer():

        GameWorld.DebugLog("跨服服务器不接受复活请求!")

        return

    
    if PlayerControl.GetCrossRealmState(curPlayer):

        OnReqCrossServerReborn(curPlayer, rebornType)

        return

    

    #FB中禁止复活

    if FBLogic.DoFBForbidReborn(curPlayer, playerRebornType):

    if FBLogic.DoFBForbidReborn(curPlayer, rebornType):

        PlayerControl.NotifyCode(curPlayer, "Reborn_lhs_31379")

        return

    

    #玩家复活

    if PlayerRebornByType(curPlayer, playerRebornType, tick):

    if PlayerRebornByType(curPlayer, rebornType, tick):

        #玩家复活成功,判断是否在副本中复活

        PlayerReborn_InFB(curPlayer, playerRebornType, tick)

        PlayerReborn_InFB(curPlayer, rebornType, tick)

        
    return



def OnReqCrossServerReborn(curPlayer, rebornType):

    ## 请求跨服服务器复活玩家

    
    crossMapID = curPlayer.NomalDictGetProperty(ChConfig.Def_PlayerKey_CrossMapID)

    if not crossMapID:

        GameWorld.DebugLog("当前无跨服地图!")

        return

    
    if not __CheckCanReborn(curPlayer, rebornType):

        return

    
    msgDict = {"PlayerID":curPlayer.GetPlayerID(), "RebornType":rebornType}

    GameWorld.SendMsgToCrossServer(ShareDefine.ClientServerMsg_Reborn, msgDict)

    GameWorld.DebugLog("跨服中请求复活, crossMapID=%s,msgDict=%s" % (crossMapID, msgDict), curPlayer.GetPlayerID())

    return



def ClientServerMsg_Reborn(curPlayer, msgData, serverGroupID, tick):

    ## 收到子服请求复活信息

    
    rebornType = msgData["RebornType"]

    gameMap = GameWorld.GetMap()

    if not __CheckCanReborn(curPlayer, rebornType, gameMap):

        return

    
    isAddReviveTired = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_IsAddReviveTired)

    # 跨服服务器不执行消耗，复活后同步消息回主服扣除消耗

    __DoPlayerReborn(curPlayer, rebornType, tick)

    
    # 发送回本服复活结果

    msgInfo = {"Result":1, "ReviveTired":isAddReviveTired}

    msgInfo.update(msgData)

    GameWorld.SendMsgToClientServer(ShareDefine.CrossServerMsg_RebornRet, msgInfo, [serverGroupID])

    return



def CrossServerMsg_RebornRet(curPlayer, msgData, tick):

    ## 收到跨服服务器复活结果

    
    result = msgData["Result"]

    if result != 1:

        return

    
    rebornType = msgData["RebornType"]

    isAddReviveTired = msgData["ReviveTired"]

    __RebornCost(curPlayer, rebornType, True)

    
    if isAddReviveTired:

        __AddReviveTired(curPlayer, tick)

        

    return



@@ -2662,7 +2707,8 @@
    #取消自动运镖状态

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_AutoTruck, 0)

    

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_RoomID, 0)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PlayerKey_CrossRegisterMap, 0)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PlayerKey_IsCrossPKMatching, 0)

    

    #下线召回宠物

    PetControl.ReCallFightPet(curPlayer)

@@ -3895,20 +3941,23 @@
#    curPlayer.GameServer_LineState()

    return







##获取死亡冷却时间

#@param curPlayer 玩家实例

#@param playerRebornType 复活类型

#@return 死亡冷却时间

def GetRebronTime(curPlayer, playerRebornType):

    mapType = GameWorld.GetMap().GetMapFBType()

def GetRebronTime(curPlayer, rebornType):

    ''' 死亡状态才验证时间，本服跨服通用

            跨服服务器死亡的复活也是先发到本服，正常情况下本服是活着的，无法验证

            所以可否复活由跨服服务器死亡状态下的玩家实例判断，简单讲就是哪个服务器死亡的哪个服务器判断

            所以该函数可以直接使用玩家所在的地图判断

    '''

    

    if playerRebornType in [ChConfig.rebornType_Health, ChConfig.rebornType_UseItem]:

        #原地复活、道具复活不用CD

    # 非死亡状态下，也就是哪个服务器角色死亡由哪个服务器判断

    if curPlayer.GetHP() > 0 and curPlayer.GetPlayerAction() != IPY_GameWorld.paDie:

        return 0

    
    # 回城复活的才需要CD

    if rebornType not in [ChConfig.rebornType_City, ChConfig.rebornType_MainCity]:

        return 0

    

    # 副本地图CD

    mapType = GameWorld.GetMap().GetMapFBType()

    if mapType != IPY_GameWorld.fbtNull:

        fbRebornTimeDict = IpyGameDataPY.GetFuncEvalCfg('DuplicatesRebornTime', 1)

        curMapID = GameWorld.GetMap().GetMapID()

@@ -3922,30 +3971,6 @@
            if findBuff.GetSkill().GetSkillLV() == findBuff.GetSkill().GetSkillMaxLV():

                return IpyGameDataPY.GetFuncEvalCfg('RebornArguments', 1)[1]

    return 0

    
#    playerRebornTimeDict = ReadChConfig.GetEvalChConfig('PlayerRebornTime')

#    
#    curMapID = GameWorld.GetMap().GetMapID()

#    
#    #不在配表的地图ID中取默认的

#    if curMapID not in playerRebornTimeDict.keys():

#        curMapID = 0

#    
#    rebronTimeByTypeDict = playerRebornTimeDict.get(curMapID, {})

#    
#    if not rebronTimeByTypeDict:

#        GameWorld.ErrLog("GetRebronTime rebronTimeByTypeDict=%s,,curMapID=%s" % 
#                              (rebronTimeByTypeDict, curMapID))

#        return 0

#    
#    #公式参数

#    playerLV = curPlayer.GetLV()

#    playerDeadCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PlayerDeadCnt)

#    
#    rebornTime = int(eval(rebronTimeByTypeDict.get(playerRebornType, "0")))

#    
#    return rebornTime





## 死亡冷却时间是否完了

#@param curPlayer 玩家实例

@@ -3961,116 +3986,90 @@
    



#---------------------------------------------------------------------

##自定义函数, 玩家复活

#@param curPlayer 玩家实例

#@param playerRebornType 复活类型

#@param tick 时间戳

#@param mapBornPlace 复活位置，默认0为原地

#@return 返回值无意义

#@remarks 自定义函数, 玩家复活

def PlayerRebornByType(curPlayer, playerRebornType, tick, mapBornPlace=0, isAddSuperBuff=True):

    curPlayerID = curPlayer.GetID()

    curVipLv = curPlayer.GetVIPLv()



def __CheckCanReborn(curPlayer, rebornType, gameMap=None):

    ''' 检查可否复活，为了逻辑统一，这里不适用玩家所在的地图，支持跨服状态下判断跨服地图

                本函数不验证玩家死亡状态等，因为有可能前后端复活状态不一致，如果这里拦住可能导致前端躺尸复活不了

    '''

    

    gameMap = GameWorld.GetMap()

    if rebornType not in ChConfig.Def_RebornTypeList:

        return

    

    #需要支付的银子数量 
    moneyPrice = 0

    #复活恢复血量、魔的万分比

    resetHpPercent = ChConfig.Def_MaxRateValue

    resetMpPercent = ChConfig.Def_MaxRateValue

    ## 由于本服及跨服地图数据不互通，所以这里根据是否有地图数据进行判断处理

    if gameMap:

        playerID = curPlayer.GetPlayerID()

        if rebornType in [ChConfig.rebornType_Health, ChConfig.rebornType_UseItem] and not gameMap.GetLocalReborn():

            GameWorld.ErrLog("该地图不可原地复活! mapID=%s,rebornType=%s" % (gameMap.GetMapID(), rebornType), curPlayer.GetPlayerID())

            return

        

    #复活冷却时间（秒）

    rebornTime = GetRebronTime(curPlayer, playerRebornType)    
    #冷却时间到了

    if playerRebornType != ChConfig.rebornType_System and not CanRebornByTimeOver(curPlayer, rebornTime):

        PlayerControl.NotifyCode(curPlayer, 'RebornCD')

        return False

    # 验证复活CD

    rebornCD = GetRebronTime(curPlayer, rebornType)

    if rebornCD:

        curTime = int(time.time())

        deadTime = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_DeadTime)

        if curTime - deadTime < rebornCD:

            PlayerControl.NotifyCode(curPlayer, "RebornCD")

            GameWorld.Log("复活冷却时间中，无法复活! curTime(%s) - deadTime(%s) < rebornCD(%s)" % (curTime, deadTime, rebornCD), playerID)

            return

        
    # 验证复活消耗，在本服验证，跨服服务器只验证状态

    if not GameWorld.IsCrossServer():

        if not __RebornCost(curPlayer, rebornType, False):

            return

        
    return True



def __RebornCost(curPlayer, rebornType, isDoCost):

    ## 扣除复活消耗

    # @param isDoCost: 是否执行消耗

    playerID = curPlayer.GetPlayerID()

    if rebornType == ChConfig.rebornType_Health:

        rebornCfg = IpyGameDataPY.GetFuncEvalCfg('RebornArguments', 1)

        moneyPrice = rebornCfg[2]

        costMoneyList = PlayerControl.HaveMoneyEx(curPlayer, ShareDefine.TYPE_Price_Gold_Paper_Money, moneyPrice)

        if not costMoneyList:

            GameWorld.ErrLog("货币不足，无法原地复活! moneyPrice=%s" % (moneyPrice), playerID)

            return

        
        if isDoCost:

            for moneyType, moneyCnt in costMoneyList:

                if not PlayerControl.PayMoney(curPlayer, moneyType, moneyCnt, ChConfig.Def_Cost_Revive):

                    return

                
    elif rebornType == ChConfig.rebornType_UseItem:

        rebornItem = ItemCommon.FindItemInPackByEffectEx(curPlayer, ChConfig.Def_Effect_Reborn)

        if not rebornItem:

            GameWorld.ErrLog("复活道具不足，无法原地复活! ", playerID)                
            return

        
        if isDoCost:

            ItemCommon.DelItem(curPlayer, rebornItem, 1, True, "Reborn")

            
    return True



def __DoPlayerReborn(curPlayer, rebornType, tick, mapBornPlace=0, isAddSuperBuff=True):

    ## 执行玩家复活逻辑，该函数没有执行验证是否可复活等，不可直接调用

    

    if curPlayer.GetHP() > 0 and curPlayer.GetPlayerAction() != IPY_GameWorld.paDie:

        # 当血量大于0收到复活请求时，一般是前后端复活状态不一致的情况下导致的

        # 由于前端需要根据复活状态判断复活界面相关逻辑，所以这里需要做一些特殊处理，防止某些情况下前后端复活状态不一致导致的一些异常问题

        # 后端非死亡状态的情况，补同步一次复活包给前端

        SyncPlayerReborn(curPlayer, rebornType)

        return

    
    resetHpPercent = ChConfig.Def_MaxRateValue

    isFBReborn = False

    #-----------------------------------------回城复活(切换地图)-----------------------------------

    if playerRebornType == ChConfig.rebornType_City:

    if rebornType == ChConfig.rebornType_City:

        if FBLogic.OnPlayerReborn():

            isFBReborn = True

        else:

            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_IsReBorn, 1)

        
#===============================================================================

#        #不在特殊的地图中,玩家副本中复活相关

#        if not FBLogic.OnPlayerReborn():

#            #输出系统提示

#            __NotifyReBornToPlace( curPlayer )

#===============================================================================



    
    #----------------------------------------------其他复活(不切换地图)------------------------------------

    #技能复活

    elif playerRebornType == ChConfig.rebornType_Skill:



        if not gameMap.GetSkillReborn():

            return False

        
        reBornSkill =  GameWorld.GetGameData().GetSkillBySkillID(ChConfig.Def_SkillID_SkillReBorn)

        #恢复血量万分比

        resetHpPercent = reBornSkill.GetEffect(1).GetEffectValue(0)

        #恢复魔万分比

        resetMpPercent = reBornSkill.GetEffect(2).GetEffectValue(0)

        
        BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_SkillReBorn, tick)

    
    #原地健康复活

    elif playerRebornType == ChConfig.rebornType_Health:

        #if not PlayerVip.GetVipCanOriginalReborn(curVipLv):

        #    #vip等级限制

        #    return

        if not gameMap.GetLocalReborn():

            GameWorld.DebugLog('    地图配置不能原地复活')

            return False

        
        if not __HealthRebornPayMoney(curPlayer):

            return False

        
    #使用道具(还阳咒)复活

    elif playerRebornType == ChConfig.rebornType_UseItem:



        if not gameMap.GetLocalReborn():

            return False

        
        if not __RebornDelItem(curPlayer):

            return False

    
    # 副本复活

    elif playerRebornType in [ChConfig.rebornType_FBGold, ChConfig.rebornType_FBUseItem]:

        isFBReborn = True

        freeBorn = FBLogic.DecFreeRebornCount(curPlayer)

        if not freeBorn:

            if not gameMap.GetLocalReborn():

                return False

            

            if playerRebornType == ChConfig.rebornType_FBGold:

                #if not PlayerVip.GetVipCanOriginalReborn(curVipLv):

                #    #vip等级限制

                #    return False

                
                if not __HealthRebornPayMoney(curPlayer):

                    return False

                
            elif playerRebornType == ChConfig.rebornType_FBUseItem:

                if not __RebornDelItem(curPlayer):

                    return False

    elif playerRebornType == ChConfig.rebornType_MainCity:

    elif rebornType == ChConfig.rebornType_MainCity:

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_IsReBorn, 2)



    elif playerRebornType == ChConfig.rebornType_System:

        pass

    
    else:

        #封包错误

#        GameWorld.Log("重生封包类型 = %s错误"%(playerRebornType), curPlayerID )

        return False

    
        
    #通知客户端玩家复活成功

    curPlayer.Reborn(playerRebornType)

    curPlayer.Reborn(rebornType)

    

    #执行玩家副本复活

    if isFBReborn:

@@ -4081,16 +4080,8 @@
        SkillCommon.AddBuffBySkillType_NoRefurbish(curPlayer , ChConfig.Def_SkillID_LimitSuperBuff, tick)

    #复活疲劳BUff

    if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_IsAddReviveTired):

        findBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_ReviveTired)[0]

        if findBuff:

            buffSkillLV = findBuff.GetSkill().GetSkillLV()

            if findBuff.GetSkill().GetSkillMaxLV() != buffSkillLV:

                buffSkillLV = buffSkillLV + 1

        else:

            buffSkillLV = 1

        SkillCommon.AddBuffBySkillType_NoRefurbish(curPlayer , ChConfig.Def_SkillID_ReviveTired, tick, buffSkillLV)

        GameWorld.DebugLog('    复活疲劳BUff buffSkillLV=%s'%(buffSkillLV))

        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_IsAddReviveTired,0)

        __AddReviveTired(curPlayer, tick)

        
    #复活后清除角色身上的打BOSS和PK状态

    validTime = IpyGameDataPY.GetFuncCfg("PKConfig", 4) * 1000

    if PlayerState.IsInPKState(curPlayer):

@@ -4109,15 +4100,16 @@
    PlayerControl.SetProDef(curPlayer, PlayerControl.GetMaxProDef(curPlayer))

    

    #玩家复活后副本处理

    FBLogic.OnPlayerRebornOver(curPlayer, playerRebornType)

        
    FBLogic.OnPlayerRebornOver(curPlayer, rebornType)

    
    gameMap = GameWorld.GetMap()

    #障碍点中原地复活, 打回重生点

    if (playerRebornType == ChConfig.rebornType_City and not isFBReborn)\

    or not GameWorld.GetMap().CanMove(curPlayer.GetPosX(), curPlayer.GetPosY()) \

    or (playerRebornType == ChConfig.rebornType_MainCity and gameMap.GetRebornMapID() == curPlayer.GetMapID()):

    if (rebornType == ChConfig.rebornType_City and not isFBReborn) \

        or not GameWorld.GetMap().CanMove(curPlayer.GetPosX(), curPlayer.GetPosY()) \

        or (rebornType == ChConfig.rebornType_MainCity and gameMap.GetRebornMapID() == curPlayer.GetMapID()):

        #玩家切换到重生点

        playerControl.SetToBornPlace()        

    elif playerRebornType == ChConfig.rebornType_MainCity:

    elif rebornType == ChConfig.rebornType_MainCity:

        #直接取db中配置的复活点

        PlayerControl.PlayerResetWorldPos(curPlayer, gameMap.GetRebornMapID(), gameMap.GetRebornMapX(), gameMap.GetRebornMapY(), False)

    #重新召唤宠物

@@ -4125,57 +4117,38 @@
    

    #复活成功,重置状态

    PlayerControl.ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)

    return True

    return



##复活扣除元宝

#@param curPlayer 玩家实例

#@return 是否扣除成功

def __HealthRebornPayMoney(curPlayer):

    rebornCfg = IpyGameDataPY.GetFuncEvalCfg('RebornArguments', 1)

    moneyPrice = rebornCfg[2]

    #异常

    if not moneyPrice:

        return True

    costMoneyList = PlayerControl.HaveMoneyEx(curPlayer, ShareDefine.TYPE_Price_Gold_Paper_Money, moneyPrice)

    if not costMoneyList:

        return False

    infoDict = {}

    for moneyType, moneyCnt in costMoneyList:

        if not PlayerControl.PayMoney(curPlayer, moneyType, moneyCnt, ChConfig.Def_Cost_Revive, infoDict):

            return False

def __AddReviveTired(curPlayer, tick):

    ## 增加复活疲劳

    findBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_ReviveTired)[0]

    if findBuff:

        buffSkillLV = findBuff.GetSkill().GetSkillLV()

        if findBuff.GetSkill().GetSkillMaxLV() != buffSkillLV:

            buffSkillLV = buffSkillLV + 1

    else:

        buffSkillLV = 1

    SkillCommon.AddBuffBySkillType_NoRefurbish(curPlayer , ChConfig.Def_SkillID_ReviveTired, tick, buffSkillLV)

    GameWorld.DebugLog('    复活疲劳BUff buffSkillLV=%s'%(buffSkillLV))

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_IsAddReviveTired,0)    
    return



def PlayerRebornByType(curPlayer, rebornType, tick, mapBornPlace=0, isAddSuperBuff=True):

    ''' 玩家复活

    '''

    gameMap = GameWorld.GetMap()

    if not __CheckCanReborn(curPlayer, rebornType, gameMap):

        return

    

    GameWorld.Login_Interface_GoldRec(curPlayer , 0 , 0 , 'HealthReborn' , moneyType , moneyPrice)

    if not GameWorld.IsCrossServer():

        if not __RebornCost(curPlayer, rebornType, True):

            return

        
    __DoPlayerReborn(curPlayer, rebornType, tick, mapBornPlace, isAddSuperBuff)

    return True



##复活扣除道具

#@param curPlayer 玩家实例

#@return 是否扣除成功

def __RebornDelItem(curPlayer):

    rebornItem = ItemCommon.FindItemInPackByEffectEx(curPlayer, ChConfig.Def_Effect_Reborn)

    if not rebornItem:

        #GeRen_chenxin_143504 对不起,您没有XXX!

        #PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_143504", [ChConfig.Def_ItemID_Reborn])

        return False

            
    #调用通用接口删除道具

    ItemCommon.DelItem(curPlayer, rebornItem, 1, True, "Reborn")

    return True





#---------------------------------------------------------------------

#===============================================================================

# def __NotifyReBornToPlace( curPlayer ):

#    #普通地图

#    if GameWorld.GetMap().GetMapFBType() == IPY_GameWorld.fbtNull:

#        #Revival_Home   <n color="0,255,0">提示：您可以在各大主城的杂货店消除身上携带的虚弱状态!</n>  256 -

#        PlayerControl.NotifyCode( curPlayer, "Revival_Home" )

#    #副本中

#    elif not FBLogic.DoNotifyReBorn( curPlayer ):

#        #输出默认提示

#        PlayerControl.NotifyCode( curPlayer, "Revival_Home" )

#    
#    return

#===============================================================================



##副本接口:玩家复活

#@param curPlayer 玩家实例

#@param tick 时间戳


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerControl.py

@@ -1583,6 +1583,12 @@
        NotifyCode(curPlayer, "CrossMatching18")

        return

    

    if curPlayer.GetHP() <= 0:

        return

    
    if PlayerCrossRealmPK.GetIsCrossPKMatching(curPlayer):

        return

    
    GY_Query_CrossRealmReg.RegisterEnterCrossServer(curPlayer, mapID)

    return



@@ -5713,7 +5719,10 @@


## 跨服状态: 0-非跨服状态，1-跨服状态

def GetCrossRealmState(curPlayer): return curPlayer.GetExAttr5()

def SetCrossRealmState(curPlayer, value): curPlayer.SetExAttr5(value, False, True)

def SetCrossRealmState(curPlayer, value):

    NomalDictSetProperty(curPlayer, ChConfig.Def_PlayerKey_CrossMapID, value)

    curPlayer.SetExAttr5(1 if value else 0, False, True)

    return



## 铜钱点, 支持铜钱超20亿

def GetSilver(curPlayer): return curPlayer.GetExAttr6() * ChConfig.Def_PerPointValue + curPlayer.GetSilver()


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerCrossRealmPK.py

@@ -33,10 +33,10 @@


## 是否匹配中

def SetIsCrossPKMatching(curPlayer, isMatching):

    curPlayer.SetDict(ChConfig.Def_PlayerKey_IsCrossPKMatching, isMatching)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PlayerKey_IsCrossPKMatching, isMatching)

    return

def GetIsCrossPKMatching(curPlayer): 
    return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_IsCrossPKMatching) and IsCrossRealmPKMatchState()

def GetIsCrossPKMatching(curPlayer):

    return curPlayer.NomalDictGetProperty(ChConfig.Def_PlayerKey_IsCrossPKMatching) and IsCrossRealmPKMatchState()



def DoPlayerOnDay(curPlayer):

    if GameWorld.IsCrossServer():


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/RemoteQuery/GY_Query_ClientServerReceiveMsg.py

New file
@@ -0,0 +1,47 @@
#!/usr/bin/python

# -*- coding: GBK -*-

#-------------------------------------------------------------------------------

#

##@package Player.RemoteQuery.GY_Query_ClientServerReceiveMsg

#

# @todo:子服收到跨服服务器信息

# @author hxp

# @date 2019-01-10

# @version 1.0

#

# 详细描述: 子服收到跨服服务器信息

#

#-------------------------------------------------------------------------------

#"""Version = 2019-01-10 15:30"""

#-------------------------------------------------------------------------------



import GameWorld

import ShareDefine

import ChPlayer



#------------------------------------------------------------------------------ 


def DoLogic(query_Type, query_ID, packCMDList, tick): 
    return





#------------------------------------------------------------------------------ 
## 执行结果

#  @param curPlayer 发出请求的玩家

#  @param callFunName 功能名称

#  @param funResult 查询的结果

#  @param tick 当前时间

#  @return None

#  @remarks 函数详细说明.

def DoResult(curPlayer, callFunName, funResult, tick):

    playerID = curPlayer.GetPlayerID()

    GameWorld.Log("GY_Query_ClientServerReceiveMsg %s" % funResult, playerID)

    msgType, msgData = eval(funResult)

    
    if msgType == ShareDefine.CrossServerMsg_RebornRet:

        ChPlayer.CrossServerMsg_RebornRet(curPlayer, msgData, tick)

        
    return



    
    

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/RemoteQuery/GY_Query_CrossRealmReg.py

@@ -49,29 +49,29 @@
    GameWorld.Log("GY_Query_CrossRealmReg DoResult %s" % funResult, curPlayer.GetPlayerID())

    if not resultInfo:

        return

    registerType, mapID, dataMapID, copyMapID, posX, posY = resultInfo

    RegisterEnterCrossServer(curPlayer, registerType, mapID, dataMapID, copyMapID, posX, posY)

    registerMap, mapID, dataMapID, copyMapID, posX, posY = resultInfo

    RegisterEnterCrossServer(curPlayer, registerMap, mapID, dataMapID, copyMapID, posX, posY)

    return



def RegisterEnterCrossServer(curPlayer, registerType, mapID=0, dataMapID=0, copyMapID=0, posX=0, posY=0):

def RegisterEnterCrossServer(curPlayer, registerMap, mapID=0, dataMapID=0, copyMapID=0, posX=0, posY=0):

    '''

    @param registerType: 一般是dataMapID

    @param registerMap: 一般是dataMapID

    '''

    playerID = curPlayer.GetPlayerID()

    if GameWorld.IsCrossServer():

        GameWorld.Log("    跨服服务器不允许上传报名数据!", playerID)

        return

    

    playerRegisterType = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CrossRegisterType)

    if playerRegisterType in ChConfig.RegisterEnter_CrossServerMapIDList:

        GameWorld.ErrLog("跨服已经在上传数据，不重复提交!playerRegisterType=%s,registerType=%s" % (playerRegisterType, registerType), curPlayer.GetPlayerID())

    playerRegisterMap = curPlayer.NomalDictGetProperty(ChConfig.Def_PlayerKey_CrossRegisterMap)

    if playerRegisterMap in ChConfig.RegisterEnter_CrossServerMapIDList:

        GameWorld.ErrLog("跨服已经在上传数据，不重复提交!playerRegisterMap=%s,registerMap=%s" % (playerRegisterMap, registerMap), curPlayer.GetPlayerID())

        return

    

    zoneID = 0

    if not mapID:

        zoneIpyData = CrossRealmPlayer.GetServerCrossZoneIpyData(registerType)

        zoneIpyData = CrossRealmPlayer.GetServerCrossZoneIpyData(registerMap)

        if not zoneIpyData:

            GameWorld.ErrLog("找不到该服务器对应跨服分区: registerType=%s" % (registerType))

            GameWorld.ErrLog("找不到该服务器对应跨服分区: registerMap=%s" % (registerMap))

            return

        zoneID, mapID, dataMapID, copyMapID, posX, posY = zoneIpyData.GetZoneID(), zoneIpyData.GetMapID(), \

            zoneIpyData.GetDataMapID(), zoneIpyData.GetCopyMapID(), zoneIpyData.GetPosX(), zoneIpyData.GetPosY()

@@ -82,15 +82,15 @@
    #跨服前更新自己所属服务器组ID

    PlayerControl.UpdPlayerServerGroupID(curPlayer)

    

    if registerType in ChConfig.RegisterEnter_CrossServerMapIDList:

    if registerMap in ChConfig.RegisterEnter_CrossServerMapIDList:

        prepareEnterCrossServer = ChPyNetSendPack.tagMCPrepareEnterCrossServer()

        prepareEnterCrossServer.DataMapID = registerType

        prepareEnterCrossServer.DataMapID = registerMap

        NetPackCommon.SendFakePack(curPlayer, prepareEnterCrossServer)

    curPlayer.SetDict(ChConfig.Def_PlayerKey_CrossRegisterType, registerType)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PlayerKey_CrossRegisterMap, registerMap)

    #curPlayer.SendMergeRegisterPlayer(mapID, dataMapID, copyMapID, posX, posY)

    curPlayer.SendMergeRegisterPlayerAfterChange(CrossRealmPlayer.GetCrossPlayerName(curPlayer), mapID, dataMapID, copyMapID, posX, posY)

    GameWorld.Log("    发送跨服玩家数据注册: registerType=%s,zoneID=%s,mapID=%s,dataMapID=%s,copyMapID=%s,posX=%s,posY=%s,GetVsRoomId=%s" 
                  % (registerType, zoneID, mapID, dataMapID, copyMapID, posX, posY, curPlayer.GetVsRoomId()), playerID)

    GameWorld.Log("    发送跨服玩家数据注册: registerMap=%s,zoneID=%s,mapID=%s,dataMapID=%s,copyMapID=%s,posX=%s,posY=%s,GetVsRoomId=%s" 
                  % (registerMap, zoneID, mapID, dataMapID, copyMapID, posX, posY, curPlayer.GetVsRoomId()), playerID)

    return



## 跨服赛报名结果（上传数据）

@@ -100,27 +100,27 @@
def GameServer_MergeRegisterResult(index, tick):

    registerResult = IPY_GameWorld.IPY_GMMergeRegisterPlayerResult()

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    registerType = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CrossRegisterType)

    curPlayer.SetDict(ChConfig.Def_PlayerKey_CrossRegisterType, 0)

    registerMap = curPlayer.NomalDictGetProperty(ChConfig.Def_PlayerKey_CrossRegisterMap)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PlayerKey_CrossRegisterMap, 0)

    playerID = curPlayer.GetPlayerID()

    result = registerResult.GetResult()

    GameWorld.Log("GameServer_MergeRegisterResult registerType=%s,result=%s" % (registerType, result), playerID)

    GameWorld.Log("GameServer_MergeRegisterResult registerMap=%s,result=%s" % (registerMap, result), playerID)

    if not result:

        errorMsg = registerResult.GetErrorMsg()

        GameWorld.Log("CrossRealmReg result Error:%s" % errorMsg, playerID)

        NetPackCommon.SendFakePack(curPlayer, ChPyNetSendPack.tagMCEnterCrossServerError())

        return

    

    if registerType in ChConfig.RegisterEnter_CrossServerMapIDList:

    if registerMap in ChConfig.RegisterEnter_CrossServerMapIDList:

        CrossRealmPlayer.DoEnterCrossRealm(curPlayer)

        PlayerControl.SetCrossRealmState(curPlayer, 1)

        PlayerControl.SetCrossRealmState(curPlayer, registerMap)

        NetPackCommon.SendFakePack(curPlayer, ChPyNetSendPack.tagMCStartEnterCrossServer())

        return

    

    #newAccount = registerResult.GetAccount()

    #newName = registerResult.GetPwd()

    

    msgList = str([registerType]) 
    msgList = str([registerMap]) 
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(curPlayer.GetID(), 0, 0, "CrossRealmReg", msgList, len(msgList))    

    return

    


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/RemoteQuery/GY_Query_CrossServerReceiveMsg.py

New file
@@ -0,0 +1,47 @@
#!/usr/bin/python

# -*- coding: GBK -*-

#-------------------------------------------------------------------------------

#

##@package Player.RemoteQuery.GY_Query_CrossServerReceiveMsg

#

# @todo:跨服服务器收到子服信息

# @author hxp

# @date 2019-01-10

# @version 1.0

#

# 详细描述: 跨服服务器收到子服信息

#

#-------------------------------------------------------------------------------

#"""Version = 2019-01-10 15:30"""

#-------------------------------------------------------------------------------



import GameWorld

import ShareDefine

import ChPlayer



#------------------------------------------------------------------------------ 


def DoLogic(query_Type, query_ID, packCMDList, tick): 
    return





#------------------------------------------------------------------------------ 
## 执行结果

#  @param curPlayer 发出请求的玩家

#  @param callFunName 功能名称

#  @param funResult 查询的结果

#  @param tick 当前时间

#  @return None

#  @remarks 函数详细说明.

def DoResult(curPlayer, callFunName, funResult, tick):

    playerID = curPlayer.GetPlayerID()

    GameWorld.Log("GY_Query_CrossServerReceiveMsg %s" % funResult, playerID)

    msgType, msgData, serverGroupID = eval(funResult)

    
    if msgType == ShareDefine.ClientServerMsg_Reborn:

        ChPlayer.ClientServerMsg_Reborn(curPlayer, msgData, serverGroupID, tick)

        
    return



    
    

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ShareDefine.py

@@ -1204,6 +1204,7 @@
CrossServerMsg_PutInItem = "PutInItem"                  # 获得物品

CrossServerMsg_GiveMoney = "GiveMoney"                  # 获得货币

CrossServerMsg_DropGoodItem = "DropGoodItem"            # 掉落好物品

CrossServerMsg_RebornRet = "RebornRet"                  # 复活结果



# 子服发送跨服信息定义

ClientServerMsg_ServerInitOK = "ServerInitOK"           # 子服启动成功

@@ -1213,6 +1214,7 @@
ClientServerMsg_PKCancel = "PKCancel"                   # 跨服PK取消匹配

ClientServerMsg_PKPrepareOK = "PKPrepareOK"             # 跨服PK准备完毕

ClientServerMsg_PKBillboard = "PKBillboard"             # 跨服PK排行榜

ClientServerMsg_Reborn = "Reborn"                       # 复活



#角色改名结果

(