---------------------logic同world通信的协议定义-----------------------
---初始hello
LW_HELLO = {
  {"svrIndex",        "int"},
}

LW_DISCONNECT = {}
LW_HEARTBEAT = {
	{"svrIndexData",  "table"},
}

LW_MOZHU_QUERY = {
  {"uuid",            "string"},
  {"unionUuid",       "string"},
}

WL_MOZHU_QUERY = {
  {"uuid",             "string"},
  {"myRank",             "int"},
  {"roleRank",         "table"},
  {"unionRank",        "table"},
  {"info",             "table"},
}

WL_HELLO = {
  {"nGetSvrID",        "int"},
  {"nNowSvrID",        "int"},
}

WL_HEARTBEAT = {}

LW_MIDDLE_CHAT = 
{
  {"svrIndex",               "int"},
  {"tChatMsg",               "table"},
}

WL_MIDDLE_CHAT = 
{
  {"tChatMsg",               "table"}
}



---------------------------------------通用协议-------------------------------------------

--------------- 战斗录像--------------------------------------
-- 查询录像数据
LW_COMBAT_VIDEO_QUERY = {
  {"sourceServerId",               "int"},      -- 请求方服务器Id
  {"videoUuid",                    "string"},   -- 录像唯一标识
  {"extraArgs",                    "table"},    -- 额外参数
}
WL_COMBAT_VIDEO_QUERY = {
  {"res",                           "int"},    -- 结果，-1: 未找到相关数据, 0-正确命中
  {"videoData",                    "zip"},   -- 录像数据
  {"extraArgs",                    "table"},   -- 额外参数
}


-- 保存录像数据
LW_COMBAT_VIDEO_SAVE = {
  -- {"sourceServerId",               "int"},  -- 请求方服务器Id
  {"videoType",                    "int"},     -- 录像类型
  {"videoData",                    "zip"},   -- 录像数据
  {"extraArgs",                    "table"},   -- 额外参数
}

--------------------------------------------------------------


-----------------获取战斗数据----------------------------------
WL_COMBAT_DATA = {
  {"playerUuid",                    "string"},    -- 玩家uuid
  {"moduleTag",                     "int"},       -- 请求模块标识
  {"combatType",                    "int"},       -- 战斗类型
  {"extraArgs",                     "table"},     -- 额外参数
}

LW_COMBAT_DATA = {
  {"errCode",                       "int"},       -- 错误码，1:正确，-1: 没有对应类型的战斗数据
  {"moduleTag",                     "int"},       -- 请求模块标识
  {"extraArgs",                     "table"},     -- 额外参数
  {"objList",                       "table"},
  {"helpList",                      "table"},
  {"roleBase",                      "table"},
  {"formation",                     "int"},
  {"jiBan",                         "table"},
  {"elfList",                        "table"}
}

-----------------------------------------------------------------------------------------



-- 聊天查看分享英雄数据(请求的服务器->中心)
LW_MIDDLE_CHAT_QUERY_HERO_DATA = 
{
    {"nSrcServerID",        "int"},     -- 源服务器ID
    {"nDesServerID",        "int"},     -- 目标服务器ID
    {"nSrcUID",             "string"},  -- 请求的玩家UID
    {"nDesUID",             "string"},  -- 查询的玩家UID
    {"nHeroIndex",          "int"},     -- 查看的英雄下表
    {"nChatType",           "int"},     -- 聊天频道
}

-- 发送到对应服务器信息(中心->目标服务器)
WL_MIDDLE_CHAT_QUERY_HERO_DATA = 
{
    {"nSrcServerID",        "int"},     -- 源服务器ID
    {"nSrcUID",             "string"},  -- 请求的玩家UID
    {"nDesUID",             "string"},  -- 查询的玩家UID
    {"nHeroIndex",          "int"},     -- 查看的英雄下表
    {"nChatType",           "int"},     -- 聊天频道
}

-- 英雄信息回复(目标->中心)
LW_MIDDLE_CHAT_GET_HERO_DATA = 
{ 
    -- {"nResult",             "int"},     -- 结果 1 获取成功，0 获取不到数据  
    {"nSrcUID",             "string"},  -- 请求的玩家UID
    {"nSrcServerID",        "int"},     -- 源服务器ID
    {"tHeroData",           "table"},   -- 英雄数据
}

-- 英雄信息回复(目标->中心)
WL_MIDDLE_CHAT_GET_HERO_DATA = 
{ 
    -- {"nResult",             "int"},     -- 结果 1 获取成功，0 获取不到数据  
    {"nSrcUID",             "string"},  -- 请求的玩家UID
    {"tHeroData",           "table"},   -- 英雄数据
}

-- 请求战报录像
LW_WARREPORT_GET_COMBATINFO =
{
    {"nSrcUID",           "string"},
    {"type",              "int"},
    {"id",                "string"},
    {"mode",                "int"},
    {"nSrcServerID",        "int"},     -- 源服务器ID
    {"nDesServerID",        "int"},     -- 目标服务器ID
}

WL_WARREPORT_GET_COMBATINFO =
{
    {"nSrcUID",           "string"},
    {"type",              "int"},
    {"id",                "string"},
    {"nSrcServerID",        "int"},     -- 源服务器ID
    {"mode",                "int"},
}

-- 发送战报数据
LW_WARREPORT_SEND_COMBATINFO = 
{
    {"nSrcUID",           "string"},
    {"mode",                "int"},
    {"combatInfo",        "table"},
    {"nSrcServerID",        "int"},     -- 源服务器ID
}

WL_WARREPORT_SEND_COMBATINFO = 
{
    {"nSrcUID",           "string"},
    {"mode",                "int"},
    {"combatInfo",        "table"},
}

-------------------- 请求跨服玩家头像数据开始 --------------------
LW_CHAT_PLAYER_INFO = 
{
  {"nSrcUID",           "string"},    -- 请求uid
  {"nDesUID",           "string"},    -- 目标UID
  {"nSrcServerID",        "int"},     -- 源服务器ID
  {"nDesServerID",        "int"},     -- 目标服务器ID
  {"nFrom",               "int"},     -- 来源(1 聊天查看，2 天梯赛)
  {"nType",               "int"},     -- 类型(2-1 天梯赛对战列表，2-2 天梯赛排行榜)
}

WL_CHAT_PLAYER_INFO = 
{
  {"nSrcUID",           "string"},    -- 请求uid
  {"nDesUID",           "string"},    -- 目标UID
  {"nSrcServerID",        "int"},     -- 源服务器ID
  {"nFrom",               "int"},     -- 来源(1 聊天查看，2 天梯赛)
  {"nType",               "int"},     -- 类型(2-1 天梯赛对战列表，2-2 天梯赛排行榜)
}

LW_CHAT_PLAYER_INFO_SEND = 
{
  {"nSrcUID",           "string"},    -- 请求uid
  {"nSrcServerID",        "int"},     -- 源服务器ID
  {"tData",             "table"},     -- 目标玩家数据
  {"nFrom",               "int"},     -- 来源(1 聊天查看，2 天梯赛)
  {"nType",               "int"},     -- 类型(2-1 天梯赛对战列表，2-2 天梯赛排行榜)
}

WL_CHAT_PLAYER_INFO_SEND = 
{
  {"nSrcUID",           "string"},    -- 请求uid
  {"tData",             "table"},     -- 目标玩家数据
  {"nFrom",               "int"},     -- 来源(1 聊天查看，2 天梯赛)
  {"nType",               "int"},     -- 类型(2-1 天梯赛对战列表，2-2 天梯赛排行榜)
}

-------------------- 请求跨服玩家头像数据结束 --------------------

-------------------- 请求跨服切磋开始 ---------------------------
---请求敌方数据
LW_COMBAT_GETINFO =
{
  {"nSrcUID",           "string"},    -- 请求uid
  {"nDesUID",           "string"},    -- 目标UID
  {"nSrcServerID",        "int"},     -- 源服务器ID
  {"nDesServerID",        "int"},     -- 目标服务器ID
  {"nCombatType",         "int"},     -- 对战类型
  {"extraArgs",           "table"},   -- 额外参数
}

WL_COMBAT_GETINFO =
{
  {"nSrcUID",           "string"},    -- 请求uid
  {"nDesUID",           "string"},    -- 目标UID
  {"nSrcServerID",        "int"},     -- 源服务器ID
  {"nCombatType",         "int"},     -- 对战类型
  {"extraArgs",           "table"},   -- 额外参数
}

-- 回复数据
LW_COMBAT_GETINFO_SEND = 
{
  {"nResult",           "int"},       -- 结果
  {"nSrcUID",           "string"},    -- 请求uid
  {"nSrcServerID",        "int"},     -- 源服务器ID
  {"tObjList",            "table"},
  {"tHelpList",           "table"},
  {"tRoleBase",           "table"},
  {"formation",           "int"},
  {"tJiBan",              "table"},
  {"tElfList",            "table"},
}

WL_COMBAT_GETINFO_SEND = 
{
  {"nResult",             "int"},       -- 结果
  {"nSrcUID",             "string"},    -- 请求uid
  {"tObjList",            "table"},
  {"tHelpList",           "table"},
  {"tRoleBase",           "table"},
  {"formation",           "int"},
  {"tJiBan",              "table"},
  {"tElfList",            "table"},
}

-------------------- 请求跨服切磋结束 ---------------------------

-------------------- 跨服商业活动开始 ---------------------------
-- 请求开服天数
WL_COMMERCE_QUERYOPENDAY = {
}

-- 回复开服天数
LW_COMMERCE_SENDOPENDAY = {
  {"nOpenDay",            "int"},
  {"nSrcServerID",        "int"},
}

-- 请求是否开启活动
LW_COMMERCE_ACTOPEN = 
{
  {"nSrcServerID",        "int"},     -- 源服务器ID
  {"nOperate",            "int"},     -- 来源
}

WL_COMMERCE_ACTOPEN = 
{
  {"nOpen",               "int"},     -- 1 开 0 未开
  {"nOperate",            "int"},     -- 来源
  {"nServerKey",          "int"},     -- 服务器Key
}

-- 排行榜数据改变发送到中心服进行排行
LW_COMMERCE_RANK_POINT_CHANGE = 
{
  {"uuid",              "string"},       -- 玩家uid
  {"name",              "string"},       -- 玩家姓名
  {"head",              "int"},       -- 玩家头像ID
  {"headFrame",         "int"},       -- 玩家头像框
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nValue",            "int"},       -- 排行key
  {"nRankType",         "int"},       -- 排行类型
  {"nRankSubType",      "int"},       -- 排行榜小类型
  {"nOperate",          "int"},       -- 操作类型(1 累加nValue, 2 直接替换 )
  {"servername",        "string"},    -- 服务器名称
}

-- 请求排行榜数据
LW_COMMERCE_QUERY_RANK_INFO = 
{
  {"nRankType",         "int"},       -- 排行类型
  {"nRankSubType",      "int"},       -- 排行榜小类型
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 回复排行榜数据
WL_COMMERCE_QUERY_RANK_INFO = {
  {"nRankType",         "int"},       -- 排行类型
  {"nRankSubType",      "int"},       -- 排行榜小类型
  {"nServerKey",        "int"},       -- 服务器ID
  {"nBegin",            "int"},       -- 首次发送
  {"nEnd",              "int"},       -- 是否发送完成
  {"tRankData",         "table"},     -- 排行榜数据
}

-- 获取服务器排行榜服务器排名
LW_COMMERCE_QUERY_SERVER_RANK = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nServerUuid",       "string"},       -- 服务器唯一区分ID
  {"nOperate",          "int"},       -- 操作类型
}

-- 获取服务器排行榜服务器排名 回包
WL_COMMERCE_GET_SERVERRANK_PRIZE = 
{
  {"nRank",               "int"},     -- 排名
  {"nOperate",          "int"},       -- 操作类型
}

-- 通知中心服全服邮件发送完成
LW_COMMERCE_TELL_SERVER_MAILOK = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 发送给对应的服务器 个人排行榜奖励
WL_COMMERCE_SEND_HUMAN_PRIZE = 
{
  {"nRank",             "int"},
  {"uuid",              "string"},
}

-- 清理排行榜命令
LW_COMMERCE_CLEAR_RANK = 
{
  {"nRankType",         "int"},       -- 排行类型
  {"nRankSubType",      "int"},       -- 排行榜小类型
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- GM清理个人邮件发送缓存
LW_COMMERCE_GM_CLEAR_MAIL = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 获取战区第一个服的活动时间数据
WL_COMMERCE_GET_ACT_INFO = {
  {"nReqServerID",        "int"}    -- 不存在时为0
}

-- 发送给中心服活动时间数据
LW_COMMERCE_GET_ACT_INFO = 
{
  {"nOperate",          "int"},       -- 0 失败 1 成功有数据 2 成功无数据
  {"nReqServerID",      "int"},       -- 不存在时为0
  {"nSrcServerID",      "int"},       -- 服务器ID 
  {"nBatchID",          "int"},       -- 批次
  {"nBeginTime",        "int"},       -- 开始时间
  {"nEndTime",          "int"},       -- 结束时间
}

-- 请求中心服活动时间
LW_COMMERCE_ACT_GET_OPENTIME = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 回复普通服活动时间
WL_COMMERCE_ACT_GET_OPENTIME = 
{
  {"nBatchID",          "int"},       -- 批次
  {"nBeginTime",        "int"},       -- 开始时间
  {"nEndTime",          "int"},       -- 结束时间
}

-------------------- 跨服商业活动结束 ---------------------------

-------------------- 天梯赛开始 -----------------------------------
-- 请求参加天梯赛(普通->中心)
LW_JJC_NEWLADDER_JOINLADDER_O2C = 
{
    {"uuid",              "string"},    -- 玩家uid
    {"name",              "string"},    -- 名字
    {"head",              "int"},       -- 玩家头像ID
    {"headFrame",         "int"},       -- 玩家头像框
    {"nSrcServerID",      "int"},       -- 服务器ID
    {"szServerName",      "string"},    -- 服务器名字
    {"zhandouli",         "int"},       -- 战斗力
}

-- 请求参加天梯赛(中心->战区数据服)
WL_JJC_NEWLADDER_JOINLADDER_C2D = {
    {"uuid",              "string"},    -- 玩家uid
    {"name",              "string"},    -- 名字
    {"head",              "int"},       -- 玩家头像ID
    {"headFrame",         "int"},       -- 玩家头像框
    {"nSrcServerID",      "int"},       -- 服务器ID
    {"szServerName",      "string"},    -- 服务器名字
    {"zhandouli",         "int"},       -- 战斗力
}

-- 请求参加天梯赛(数据->中心)
LW_JJC_NEWLADDER_JOINLADDER_D2C = {
    {"uuid",              "string"},    -- 玩家uid
    {"nSrcServerID",      "int"},       -- 玩家所属服务器ID
    {"nRank",             "int"},       -- 玩家当前排名
    {"tEnemy",            "table"},     -- 对战列表
    {"nPoint",            "int"},       -- 当前玩家积分
}

-- 请求参加天梯赛(中心->普通)
WL_JJC_NEWLADDER_JOINLADDER_C2O = {
    {"uuid",              "string"},    -- 玩家uid
    {"nRank",             "int"},       -- 玩家当前排名
    {"tEnemy",            "table"},     -- 对战列表
    {"nPoint",            "int"},       -- 当前玩家积分
}

-- 请求天梯赛排行榜数据(普通->中心)
LW_JJC_NEWLADDER_QUERY_RANK_O2C = {
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 请求天梯赛排行榜数据(中心->战区数据服)
WL_JJC_NEWLADDER_QUERY_RANK_C2D = {
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 请求天梯赛排行榜数据(数据服->中心)
LW_JJC_NEWLADDER_QUERY_RANK_D2C = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nIsEnd",            "int"},       -- 是否发送完成 0 未 1 发送完
  {"tRankInfo",         "table"},     -- 排行榜数据
  {"nFirst",            "int"},       -- 首次发送 1 是 0 否
}

-- 请求天梯赛排行榜数据(中心->普通)
WL_JJC_NEWLADDER_QUERY_RANK_C2O = 
{
  {"nFirst",            "int"},       -- 首次发送 1 是 0 否
  {"nIsEnd",            "int"},       -- 是否发送完成 0 未 1 发送完
  {"tRankInfo",         "table"},     -- 排行榜数据
}

-- 查询是否能够战斗(普通->中心)
LW_JJC_NEWLADDER_QUERY_CAN_FIGHT_O2C = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 目标uid
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 查询是否能够战斗(中心->战区数据服)
WL_JJC_NEWLADDER_QUERY_CAN_FIGHT_C2D = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 目标uid
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 查询是否能够战斗(数据服->中心)
LW_JJC_NEWLADDER_QUERY_CAN_FIGHT_D2C = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 目标uid
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nIsFight",          "int"},       -- 0 不能战斗 1 可以战斗
}

-- 查询是否能够战斗(中心->普通)
WL_JJC_NEWLADDER_QUERY_CAN_FIGHT_C2O = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 目标uid
  {"nIsFight",          "int"},       -- 0 不能战斗 1 可以战斗
}

-- 战斗结束(普通->中心)
LW_JJC_NEWLADDER_CANCEL_FIGHT_END_O2C = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 目标uid
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nResult",           "int"},       -- 战斗结果 0 输 1赢
  {"tEnemyUid",         "table"},     -- 对战列表
  {"nZhanDouLi",         "int"},       -- 战斗力
}

-- 战斗结束(中心->战区数据服)
WL_JJC_NEWLADDER_CANCEL_FIGHT_END_C2D = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 目标uid
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nResult",           "int"},       -- 战斗结果 0 输 1赢
  {"tEnemyUid",         "table"},     -- 对战列表
  {"nZhanDouLi",        "int"},       -- 战斗力
}

-- 战斗结束(数据服->中心)
LW_JJC_NEWLADDER_CANCEL_FIGHT_END_D2C = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 对手uid
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nNewRank",          "int"},       -- 新的排名
  {"nNewPoint",         "int"},       -- 新的点数
  {"tOldEnemyData",     "table"},     -- 旧的对手数据
  {"tNewOneEnemy",      "table"},     -- 新对手的数据
}

-- 战斗结束
WL_JJC_NEWLADDER_CANCEL_FIGHT_END_C2O = {
  {"uuid",              "string"},    -- 玩家uid
  {"uuidDes",           "string"},    -- 对手uid
  {"nNewRank",          "int"},       -- 新的排名
  {"nNewPoint",         "int"},       -- 新的点数
  {"tOldEnemyData",     "table"},     -- 旧的对手数据
  {"tNewOneEnemy",      "table"},     -- 新对手的数据
}

-- 发送战败邮件(数据->中心)
LW_JJC_NEWLADDER_SEND_MAIL_D2C = {
  {"uuidDes",           "string"},      -- 目标uid
  {"nDesServerID",      "int"},         -- 目标服务器ID
  {"szServerName",      "string"},      -- 挑战玩家对应服务器名称
  {"szName",            "string"},      -- 挑战玩家名称
  {"nNewRank",          "int"},         -- 新排名
}

-- 发送战败邮件(中心->目标)
WL_JJC_NEWLADDER_SEND_MAIL_C2O = {
  {"uuidDes",           "string"},      -- 目标uid
  {"szServerName",      "string"},      -- 挑战玩家对应服务器名称
  {"szName",            "string"},      -- 挑战玩家名称
  {"nNewRank",          "int"},         -- 新排名
}

-- 请求刷新对战列表(普通->中心)
LW_JJC_NEWLADDER_REFRESH_O2C = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 请求刷新对战列表(中心->数据)
WL_JJC_NEWLADDER_REFRESH_C2D = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 请求刷新对战列表(数据->中心)
LW_JJC_NEWLADDER_REFRESH_D2C = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"tEnemy",            "table"},     -- 对战列表
}

-- 请求刷新对战列表(中心-普通)
WL_JJC_NEWLADDER_REFRESH_C2O = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"tEnemy",            "table"},     -- 对战列表
}

-- 请求上一轮前3玩家信息(普通->中心)
LW_JJC_NEWLADDER_LAST3RANK_O2C = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 请求上一轮前3玩家信息(中心->数据)
WL_JJC_NEWLADDER_LAST3RANK_C2D = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
}

-- 请求上一轮前3玩家信息(数据->中心)
LW_JJC_NEWLADDER_LAST3RANK_D2O = 
{
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"nExist",            "int"},       -- 是否存在数据
  {"tLastRankInfo",     "table"}      -- 上一次排名数据
}

-- 请求上一轮前3玩家信息(中心-普通)
WL_JJC_NEWLADDER_LAST3RANK_C2O = 
{
  {"nExist",            "int"},       -- 是否存在数据
  {"tLastRankInfo",     "table"}      -- 上一次排名数据
}

-- 进行点赞(普通->中心)
LW_JJC_NEWLADDER_SEND_WORSHIP_O2C = 
{
  {"uuidSrc",           "string"},
  {"uuidDes",           "string"},
  {"nSrcServerID",      "int"},
  {"nDesServerID",      "int"},
}

-- 进行点赞(中心->数据(被点赞玩家所在服))
WL_JJC_NEWLADDER_SEND_WORSHIP_C2D = {
  {"uuidSrc",           "string"},
  {"uuidDes",           "string"},
  {"nSrcServerID",      "int"},
}

-- 进行点赞(数据->中心(被点赞玩家所在服))
LW_JJC_NEWLADDER_SEND_WORSHIP_D2C =
{
  {"uuidSrc",           "string"},
  {"nSrcServerID",      "int"},
  {"uuidDes",           "string"},
  {"nNowWorShip",       "int"}
}

-- 进行点赞(中心->普通)
WL_JJC_NEWLADDER_SEND_WORSHIP_C2O =
{
  {"uuidSrc",           "string"},
  {"uuidDes",           "string"},
  {"nNowWorShip",       "int"}
}

-- 告诉战区服点赞数改变(中心->战区数据服)
-- 改变战区数据服记录的点赞数量
WL_JJC_NEWLADDER_WORSHIP_CHANGE_C2D =
{
  {"uuidDes",           "string"},
  {"nAddNum",           "int"},     -- 增加数量
}

-- 通知中心服最新的点赞数
LW_JJC_NEWLADDER_WORSHIP_CHANGE_D2C = 
{
  {"uuidDes",           "string"},
  {"nNowWorShip",       "int"},
  {"nSrcServerID",      "int"},
}

-- 通知对应战区所属服务器更新最新的点赞数
WL_JJC_NEWLADDER_WORSHIP_UPDATE_D2C = 
{
  {"uuidDes",           "string"},
  {"nNowWorShip",       "int"}
}

-- 发送排名奖励(数据->中心)
LW_JJC_NEWLADDER_SEND_RANK_PRIZE_D2C =
{
  {"uuid",              "string"},    -- 玩家uid
  {"nServerID",         "int"},       -- 服务器ID
  {"nRank",             "int"},       -- 排名
}

-- 发送排名奖励(中心->普通)
WL_JJC_NEWLADDER_SEND_RANK_PRIZE_C2O =
{
  {"uuid",              "string"},    -- 玩家uid
  {"nRank",             "int"},       -- 排名
}

-- 请求玩家当前的点赞数(数据->中心)
LW_JJC_NEWLADDER_QUERY_WORSHIP_D2C = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"nServerID",         "int"},       -- 玩家所属服
  {"nFromServerID",     "int"},       -- 请求来源服
}

-- 请求玩家当前的点赞数(中心->普通)
WL_JJC_NEWLADDER_QUERY_WORSHIP_C20 = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"nFromServerID",     "int"},       -- 请求来源服
}

-- 请求玩家当前的点赞数(普通->中心)
LW_JJC_NEWLADDER_QUERY_WORSHIP_O2C = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"nFromServerID",     "int"},       -- 请求来源服
  {"nWorShip",          "int"},       -- 当前玩家点赞数
}

-- 请求玩家当前的点赞数(中心->数据)
WL_JJC_NEWLADDER_QUERY_WORSHIP_C2D = 
{
  {"uuid",              "string"},    -- 玩家uid
  {"nWorShip",          "int"},       -- 当前玩家点赞数
}
-------------------- 天梯赛结束 -----------------------------------


-------------------- 封禁功能开始 -----------------------------------
--从跨服请求封禁数据
LW_QUERY_BAN_INFO = {
  {"nSrcServerID",      "int"},       -- 服务器ID
}

WL_QUERY_BAN_INFO = {
  {"banList",           "table"},       --  禁止登录列表
}

-- 通知跨服更新
LW_UPDATE_BAN_INFO =
{
  {"nSrcServerID",      "int"},          -- 服务器ID
  -- {"banTag",            "string"},       -- 禁止登录标识
  -- {"banTime",           "int"},          -- 禁止登录时间
  -- {"banLevel",          "int"},          -- 禁止等级

  {"banStr",          "string"},          -- 封禁数据
}

WL_UPDATE_BAN_INFO =
{
  -- {"banTag",            "string"},       -- 禁止登录标识
  -- {"banTime",           "int"},          -- 禁止登录时间
  -- {"banLevel",          "int"},          -- 禁止等级

  {"banStr",          "string"},          -- 封禁数据
}

-------------------- 封禁功能结束 -----------------------------------

----------------------- 返利开始 -----------------------------------

--向跨服查询是否能返利
LW_REBATE_QUERY = {
  {"nSrcServerID",      "int"},       -- 服务器ID
  {"channelId",         "int"},       -- 渠道D
  {"serverId",          "int"},       -- 区服ID
  {"account",           "string"},       -- 账号
}

WL_REBATE_OK = {
  {"channelId",         "int"},       -- 渠道D
  {"serverId",          "int"},       -- 区服ID
  {"account",           "string"},       -- 账号
}
-------------------- 返利结束 -----------------------------------

-------------------- 桌面添加开始 -----------------------------------

-- 普通服→中心服：上报添加桌面（仅写入，无需回包）
LW_DESKTOP_SET = {
  {"nSrcServerID",  "int"},     -- 来源区服ID
  {"channelId",     "int"},     -- 渠道ID
  {"serverId",      "int"},     -- 区服ID
  {"account",       "string"},  -- 账号
  {"platform",      "string"},  -- 平台标识
}

-- 普通服→中心服：查询桌面状态
LW_DESKTOP_QUERY = {
  {"nSrcServerID",  "int"},     -- 来源区服ID（用于路由回包）
  {"channelId",     "int"},     -- 渠道ID
  {"serverId",      "int"},     -- 区服ID
  {"account",       "string"},  -- 账号
  {"platform",      "string"},  -- 平台标识
}

-- 中心服→普通服：查询结果回包
WL_DESKTOP_QUERY = {
  {"channelId",       "int"},     -- 渠道ID
  {"serverId",        "int"},     -- 区服ID
  {"account",         "string"},  -- 账号
  {"platform",        "string"},  -- 平台标识
  {"isDesktopAdded",  "int"},     -- 是否已添加 0否 1是
}

-------------------- 桌面添加结束 -----------------------------------


--------------------------诸神圣域------------------------------------
-- 普通服向跨服请求排行榜数据
LW_GODSATREA_QUERY_RANKLIST = {
  {"playerUid",             "string"},    -- 请求者uuid
  {"sourceServerId",        "int"},       -- 请求方服务器ID
}

WL_GODSATREA_QUERY_RANKLIST = {
  {"myRank",                "int"},         -- 请求者排名
  {"playerUid",             "string"},      -- 请求者uuid
  {"rankList",              "table"},       -- 排行榜数据
}



-- 普通服向跨服请求某个排名的玩家数据
LW_GODSATREA_QUERY_PLAYER_INFO = {
  {"sourceServerId",      "int"},       -- 请求方服务器ID
  {"targetRank",          "int"},       -- 要查看玩家的排名
  {"targetUid",           "string"},    -- 要查看玩家的uuid
  {"playerUid",           "string"},    -- 请求者uuid
}

WL_GODSATREA_QUERY_PLAYER_INFO = {
  {"res",               "int"},         -- 请求结果, 0: 成功, -1: 数据异常, -2: 不是最新数据
  {"playerInfo",        "table"},       -- 排行榜数据
  {"playerUid",         "string"},      -- 请求者uuid
}



-- 查询是否能挑战玩家
LW_GODSATREA_CHALLENGE_QUERY = {
  {"sourceServerId",        "int"},       -- 进攻方服务器ID
  {"defenseRank",           "int"},       -- 防御方排名
  {"defenseUid",            "string"},    -- 防御方uuid
  {"attackerUid",           "string"},    -- 进攻方uid
}

WL_GODSATREA_CHALLENGE_QUERY = {
  {"res",                   "int"},       -- 请求结果, 0: 可以挑战, 1: 自己正被挑战, 2: 目标正在战斗，-1: 数据异常, -2: 不是最新数据,-3：不能挑战比自己低的
  {"defenseServerId",       "int"},       -- 防御方服务器ID
  {"defenseRank",           "int"},       -- 防御方排名
  {"defenseUid",            "string"},    -- 防御方uuid
  {"attackerUid",           "string"},    -- 进攻方uid
  {"defenseName",           "string"},    -- 防御方名字
}

-- 请求挑战玩家
-- LW_GODSATREA_CHALLENGE = {
--   {"sourceServerId",        "int"},       -- 进攻方服务器ID
--   {"defenseRank",           "int"},       -- 防御方排名
--   {"defenseUid",            "string"},    -- 防御方uuid
--   {"attackerUid",           "string"},    -- 进攻方uid
-- }

-- -- 跨服向防御方请求战斗数据
-- WL_GODSATREA_GET_COMBAT_DATA = {
--   {"defenseRank",             "int"},         -- 防御方排名
--   {"defenseUid",             "string"},       -- 防御方uuid
--   {"attackerRank",           "int"},          -- 进攻方排名
--   {"attackerUid",            "string"},       -- 进攻方uuid
-- }

-- -- 防御方向跨服发送战斗数据
-- LW_GODSATREA_GET_COMBAT_DATA = {
--   {"sourceServerId",        "int"},         -- 防御方服务器ID
--   {"attackerRank",          "int"},         -- 进攻方排名
--   {"attackerUid",           "string"},      -- 进攻方uuid
--   {"defenseRank",           "int"},         -- 防御方排名
--   {"defenseUid",            "string"},      -- 防御方uuid
--   {"defenseCombatData",     "table"},       -- 防御方的战斗数据
-- }

-- -- 跨服向挑战方发送防御方的战斗数据
-- WL_GODSATREA_CHALLENGE = {
--   {"res",                  "int"},          -- 请求结果
--   {"defenseRank",          "int"},          -- 防御方排名
--   {"defenseUid",           "string"},       -- 防御方uuid
--   {"defenseMonsterOUtId",  "int"},          -- 防御方怪物ID, 如果值不为0, 则表示防御方是怪物, 就用不到 defenseCombatData 了
--   {"defenseCombatData",    "table"},        -- 防御方的战斗数据
-- }

-- 通知跨服挑战成功
LW_GODSATREA_WIN = {
  {"sourceServerId",        "int"},         -- 进攻方服务器ID
  {"defenseRank",           "int"},         -- 防御方排名
  {"defenseUid",            "string"},      -- 防御方uuid
  {"attackerUid",           "string"},      -- 进攻方uuid
  {"attackInfo",            "table"},       -- 进攻方信息。 如果进攻方没有排名时挑战胜利, 更新展示信息
}

-- 跨服通知玩家, 更换称号
WL_GODSATREA_UPDATE_CHENGHAO = {
  {"targetUid",             "string"},    -- 玩家uuid
  {"newRank",               "int"},       -- 新的排名
  {"enemyName",             "string"},    -- 敌方名字
  {"isWinner",              "int"},       -- 是否是胜利方, 0-否，1-是
}




-- 向跨服请求某个排名的战斗录像
LW_GODSATREA_QUERY_RANK_VIDEO = {
  {"sourceServerId",        "int"},        -- 请求方服务器ID
  {"playerUid",            "string"},      -- 玩家uuid
  {"targetRank",           "int"},         -- 目标排名
}
-- 跨服向请求服发送目标的战斗录像
WL_GODSATREA_QUERY_RANK_VIDEO = {
  {"isFinish",              "int"},        -- 是否发送完成，0-否, 1-是
  {"playerUid",            "string"},      -- 玩家uuid
  {"videoData",            "zip"},       -- 排名战斗录像
}



-- 通知跨服, 玩家基础数据有更新
LW_GODSATREA_UPDATE_PLAYER_BASE_INFO = {
  -- {"sourceServerId",        "int"},      -- 服务器ID
  {"playerUid",             "string"},      -- 玩家uuid
  {"playerInfo",            "table"},       -- 玩家信息, 改名等修改基础数据时更新
}
-- 通知跨服, 英雄数据有更新
LW_GODSATREA_UPDATE_PLAYER_HERO_INFO = {
  -- {"sourceServerId",        "int"},      -- 服务器ID
  {"playerUid",             "string"},      -- 玩家uuid
  {"power",                 "int"},         -- 战力
  {"heroInfo",              "table"},       -- 玩家英雄信息
}

-- 跨服通知游戏服发奖励
WL_GODSATREA_BROCAST_REWARD = {
  {"uid2RankTb",            "table"},       -- uid->rank 表
}

-- 跨服通知玩家, 更新数据
WL_GODSATREA_UPDATE_PLAYER_INFO = {
  {"playerUid",             "string"},      -- 玩家uuid
}


---------------------------------------------------------------------

---------------------------------战区争霸----------------------------

-- 跨服通知普通服活动开启
WL_AREABATTLE_OPEN = {
}

-- 普通服报名参加争霸活动
LW_AREABATTLE_JOIN_BATTLE = {
  {"sourceServerId",        "int"},        -- 参战服务器Id
  {"joinBattleArray",       "table"},      -- 参战玩家列表
}


-- 普通服请求争霸活动的基本数据
LW_AREABATTLE_BASEINFO_QUERY = {
  {"sourceServerId",        "int"},
  {"playerUuid",             "string"},      -- 玩家uuid
}
WL_AREABATTLE_BASEINFO_QUERY = {
  {"stage",                         "int"},            -- 当前阶段, 0-休战, 1-准备, 2- 战斗, 3-发奖
  {"startTime",                     "int"},            -- 本轮活动开始时间
  {"endTime",                      "int"},            -- 本轮活动结束时间
  {"playerUuid",                   "string"},      -- 玩家uuid
}


-- 普通服请求本服参与争霸活动的玩家数据
LW_AREABATTLE_JOINPLAYER_QUERY = {
  {"sourceServerId",        "int"},
  {"playerUuid",             "string"},      -- 玩家uuid
}
WL_AREABATTLE_JOINPLAYER_QUERY = {
  {"errCode",             "int"}, -- 错误码，0: 正常, -1: 本服每次没有参加战斗 
  {"playerArray",        "table"},
  {"playerUuid",          "string"},      -- 玩家uuid
}


-- 普通服请求参与本轮活动的区服的匹配列表
LW_AREABATTLE_MATCHLIST_QUERY = {
  {"sourceServerId",        "int"},
  {"playerUuid",             "string"},      -- 玩家uuid
}
WL_AREABATTLE_MATCHLIST_QUERY = {
  {"matchList",        "table"},
  {"playerUuid",             "string"},      -- 玩家uuid
}


-- 跨服通知普通服发奖
WL_AREABATTLE_SEND_REWARD = {
  {"srvBattleRes",        "table"}, -- 本服战斗结果
}


-- 普通服请求本服相关的录像展示数据
LW_AREABATTLE_VIDEOSHOW_QUERY = {
  {"sourceServerId",        "int"},
  {"playerUuid",             "string"},      -- 玩家uuid
}
WL_AREABATTLE_VIDEOSHOW_QUERY = {
  {"errCode",               "int"},     -- 错误码，0: 正常, -1: 本服每次没有参加战斗, -2: 录像数据还没产生，请稍后再尝试
  {"videoShowData",         "table"},   -- 录像数据
  {"srvInfo",               "table"},   -- 区服数据
  {"playerUuid",            "string"},  -- 玩家uuid
}

--------------------- 巅峰战场跨服协议开始 -----------------------------------
-- 普通服请求跨服排名数据(普通->中心)
-- LW_PEAK_BATTLEFIELD_QUERY_RANK_O2C = {
--   {"nSrcServerID",          "int"},       -- 服务器ID
--   {"nRankType",             "int"},       -- 排名类型（1=个人排名，2=服务器排名）
-- }

-- -- 请求跨服排名数据(中心->数据服)
-- WL_PEAK_BATTLEFIELD_QUERY_RANK_C2D = {
--   {"nSrcServerID",          "int"},       -- 服务器ID
--   {"nRankType",             "int"},       -- 排名类型
-- }

-- -- 请求跨服排名数据(数据服->中心)
-- LW_PEAK_BATTLEFIELD_QUERY_RANK_D2C = {
--   {"nSrcServerID",          "int"},       -- 服务器ID
--   {"nRankType",             "int"},       -- 排名类型
--   {"nIsEnd",                "int"},       -- 是否发送完成 0 未 1 发送完
--   {"tRankInfo",             "table"},     -- 排行榜数据
--   {"nFirst",                "int"},       -- 首次发送 1 是 0 否
-- }

-- -- 获取到跨服排名数据(中心->普通)
-- WL_PEAK_BATTLEFIELD_QUERY_RANK_C2O = {
--   {"nFirst",                "int"},       -- 首次发送 1 是 0 否
--   {"nIsEnd",                "int"},       -- 是否发送完成 0 未 1 发送完
--   {"tRankInfo",             "table"},     -- 排行榜数据
-- }

-- -- 普通服通知排名变化(普通->中心)
-- LW_PEAK_BATTLEFIELD_RANK_CHANGE_O2C = {
--   {"uuid",                  "string"},    -- 玩家uuid
--   {"name",                  "string"},    -- 玩家名字
--   {"head",                  "int"},       -- 玩家头像ID
--   {"headFrame",             "int"},       -- 玩家头像框
--   {"nSrcServerID",          "int"},       -- 服务器ID
--   {"nRank",                 "int"},       -- 当前排名
--   {"nValue",                "int"},       -- 排名值（如积分等）
--   {"servername",            "string"},    -- 服务器名称
-- }

-- -- 排名变化通知(中心->数据服)
-- WL_PEAK_BATTLEFIELD_RANK_CHANGE_C2D = {
--   {"uuid",                  "string"},    -- 玩家uuid
--   {"name",                  "string"},    -- 玩家名字
--   {"head",                  "int"},       -- 玩家头像ID
--   {"headFrame",             "int"},       -- 玩家头像框
--   {"nSrcServerID",          "int"},       -- 服务器ID
--   {"nRank",                 "int"},       -- 当前排名
--   {"nValue",                "int"},       -- 排名值
--   {"servername",            "string"},    -- 服务器名称
-- }

-- -- 发送排名奖励(数据服->中心)
-- LW_PEAK_BATTLEFIELD_SEND_RANK_REWARD_D2C = {
--   {"uuid",                  "string"},    -- 玩家uid
--   {"nServerID",             "int"},       -- 服务器ID
--   {"nRank",                 "int"},       -- 排名
--   {"tReward",               "table"},     -- 奖励列表
-- }

-- -- 发送排名奖励(中心->普通)
-- WL_PEAK_BATTLEFIELD_SEND_RANK_REWARD_C2O = {
--   {"uuid",                  "string"},    -- 玩家uid
--   {"nRank",                 "int"},       -- 排名
--   {"tReward",               "table"},     -- 奖励列表
-- }

-- 查询玩家排名
LW_BATTLEGROUND_PLAYER_RANK_QUERY = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
}
WL_BATTLEGROUND_PLAYER_RANK_QUERY = {
  {"playerUuid",              "string"},     -- 玩家uuid
  {"playerRank",              "int"},        -- 玩家排名
}

-- 查询对手列表信息
LW_BATTLEGROUND_MATCHLIST_QUERY = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
  {"matchList",               "table"},      -- 对手列表
}
WL_BATTLEGROUND_MATCHLIST_QUERY = {
  {"playerUuid",              "string"},     -- 玩家uuid
  {"playerInfoList",          "table"},      -- 对手列表信息
}


-- 查询玩家信息
LW_BATTLEGROUND_PLAYER_DATA_QUERY = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
  {"playerRank",               "int"},       -- 玩家排名
}
WL_BATTLEGROUND_PLAYER_DATA_QUERY = {
  {"playerUuid",              "string"},     -- 玩家uuid
  {"playerInfo",              "table"},      -- 玩家信息
}


-- 查询排行榜数据
LW_BATTLEGROUND_RANKLIST_QUERY = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
}
WL_BATTLEGROUND_RANKLIST_QUERY = {
  {"playerUuid",              "string"},     -- 玩家uuid
  {"rankList",                "table"},      -- 排行榜信息
}


-- 请求挑战玩家
LW_BATTLEGROUND_CHALLENGE_QUERY = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
  {"rank",                    "int"},        -- 排名
}
WL_BATTLEGROUND_CHALLENGE_QUERY = {
  {"errCode",                 "int"},        -- 错误码
  {"playerUuid",              "string"},     -- 玩家uuid
  {"playerInfo",              "table"},      -- 玩家数组
}

-- 挑战结束
LW_BATTLEGROUND_CHALLENGE_END = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
  {"atkRank",                 "int"},        -- 挑战方原排名
  {"defRank",                 "int"},        -- 防守方原排名
  {"challengeRes",            "int"},        -- 挑战结果
  {"playerShowData",          "table"},      -- 挑战方玩家展示信息
}

-- 通知玩家更新数据
WL_BATTLEGROUND_NOTIFY_PLAYER = {
  {"playerUuid",              "string"},     -- 玩家uuid
  {"newRank",                 "int"},        -- 最新排名
  {"atkeServerId",            "int"},        -- 挑战方服务器Id
  {"atkName",                 "string"},     -- 挑战者名字
  {"updateType",              "int"},        -- 更新类型, 1-排名上升, 2-排名下降
}


-- 玩家更新阵容
LW_BATTLEGROUND_LINEUP_UPDATE = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
  {"heroArr",                 "table"},      -- 阵容英雄列表
}

-- 活动结束
LW_BATTLEGROUND_ACT_END = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
}

-- 通知发奖
WL_BATTLEGROUND_NOTIFY_PRIZEAWARD = {
  {"playerArr",              "table"},     -- 要发奖的玩家信息列表
}


--------------------- 巅峰战场跨服协议结束 -----------------------------------

---------------------------------异界之战----------------------------

-- 异常提示
WL_ANOTHERWORLDBATTLE_TIPS = {
  {"errCode",               "int"},     -- 错误码, 具体定义见 AnotherWorldBattleDefine.lua
  {"playerUuid",             "string"}, -- 玩家uuid
}

-- 获取状态
LW_ANOTHERWORLDBATTLE_GET_STATE = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
  {"myUnionId",               "string"},     -- 公会信息
  {"isTips",                  "int"},        -- 是否用于提示
}
WL_ANOTHERWORLDBATTLE_GET_STATE = {
  {"playerUuid",              "string"},   -- 玩家uuid
  {"systemState",              "int"},     -- 活动状态
  {"joinState",              "int"},       -- 报名状态
  {"isTips",                  "int"},        -- 是否用于提示
}


-- 报名
LW_ANOTHERWORLDBATTLE_JOIN = {
  {"sourceServerId",          "int"},        -- 请求服服务器Id
  {"playerUuid",              "string"},     -- 玩家uuid
  {"unionInfo",               "table"},      -- 公会信息
}
WL_ANOTHERWORLDBATTLE_JOIN = {
  {"playerUuid",              "string"},     -- 玩家uuid
  {"myUnionId",                 "string"},   -- 公会Id
}


-- 查询所有城池信息
LW_ANOTHERWORLDBATTLE_ALLCITY_QUERY = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},     -- 请求者的公会Id
}
WL_ANOTHERWORLDBATTLE_ALLCITY_QUERY  = {
  {"playerUuid",                "string"},
  {"cityArr",                   "table"},   -- 公会所在分组的所有城池数据
  {"myUnionBaseCityId",          "int"},   -- 公会出生点城池Id
  {"myOccupyCityArr",            "table"}, -- 公会占领的城池信息
  {"hasPointNum",                 "int"},  -- 玩家当前占领的据点数量
  {"challengeTimes",            "int"},   -- 公会出生点城池Id
  {"lastTime",                  "int"},   -- 公会出生点城池Id
  {"occupyPointData",           "table"},  -- 公会占领的据点数据
}

-- 查询单个城池的详细信息
LW_ANOTHERWORLDBATTLE_CITYDETAILED_QUERY = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
  {"targetCityId",            "int"},
}
WL_ANOTHERWORLDBATTLE_CITYDETAILED_QUERY = {
  {"playerUuid",              "string"},
  {"targetCityId",             "int"},
  {"myUnionOccupyArr",         "table"},
  {"pointArr",                 "table"},
  {"gatherState",              "int"},  -- 0-不能集结, 1-可集结, 2-已集结
  {"gatherTime",                "int"},  -- 集结时间, 不显示时值为-1
}

-- 查询公会所在分组的单个城池的某个据点详细信息
LW_ANOTHERWORLDBATTLE_POINTtDETAILED_QUERY = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",           "int"},
}
WL_ANOTHERWORLDBATTLE_POINTDETAILED_QUERY = {
  {"playerUuid",              "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",          "int"},
  {"pointInfo",               "table"},
}


-- 查询公会出生点信息
LW_ANOTHERWORLDBATTLE_BASECITY_QUERY = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
}
WL_ANOTHERWORLDBATTLE_BASECITY_QUERY = {
    {"playerUuid",              "string"},
    {"baseCityInfo",             "table"},
}

-- 查询玩家占领的据点信息
LW_ANOTHERWORLDBATTLE_PLAYEROCCUPYPOINT_QUERY = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
}
WL_ANOTHERWORLDBATTLE_PLAYEROCCUPYPOINT_QUERY = {
    {"playerUuid",              "string"},
    {"occupyPointArr",            "table"},
}


-- 查询的公会排行榜
LW_ANOTHERWORLDBATTLE_UNIONRANK_QUERY = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
}
WL_ANOTHERWORLDBATTLE_UNIONRANK_QUERY = {
  {"playerUuid",              "string"},
  {"myUnionRank",              "int"},
  {"unionRankArr",             "table"},
}


-- 查询的玩家排行榜
LW_ANOTHERWORLDBATTLE_PLAYERRANK_QUERY = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
}
WL_ANOTHERWORLDBATTLE_PLAYERRANK_QUERY = {
  {"playerUuid",              "string"},
  {"myRank",                  "int"},
  {"playerRankArr",           "table"},
}


-- 集结
LW_ANOTHERWORLDBATTLE_GATHER = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
  {"targetCityId",            "int"},
  {"opType",                  "int"},
}
WL_ANOTHERWORLDBATTLE_GATHER = {
  {"playerUuid",              "string"},
  {"targetCityId",            "int"},
  {"opType",                  "int"},
}


-- 挑战某个据点
LW_ANOTHERWORLDBATTLE_POINT_ISCAN_CHALLENGE = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",           "int"},
}
WL_ANOTHERWORLDBATTLE_POINT_ISCAN_CHALLENGE = {
  {"playerUuid",              "string"},
  {"pointInfo",               "table"},
}

-- 挑战据点结束
LW_ANOTHERWORLDBATTLE_POINT_CHALLENGE_END = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",          "int"},
  {"challengeRes",            "int"},
  {"playerShowInfo",          "table"},
}

-- 通知玩家, 据点被别的玩家占领了
WL_ANOTHERWORLDBATTLE_POINT_LOSE = {
  {"playerUuid",             "string"},
  {"loseCityId",            "int"},
  {"losePointIdx",          "int"},
}


-- 发奖
WL_ANOTHERWORLDBATTLE_ISSUEREWARD = {
  {"unionOccupyInfo",          "table"},
}


-- 玩家数据更新
LW_ANOTHERWORLDBATTLE_UPDATE_PLAYER = {
  {"playerUuid",              "string"},
  {"updateData",               "table"},
  {"myUnionId",              "string"},
}

-- 公会数据更新
LW_ANOTHERWORLDBATTLE_UPDATE_UNION = {
  {"myUnionId",              "string"},
  {"updateData",               "table"},
}

-- 更换据点防守阵容
LW_ANOTHERWORLDBATTLE_UPDATE_POINT_LINEIP = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"heroArr",                 "table"},
  {"targetCityId",            "int"},
  {"targetPointIdx",          "int"},
  {"formation",		            "int"},--阵法
	{"heroList"	,			          "table"},--上阵英雄
	{"helpList"	,			          "table"},--辅助对象
}
-- 更换据点防守阵容
WL_ANOTHERWORLDBATTLE_UPDATE_POINT_LINEIP = {
  {"playerUuid",              "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",          "int"},
  {"formation",		            "int"},--阵法
	{"heroList"	,			          "table"},--上阵英雄
	{"helpList"	,			          "table"},--辅助对象
}

-- 异界之战活动开启
WL_ANOTHERWORLDBATTLE_ACT_START = {
  {"startTime",              "int"},
}


-- 玩家英雄更新
LW_ANOTHERWORLDBATTLE_UPDATE_HERO = {
  {"playerUuid",              "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",          "int"},
  {"heroData",               "table"},
}

-- 放弃某个据点
LW_ANOTHERWORLDBATTLE_LEAVE_POINT = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",           "int"},
}
WL_ANOTHERWORLDBATTLE_LEAVE_POINT = {
  {"playerUuid",              "string"},
  {"targetCityId",            "int"},
  {"targetPointIdx",          "int"},
}


-- 获取本公会士气信息
LW_ANOTHERWORLDBATTLE_GET_MYUIONMORALE = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
}
WL_ANOTHERWORLDBATTLE_GET_MYUIONMORALE = {
  {"playerUuid",              "string"},
  {"moraleState",             "int"},
  {"moraleAttrIdx",           "int"}, -- 士气加成属性索引
  {"moraleStartTime",          "int"},
}

-- 给本公会加士气
LW_ANOTHERWORLDBATTLE_UIONMORALE_DO = {
  {"sourceServerId",          "int"},
  {"playerUuid",              "string"},
  {"myUnionId",               "string"},
}
WL_ANOTHERWORLDBATTLE_UIONMORALE_DO = {
  {"playerUuid",              "string"},
  {"opRes",                     "int"},
}

--------------------------百战成神 (LW=逻辑服->跨服, WL=跨服->逻辑服)------------------------------------
-- 客户端字段说明见 baiZhanChengShen/Proto.lua
-- 错误码 errCode 见 BaiZhanChengShenDefine.BZCS_ERR_*

-- 按积分步进匹配对手(最多3人)
LW_BZCS_MATCH = {
  {"sourceServerId",        "int"},
  {"playerUuid",            "string"},
  {"refreshRanks",          "table"},  -- 非空时仅按名次刷新展示, 不重算匹配; 全量匹配传 {}
}
WL_BZCS_MATCH = {
  {"playerUuid",            "string"},
  {"myScore",               "int"},    -- 匹配基准积分
  {"myRank",                "int"},    -- 请求方全服名次
  {"opponentList",          "table"},  -- [{rank,uuid,serverId,name,body,power,score,isRobot}, ...]
}

-- 排行榜前100
LW_BZCS_RANK_LIST = {
  {"sourceServerId",        "int"},
  {"playerUuid",            "string"},
}
WL_BZCS_RANK_LIST = {
  {"playerUuid",            "string"},
  {"myRankInfo",            "table"},  -- BZCS_RANK_INFO: rank,name,head,headFrame,power,score,serverId,uuid
  {"rankList",              "table"},  -- [{rank,uuid,name,head,headFrame,serverId,power,score,...}, ...]
}

-- 对手基础信息
LW_BZCS_OPPONENT_INFO = {
  {"sourceServerId",        "int"},
  {"playerUuid",            "string"},
  {"targetRank",            "int"},    -- 对手全服名次
}
WL_BZCS_OPPONENT_INFO = {
  {"playerUuid",            "string"},
  {"res",                   "int"},    -- 0=成功 -1=目标不存在
  {"targetInfo",            "table"},  -- {name,head,headFrame,power,score}
}

-- 对手五族阵容展示
LW_BZCS_OPPONENT_LINEUP = {
  {"sourceServerId",        "int"},
  {"playerUuid",            "string"},
  {"targetRank",            "int"},    -- 对手全服名次
}
WL_BZCS_OPPONENT_LINEUP = {
  {"playerUuid",            "string"},
  {"targetRank",            "int"},
  {"showInfo",              "table"},  -- {name,lv,head,headFrame, heroArr={[race]=...}}
  {"isRobot",               "int"},    -- 1=机器人(客户端用 monsterOut 展开)
}

-- 挑战前校验目标存在(扣次在 NS C2N_CanFight)
LW_BZCS_CAN_FIGHT = {
  {"sourceServerId",        "int"},
  {"playerUuid",            "string"},
  {"targetRank",            "int"},    -- 防守方全服名次(开战时锁定该名次上的玩家)
}
WL_BZCS_CAN_FIGHT = {
  {"playerUuid",            "string"},
  {"res",                   "int"},    -- 0=可开战
  {"targetRank",            "int"},    -- 开战锁定的全服名次
  {"defUuid",               "string"},
  {"defServerId",           "int"},    -- 防守方逻辑服 SVR_INDEX
  {"defName",               "string"},
  {"defScore",              "int"},
  {"isRobot",               "int"},    -- 1=机器人
}

LW_BZCS_REGISTER = {
  {"playerInfo",            "table"},  -- uuid,serverId,firstJoinTime, showInfo={name,head,headFrame,body,heroArr}
}

-- 已注册玩家增量同步展示(updateType 见 BZCS_UPDATE_SHOW_*; showInfo 仅含变更字段)
LW_BZCS_UPDATE_SHOW = {
  {"playerUuid",            "string"},
  {"updateType",            "int"},    -- 1=name, 3=head, 4=headFrame, 5=单族阵容, 6=body
  {"race",                  "int"},    -- updateType=5 时种族 1~5
  {"showInfo",              "table"},  -- 增量字段, 跨服 MergeShowInfo 合并
}

-- 整场 5 局 3 胜结算(跨服改分后 WL 通知双方)
LW_BZCS_FIGHT_END = {
  {"atkUuid",               "string"},
  {"atkServerId",           "int"},
  {"atkName",               "string"},
  {"defUuid",               "string"},
  {"defName",               "string"},
  {"defServerId",           "int"},
  {"atkWin",                "int"},    -- 攻方整场胜负 1=胜 0=负
  {"raceResults",           "table"},  -- 五族逐局 [raceIdx]=1胜2负
}
WL_BZCS_FIGHT_END = {
  {"playerUuid",            "string"}, -- 攻方 uuid
  {"atkWin",                "int"},    -- 同 LW atkWin
  {"scoreChange",           "int"},    -- 攻方本场积分变化(+100/-50)
  {"myScore",               "int"},    -- 攻方战后积分
  {"defName",               "string"},
  {"defServerId",           "int"},
  {"raceResults",           "table"},
}

-- 守方被挑战通知(真人, 非机器人)
WL_BZCS_DEF_NOTIFY = {
  {"playerUuid",            "string"}, -- 守方 uuid
  {"atkName",               "string"},
  {"atkServerId",           "int"},
  {"atkWin",                "int"},    -- 守方视角 1=守方胜 0=守方负
  {"scoreChange",           "int"},    -- 守方积分变化(+50/-50)
  {"myScore",               "int"},
  {"raceResults",           "table"},
}

-- 周期结算发奖(跨服->逻辑服, 按服批量; rewardList={{uuid,rank},...})
WL_BZCS_ISSUE_REWARD = {
  {"rewardList",            "table"},  -- 本服待发奖列表 {{uuid, rank}, ...}
}

-- 活动开启广播(全逻辑服或单 fd 重连补偿)
WL_BZCS_ACT_START = {
  {"startTime",             "int"},
  {"endTime",               "int"},
}

-- 活动结束, 逻辑服清 KEY_BZCS_START_TIME 与本地轮次数据
WL_BZCS_ACT_END = {}

-- 跨服业务错误提示(对应 BZCS_ERR_*)
WL_BZCS_TIPS = {
  {"playerUuid",            "string"},
  {"errCode",               "int"},
}