RoServer/RO_Server_Trunk-branch_0.1.39/roserver/serverproto/login.proto

syntax = "proto3";
package serverproto;

import "user.proto";

message ServerInfo{
    string      id      = 1;
    int32       port    = 2;
}
//project Service:"gate|game" RouteRule:"pass"
message CSPingReq{
    string      open_id         = 3;
}

message SCPingAck{
}

//游戏登陆操作project Service:"gate" RouteRule:"pass"
message CSLoginReq{	//project game|auth //RouteRule game
    string      platform        = 1; //用户平台
    int32       phone_platform  = 2; //手机平台 android ios
    string      platform_token  = 3; //平台token验证登陆
    string      open_id         = 4; //平台账号ID
    string      password        = 5; //密码
    string      crypt_pass      = 6; //加密aes串
    int32       game_version    = 7; //游戏版本号
    string      ip              = 8; //客户端登陆时ip地址
    int32       select_zone     = 9; //合服使用(先根据IP获取是否存在，不存在则创建)
    string      sub_platform    = 10; //用户平台下的不同分发媒体
}
message SCLoginAck{ //project gate
    int32       error        = 1; //错误码 0表示无错误
    uint64      client_id    = 2;
    string unisdk_login_json = 3; //网易登录验证回复sdk信息
}
//断线重连
message CSReconnectReq {    //project game //RouteRule game
    string      open_id         = 1; //平台账号ID
    string      platform_token  = 2; //平台token验证登陆
    string      uid             = 3; //玩家唯一ID
    string      crypt_pass      = 4; //加密aes串f
    string      platform        = 5; //用户平台
}
message SCReconnectAck {
    int32       error                   = 1; //错误码，OK表示重连成功
    ReconnectUserData reconnect_data    = 2; //重连成功后返回的信息(暂时没有信息添加)
}

message SCHandShakeNtf{
    string crypt_pass                = 1; //返回给客户端(login时带回该字符串)
}

//客户端发起创建角色请求
message CSCreateRoleReq {   //project game  //RouteRule game
    string      open_id         = 1; //平台账号
    int32       job_id          = 2; //roleCfg配置表ID
    int32       sex             = 3; //性别
    int32       country         = 4; //国家
    int32       eye             = 5; //眼睛
    int32       hair            = 6; //头发
    int32       head            = 7; //头饰
    int32       hair_avatar     = 8; //头发模型
    string      active_code     = 9; //激活码
}

message SCCreateRoleAck {
    int32       error                 = 1; //错误码
    uint64      create_role_time      = 2; //创建时间
    uint64      uid                   = 3;
    int32       gender                = 4;
}
//创建流程中发送昵称
message CSNameReq { //project game  //RouteRule game
    string      name            = 1;
}
message SCNameAck {
    int32       error           = 1; //错误码
    string      name            = 2;
}

//玩家启动时需要的基础信息 (后续根据需求来请求数据，暂时做成都发)
message SCStartupInfoNtf {
    uint64          server_time         = 1; //服务器当前时间戳
    uint64          create_time         = 2; //创建角色时间
    ReconnectInfo   reconnect_info      = 3; //重连信息(暂时不使用，后续扩展时用)
    RoleBase        role_base           = 4; //玩家基础信息
    RoleBag         role_bag            = 5; //玩家背包信息
    RoleHero        role_hero           = 6; //伙伴信息
    RoleEquip       role_equip          = 7; //准备信息
    RoleChip        role_chip           = 8; //伙伴碎片
    RoleSkill       role_skill          = 9; //技能
    RoleCard        role_card           = 10; //卡片数据
    RoleFashion     role_fashion        = 11; //时装
    RoleBattle      role_battle         = 12; //战斗相关数据
    FightPowerData  role_fightpower     = 13; //战斗力数据
    RoleChat        role_chat           = 14; //聊天处理
    RoleTask        role_task           = 15; //任务相关
    RoleRed         role_red            = 16; //小红点
    RoleCompetition role_competition    = 17; //赛季玩法信息(主界面显示赛季信息)
    RoleMap         role_map            = 18; //rolemap
    RoleTower       role_tower          = 19; //爬塔
    RoleDraw        role_draw           = 20; //抽取系统
    RoleRune        role_rune           = 21; //卢恩商会
    RoleDaoChang100 role_daochang100    = 22; //百人道场
    RoleCross       role_cross          = 23; //跨服数据
    RoleSkillEquip  role_skill_equip    = 24; //神器
    RoleWish        role_wish_box       = 25; //许愿想数据

    bool func_disable                   = 100; //功能屏蔽
    uint64 service_start_time           = 101; //服务器开服时间
    RoleBT          role_bt             = 102; //bt
}
//客户端没收到多条协议，需要做数据判断，有数据就添加没数据不处理，例如pet_manual
//数据为空客户端不能直接拿空数据覆盖
message SCStartupInfoPetNtf {
    RolePet role_pet_info                       = 1;
}
message SCStartupInfoEquipNtf {
    RoleEquip role_equip_info                   = 1;
}
message SCStartupInfoCardNtf {
    RoleCard role_card_info                     = 1;
}
message SCStartupInfoEndNtf {
}

//获取服务器时间ms
message CSGetServerTimeReq {    //project game  //RouteRule game
}
message SCGetServerTimeAck {
    uint64          server_time         = 1; //服务器当前时间戳
}

//退出登录
message SCLogoutNtf {
    int32       error           = 1; //错误码
}
//服务器踢人
message SCKickOutNtf {
    int32       error           = 1; //错误码
    uint64      ban_end_time        = 2; //封号结束时间s
}

//消耗属性点
message CSAddAttrPointReq{  //project game    //RouteRule game
    repeated    KeyValueType   attr_list = 1; //属性点添加列表
    int32       hero_id                  = 2; //英雄ID
}

message SCAddAttrPointAck{
    int32       error           = 1; //错误码
    int32       hero_id         = 2; //英雄ID
}
//重置属性点
message CSResetAttrPointReq{    //project game    //RouteRule game
    int32       hero_id                  = 1; //英雄ID
}

message SCResetAttrPointAck{
    int32       error           = 1; //错误码
    int32       hero_id         = 2; //英雄ID
}

//增加素质点
message CSAddQualityPointReq{    //project game    //RouteRule game
    int32       hero_id                  = 1; //英雄ID
    int32       item_id                  = 2; //果实Id
}

//增加素质点返回
message SCAddQualityPointAck{
    int32       error           = 1; //错误码
    int32       hero_id          = 2; //英雄ID
    int32       item_id          = 3; //道具Id
}

//战斗力变化通知客户端
message SCFightPowerChagneNtf {
    FightPowerData      data         = 2;
}

//请求激活头像
message CSActiveHeadReq {        //project game    //RouteRule game
    int32       head_id              = 1;   //头像Id
}
message SCActiveHeadAck {
    int32       error                = 1;
    int32       head_id              = 2;   //请求激活的头像ID
}

//请求头像信息
message CSHeadInfoReq {        //project game    //RouteRule game

}
message SCHeadInfoAck {
    repeated    int32           head_list = 1; //激活的头像列表
    RoleHeadCond                head_Info = 2; //头像信息
}

//设置头像ID
message CSSetHeadIdReq {        //project game    //RouteRule game
    int32                    head_id = 1;
}
message SCSetHeadIdAck {
    int32       error                = 1;   //errorcode
    int32       head_id              = 2;   //请求设置的头像ID
}

//改名
message CSRenameReq { //project game  //RouteRule game  //confirm
    string      name            = 1;
}
message SCRenameAck {
    int32       error           = 1; //错误码
    string      name            = 2;
}

message CSChangeHeadFrameReq {  //project game    //RouteRule game
    int32       head_frame_id        = 1;   //请求设置的头像框ID
}
message SCChangeHeadFrameAck {
    int32       error                = 1;   //errorcode
    int32       head_frame_id        = 2;   //请求设置的头像框ID
}
message CSHeadFrameInfoReq { //project game    //RouteRule game

}
message SCHeadFrameInfoAck {
    int32       error                  = 1;   //errorcode
    repeated HeadFrameData  head_frame = 2;
}

message SCHeadFrameChangeNtf {
    repeated HeadFrameData    head_frame        = 1;   //到期的头像框
}

message CSUseHeadFrameItemReq { //project game    //RouteRule game
    uint64  item_id                 = 1; //背包中动态生成的item_id
    uint32  item_num                = 2; //使用个数
}

message SCUseHeadFrameItemAck {
    int32       error                    = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //头像框转换道具
}

/////////////////////////////////////////////////////////hero
//伙伴培养
message CSHeroLevelUpReq {  //project game    //RouteRule game
    int32       hero_id         = 1; //动态生成的id
}
message SCHeroLevelUpAck {
    int32       error           = 1; //错误码
    int32       hero_id         = 2;
    int32       hero_level      = 3;
}
//伙伴进阶
message CSHeroAdvanceReq {    //project game    //RouteRule game
    int32       hero_id         = 2; //动态生成的id
}
message SCHeroAdvanceAck {
    int32       error           = 1; //错误码
    int32       hero_id         = 2;
    int32       advance_level = 3;
}
//伙伴上阵处理
message CSHeroBattleReq { //project game    //RouteRule game
    int32       hero_id             = 1; //当前正在出战的伙伴
    bool        is_battle           = 2; //false下阵，true上阵
}
message SCHeroBattleAck {
    int32       error           = 1; //错误码
}
//角色等级提升通知
message SCBaseLevelUpNtf {
    int32       old_level           = 1;
    int32       new_level           = 2;
}
//角色职业等级提升通知
message SCJobLevelUpNtf{
    int32       old_level           = 1;
    int32       new_level           = 2;
}
//用户基础数据变更通知
message SCRoleBaseInfoNtf {
    uint64      coin                 = 1; //玩家金币
    uint32      rmb                  = 2; //钻石
    RoleData    role_data            = 3; //玩家附属属性
    repeated KeyValueType res_list   = 4; //玩家其他资源列表(不放背包的资源)
    int32     repress_skill_pvp_val  = 5; //技能竞技压制值
    int32       max_credit_recharge  = 6; // 充值钱包额度上限值
}
//伙伴信息变更通知
message SCRoleHeroInfoNtf {
    repeated HeroData   hero_data        = 1; //玩家伙伴信息
}

//英雄碎片
message CSHeroChipDecomposeReq {    //project game    //RouteRule game
    repeated int32 chip_type_list           = 1; //卡片类型，一键分解时使用
    repeated KeyValueType   chip_list       = 2; //用来分解的道具ID
}
message SCHeroChipDecomposeAck {
    int32       error                    = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //分解获得的资源数据
}

//伙伴突破(前面的突破是策划的进阶概念，这个里是突破)
message CSHeroStrengthReq {    //project game    //RouteRule game
    int32       hero_id         = 1; //动态生成的id
}
message SCHeroStrengthAck {
    int32       error           = 1; //错误码
    int32       hero_id         = 2;
    int32       strength_level	= 3;
}

//主角转职
message CSHeroChangeJobReq {    //project game    //RouteRule game
	int32       hero_id         = 1; //转职的伙伴ID
	int32       job_id         	= 2; //需要转的职业ID
}
message SCHeroChangeJobAck {
    int32       error           = 1; 	//错误码
    int32       hero_id         = 2;	//转职的伙伴ID
}

message SCHeroConditinDataNtf{
    repeated ChangeJob    condition   = 1; //可转职业条件
}

//请求伙伴战力
message CSHeroFighPowerReq {      //project game    //RouteRule game
    int32       hero_id         = 1; //伙伴ID
}
message SCHeroFighPowerAck {
    int32       error           = 1; //errorcode
    int32       hero_id         = 2; //伙伴ID
}

//洗点
message CSHeroResetSkillPointReq {      //project game    //RouteRule game
    int32               hero_id = 1; //洗点的主角或者伙伴
    int32               stage  = 2; //洗点的阶段
}
message SCHeroResetSkillPointAck {
    int32               error  = 1; //洗点结果
}

//激活
message CSHeroActiveReq {      //project game    //RouteRule game
    int32               hero_id = 1; //伙伴ID
}
message SCHeroActiveAck {
    int32               error   = 1; //激活结果
    int32               hero_id = 2; //伙伴ID
}

//职业更换
message CSHeroReplaceJobReq {   //project game    //RouteRule game
    int32 hero_id                       = 1; //唯一ID
    int32 job_id                        = 2; //替换的职业ID
}
message SCHeroReplaceJobAck {
    int32       error                   = 1; //errorcode
    int32 hero_id                       = 2; //唯一ID
    int32 job_id                        = 3; //替换的职业ID
}

/////////////////////////////////////////////////////////
//神器变更通知
message SCSkillEquipChangeNtf{
    repeated SkillEquipChangeData skill_equip_change_list   = 1; //神器变更数据
    bool                          ignore					= 2; //是否屏蔽显示新增神器
}

//神器佩戴
message CSSkillEquipUpReq{   //project game    //RouteRule game
    int32       hero_id            = 1; //英雄动态id
    int32       slot_index         = 2; //坑位部件类型 (slot_index值为-1表示一键装备 从0开始)
    uint32      skill_equip_id     = 3; //神器实例id
}
message SCSkillEquipUpAck{
    int32       error               = 1; //错误码
}

//神器槽位变更
message SCSkillEquipSlotDataNtf{
    SkillEquipSlotData			slot			  = 1; //坑位信息
    int32						        hero_id			= 2; //对应英雄
}

//卸下神器
message CSSkillEquipDownReq{ //project game    //RouteRule game
    int32       hero_id          = 1; //英雄动态id
    int32       slot_index       = 2; //坑位部件类型 (slot_index值为-1表示一键卸下 从0开始)
}
message SCSkillEquipDownAck{
    int32       error           = 1; //错误码
}

//神器升星
message CSSkillEquipLevelUpReq{  //project game    //RouteRule game
    int32       hero_id                 = 1; //英雄id
    uint32      skill_equip_id          = 2; //神器id
    repeated   uint32  select_cost      = 3; //消耗的材料
}
message SCSkillEquipLevelUpAck{
    int32       error           = 1; //错误码
}

//神器槽位升级
message CSSkillEquipSlotLevelUpReq{  //project game    //RouteRule game
    int32       hero_id         = 1; //英雄动态id
    int32       slot_index      = 2; //槽位索引 (从0开始)
}
message SCSkillEquipSlotLevelUpAck{
    int32       error           = 1; //错误码
}

//神器分解
message CSSkillEquipDecomposeReq{  //project game    //RouteRule game
    repeated   uint32   skill_equip_id       = 1; //神器id
}
message SCSkillEquipDecomposeAck{
    int32       error           = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //分解获得的资源数据
}

//神器重铸
message CSSkillEquipRemadeReq{  //project game    //RouteRule game
    uint32   skill_equip_id     = 1; //神器id
}
message SCSkillEquipRemadeAck{
    int32       error           = 1; //错误码
    uint32   old_id       		= 2; //重铸前的神器id
	uint32   new_id       		= 3; //重铸后的神器id
}

//神器重铸尺子
message CSSkillEquipPoolReq{  //project game    //RouteRule game
    
}
message SCSkillEquipPoolAck{
    int32       error                   = 1; //错误码
    int32       cur_id                  = 2; //当前重铸ID
    repeated int32   pool_id_list       = 3; //当前最新重铸池子
    repeated int32   next_pool          = 4; //下一批重铸池子
    uint64 next_begin                   = 5; //下一批开始时间
}

//神器转移
message CSSkillEquipShiftReq{  //project game    //RouteRule game
    uint32      src_id                  = 1; //神器id
    uint32      dst_id                  = 2; //神器id
}

message SCSkillEquipShiftAck{
    int32       error           	= 1; //错误码
}

/////////////////////////////////////////////////////////equip
//装备锻造(已经装备的不参加锻造)
message CSEquipForgeReq {    //project game    //RouteRule game
    int32       config_id           = 1; //config_id为0表示一键锻造
    int32       once                = 2; //合成一次还是多次
    int32       equip_type          = 3; //一键锻造的部件
    int32       sub_equip_type      = 4; //武器子类型，表示职业
}
message SCEquipForgeAck{
    int32       error           = 1; //错误码
    int32       type            = 2; //操作类型客户端使用
}
//部分装备变化信息
message SCEquipChangeNtf{
    repeated EquipData equip_list   = 1;
    bool        ignore              = 2; //是否屏蔽显示新增道具显示
}
//坑位装备(一键装备替换所有最高级装备)
message CSEquipUpReq{   //project game    //RouteRule game
    int32       hero_id            = 1; //英雄动态id
    int32       slot_index         = 2; //坑位部件类型 (slot_index值为0表示一键装备 从1开始到6表示6个位置)
    int32       equip_id           = 3; //装备configId
}
message SCEquipUpAck{
    int32       error           = 1; //错误码
}
message SCSlotDataNtf{
    SlotData        slot     = 1; //坑位信息
    int32       hero_id      = 2; //对应英雄
}
//一键卸下装备
message CSEquipDownReq{ //project game    //RouteRule game
    int32       hero_id          = 1; //英雄动态id
    int32       sub_index        = 2; //坑位部件类型 (slot_index值为0表示一键装备 从1开始到6表示6个位置)
}

//一键升级(升级位置上能升级的所有装备)
message CSEquipLevelUpAllReq{  //project game    //RouteRule game
    int32       hero_id          = 1; //英雄动态id
}
message SCEquipLevelUpAllAck{
    int32       error           = 1; //错误码
}

//装备对应槽位升级
message CSEquipSlotLevelUpReq{  //project game    //RouteRule game
    int32       hero_id         = 1; //英雄动态id
    int32       sub_slot_index  = 2; //6个位置中的索引([1,6])
}
message SCEquipSlotLevelUpAck{
    int32       error           = 1; //错误码
}

/////////////////////////////////////////////////////////card
//装备对应槽位镶嵌卡片
message CSCardMountReq{    //project game    //RouteRule game
    int32       hero_id         = 1; //4套坑位的索引值([1,4])
    int32       sub_slot_index  = 2; //6个位置中的索引([1,6])
    int32       card_slot_index = 3; //卡槽对应索引[1,4]
    int32       card_id         = 4; //configId
}
message SCCardMountAck{
    int32       error           = 1; //错误码
}
//装备对应槽位卸下卡片
message CSCardDownReq{  //project game    //RouteRule game
    int32       hero_id         = 1; //4套坑位的索引值([1,4])
    int32       sub_slot_index  = 2; //6个位置中的索引([1,6])
    int32       card_slot_index = 3; //卡槽索引[1,4] 0表示一键卸下
}
message SCCardDownAck{
    int32       error           = 1; //错误码
}
//卡片重置
message CSCardComposeReq{   //project game    //RouteRule game
    repeated    int32         card_list = 1; //
}
message SCCardComposeAck{
    int32       error           = 1; //错误码
    int32       new_card_id             = 2; //合成的新卡ID
}
//卡片分解
message CSCardDecomposeReq{ //project game    //RouteRule game
    repeated    KeyValueType       card_list = 1; //当数据不传入时表示一键分解
    int32       card_type                    = 2; //卡片类型，一键分解时使用
}
message SCCardDecomposeAck{
    int32       error                    = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //分解获得的资源数据
}
//卡牌数据变更通知
message SCCardChangeNtf{
    repeated CardData card_list = 1;
    bool ignore                 = 2;
}
//卡牌卡槽解锁通知
message SCCardSlotChangeNtf{
    repeated KeyValueType slot_list = 1;
}

//Bag背包相关
message SCItemChangeNtf{
    repeated ItemData item_list = 1;
    bool ignore                 = 2;
}
//使用道具(例如开宝箱等)
message CSUseItemReq {  //project game    //RouteRule game
    uint64  item_id                       = 1; //背包中动态生成的item_id
    uint32  item_num                      = 2; //使用个数
    repeated int32 item_idx_list          = 3; //获得该道具包中的其中一个道具(根据给定的配置表索引)
    bool force_item_id                    = 4; //强制使用当前item_id道具
}
message SCUseItemAck {
    int32       error           = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //分解获得的资源数据
}
//背包道具销毁
message CSDelItemReq {  //project game    //RouteRule game
    repeated uint64  item_id_list         = 1; //背包中动态生成的item_id
}
message SCDelItemAck {
    int32       error              = 1; //错误码
    repeated int32 del_cfg_id_list = 2;
}

//英雄碎片合成
message CSChipComposeReq{ //project game    //RouteRule game
    int32       config_id           = 1;
}
message SCChipComposeAck{
    int32       error           = 1; //错误码
}
message SCChipChangeNtf{
    repeated ChipData chip_list  = 1; //英雄碎片列表
}

message CSCardUpGradeReq {  //project game    //RouteRule game
    repeated KeyValueType       config_ids    = 1;
}
message SCCardUpGradeAck {
    int32                   error         = 1;
    repeated KeyValueType   config_ids    = 2;
}

message CSCardEquipAllReq {  //project game    //RouteRule game
    int32       hero_id                             = 1;    //英雄ID
    repeated    EquipSlotCards   eqiup_slot_data    = 2;    //卡槽数据
}
message SCCardEquipAllAck {
    int32       error        = 1;
    int32       hero_id      = 2;
}

message CSCardEquipDownReq { //project game    //RouteRule game
    int32       hero_id             = 1;
}
message SCCardEquipDownAck {
    int32       hero_id             = 1;
    int32       error               = 2;
}

message CSCardUpGradeAllReq { //project game    //RouteRule game
    int32       hero_id             = 1;
    repeated    KeyValueType  data  = 2;    //key:装备槽位，valueL:卡片槽位
}
message SCCardUpGradeAllAck {
    int32       hero_id             = 1;
    int32       error               = 2;
}

message CSCardCollectInfoReq {  //project game    //RouteRule game

}
message SCCardCollectInfoAck {
    int32    error                            = 1;
    repeated CardCollect       card_collect   = 2; //变更的卡片图册
}

message CSCardCollectRewardReq {  //project game    //RouteRule game
    int32       card_id             = 1;
    int32       level               = 2;
}
message SCCardCollectRewardAck {
    int32    error                         = 1;
    int32    card_id                       = 2;
    int32    level                         = 3;
    repeated KeyValueType   reward_list    = 4;
}
message SCCardCollectChangeNtf {
    repeated CardCollect       card_collect          = 1; //变更的卡片图册
}

message CSCardCollectionRankReq{    //project game|rank    //RouteRule game
    int32    card_id                       = 1;
}
message SCCardCollectionRankAck{    //project game
    int32    error                         = 1;
    int32    card_id                       = 2;
    int32    card_level                    = 3;
    CommonPlayerBriefInfo player_info      = 4;
    uint64 achievement_time                = 5;
}

//卡片互换
message CSCardLevelExchangeReq {    //project game    //RouteRule game
    int32 source_card_id                    = 1;
    int32 target_card_id                    = 2;
}
message SCCardLevelExchangeAck {
    int32 error                             = 1;
    int32 source_card_id                    = 2;
    int32 target_card_id                    = 3;
}
/////////////////////////////////////////////////////////skill
//技能槽位数据变更通知
message SCSkillSlotDataNtf{
    int32           hero_id               = 1;
    repeated RoleSkillSlot   slot_info    = 2; //技能槽位(客户端不存在当前槽位信息就添加，存在就更新)
}
//职业对应技能信息变更通知
message SCJobSkillDataNtf{
    int32    hero_id                              = 1;
    repeated JobSkillData    job_skill_list       = 2; //
}
//技能槽位(栏位)升级
message CSSkillSlotLevelUpReq{  //project game    //RouteRule game
    int32       hero_id         = 1;
    int32       idx             = 2; //对应的槽位索引
}
message SCSkillSlotLevelUpAck{
    int32       error           = 1; //错误码
}
//替换技能
message CSReplaceSkillReq{  //project game    //RouteRule game
    int32       hero_id         = 1;
    int32       idx             = 2; //替换槽位
    int32       skill_id        = 3; //替换技能(原先位置有就替换技能，没有就装备技能)
}
message SCReplaceSkillAck{
    int32       error           = 1; //错误码
}
//激活技能树中的技能
message CSActiveSkillReq{   //project game    //RouteRule game
    int32 hero_id                       = 1;
    int32 skill_id                      = 2; //技能ID
}
message SCActiveSkillAck{
    int32       error           = 1; //错误码
}
//交换栏位中的技能
message CSSwapSkillReq{ //project game    //RouteRule game
    int32   hero_id            = 1;
    int32   first              = 2; //替换槽位
    int32   second             = 3; //替换槽位
}
message SCSwapSkillAck{
    int32       error           = 1; //错误码
}
//设置技能列表
message CSSetSkillListReq{ //project game    //RouteRule game
    int32                   hero_id     = 1; //英雄id
    repeated    int32       skill_list  = 2; //技能列表
}
message SCSetSkillListAck{
    int32                      error      = 1; //错误码
    int32                      hero_id    = 2; //英雄id
}
//技能升级请求
message CSSkillLevelUpReq{ //project game    //RouteRule game
    int32           hero_id         = 1;   //英雄ID
    int32           skill_id        = 2;   //升级的技能ID
}
message SCSkillLevelUpAck{
    int32           error           = 1;   //错误码
    int32           hero_id         = 2;   //英雄ID
    int32           skill_id        = 3;   //升级的技能ID
}
message CSResetSkillLevelReq{   //project game    //RouteRule game
    int32           hero_id         = 1;   //英雄ID
    bool            is_advanced        = 2;   //是否高级技能
}
message SCResetSkillLevelAck{
    int32           error           = 1;   //错误码
    int32           hero_id         = 2;   //英雄ID
    int32           reset_count     = 3;   //重置次数
}
message SCSkillResetCountNtf {
    int32           reset_count     = 1;   //重置次数
}

//请求技能压制冲榜活动数据
message CSRushActivityReq {     //project game  //RouteRule game
    int32 rush_type                 = 1;
}

message SCRushActivityAck {
    int32       error                   = 1;    //错误码
    int32       fight_count             = 2;    //战斗次数
    int32       self_rank               = 3;    //自己排名
    int32       self_level              = 4;    //自己
    uint64      end_time                = 5;    //结束时间
    bool        challeng_reward         = 6;    //挑战奖励是否领取
    bool        rank_reward             = 7;    //排名奖励是否领取
    repeated RushRankTop3   top_data    = 8;    //这里只发送前10名
    int32       rush_type               = 9;    //冲榜类型
}

//请求技能压制冲榜活动奖励
message CSRushActivityRewardReq {      //project game  //RouteRule game
    int32       reward_type             = 1;    //1:挑战奖励，2：排名奖励
    int32       rush_type               = 2;    //冲榜类型
}
message SCRushActivityRewardAck {
    int32       error                   = 1;    //错误码
    int32       reward_type             = 2;    //1:挑战奖励，2：层数奖励
    repeated    KeyValueType  item_list = 3;    //奖励列表
    int32       rush_type               = 4;    //冲榜类型
}

message CSRushSkillActivityRankReq {  //project game|rank  //RouteRule game
    int32 page                          = 1;
    int32       rush_type               = 2;    //冲榜类型
}
message SCRushSkillActivityRankAck {  //project game
    int32       error                   = 1;    //错误码
    int32       page                    = 2;
    repeated RushRankTop3    top_data   = 3;    
}

/////////////////////////////////////////////////////////fashion
//时装数据变更通知
message SCFashionDataNtf{
    repeated   int32     fashion_up_list    = 4; //穿戴的时装(不为空表示发生数据变更)
    repeated   int32     fashion_list       = 5; //时装列表
}
//穿戴时装(替换)
message CSFashionUpReq {    //project game //RouteRule game
    repeated int32   fashion_cfg_id      = 1; //时装ID
}
message SCFashionUpAck {
    int32       error           = 1; //错误码
}
//卸下时装
message CSFashionDownReq{   //project game //RouteRule game
    repeated int32   fashion_cfg_id      = 1; //时装ID
}
message SCFashionDownAck {
    int32       error           = 1; //错误码
}
//时装合成
message CSFashionComposeReq{    //project game //RouteRule game
    int32       paper_cfg_id    = 1; //图纸ID
}
message SCFashionComposeAck{
    int32       error           = 1; //错误码
}
//时装图纸分解
message CSFashionPaperDecomposeReq {    //project game //RouteRule game
    int32       paper_cfg_id    = 1; //图纸ID
}
message SCFashionPaperDecomposeAck {
    int32       error           = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //分解获得的资源数据
}

// 时装升级
message CSFashionUpLvlReq {     //project game //RouteRule game
    int32   fashion_cfg_id      = 1; //时装ID
}

// 时装升级 返回
message SCFashionUpLvlAck {
    int32       error           = 1; //错误码
}

// 时装变更  (時裝升級 時裝洗練)
message SCFashionNtf {
    repeated RoleFashionData   fashion_data      = 1; //时装ID
    repeated KeyValueType   lvs      = 2; //套装数据  key套装id，value 等级
}

// 时装洗练
message CSFashionResetAttrReq {     //project game //RouteRule game
    bool    enter               =1;
    int32   fashion_cfg_id      = 2; //时装ID

}
// 时装洗练 返回
message SCFashionResetAttrAck {
    int32       error           = 1; //错误码
}
/////////////////////////////////////////////////////////AOI相关
//获取详细信息(用来显示详细面板使用)，例如，隶属公会，个性签名，战斗力等详细信息
message CSGetOtherPlayerDetailInfoReq{  //project game|social      //RouteRule game
    uint64      uid             = 1; //请求查看的Uid
    uint64      t_uid           = 2; //被查看Uid
}
message SCGetOtherPlayerDetailInfoAck{  //project game
    uint64         uid          = 1;   //ID
    int32          error        = 2;   //错误码
    ViewRoleInfo   target_info  = 3;   //目标信息
}
//获取玩家简介信息，显示头像名称相关，不包括详细信息(本服玩家)
message CSGetOtherPlayerBriefInfoReq {  //project game  //RouteRule game
    repeated uint64         player_list  = 1;//角色列表
    int32 type                           = 2;
}
message SCGetOtherPlayerBriefInfoAck {
    repeated CommonPlayerBriefInfo brief_info                = 1;
    int32 type                                               = 2;
}
//挑战召唤物
message CSPlayerChallengeSummonReq {    //project game|battleboss  //RouteRule game
     uint64 uid                         = 1; //挑战玩家uid
     uint64 challenge_boss_uid          = 2; //挑战的bossUid
     int32 boss_summon_idx              = 3;
     FightRoleInfo fight_info           = 4; //召唤boss玩家信息(服务器使用)
}
message SCPlayerChallengeSummonAck {    //project game
    int32       error                   = 1; //错误码
    WorldBossContentInfo boss_info      = 2; //世界boss信息
}
message SCPlayerChallengeSummonNtf {
    uint64  self_uid                    = 1;
    repeated FightRoleInfo fight_list   = 2; //其他玩家列表
    uint64 boss_uid                     = 3;
    int32 self_change_play_id           = 4;
    int32 summon_boss_type              = 5;
}
//血量上报
message CSPlayerChallengeHpReq {    //project game|battleboss  //RouteRule game
    int32   damage_hp           = 1; //玩家对boss的伤害
    uint64  action_uid          = 2; //服务器使用客户端不使用
}
//boss血量变更通知
message SCPlayerChallengeHpNtf {
    int32 cur_boss_hp         = 1; //当前boss血量
}
//离开boss场景
message CSPlayerLeaveChallengeReq{  //project game|battleboss  //RouteRule game
}
//离开boss场景通知
message SCPlayerLeaveChallengeNtf{  //project game
    uint64 uid                         = 1; //离开的挑战玩家uid
}
message SCPlayerChallengeResultNtf {
    int32 result                    = 1; //1表示升级，2表示超时战场结束
}
//获取WorldBoss列表
message CSPlayerWorldBossListReq {   //project game|battleboss  //RouteRule game
}
message SCPlayerWorldBossListAck {  //project game
    repeated WorldBossContentInfo world_boss_list           = 1; //世界boss列表
}

message SCPlayerWorldBossRandNtf { //project game
    int32       error                                   = 1; //错误码(有可能会出现背包满的提示错误，这个时候也是需要显示奖励的)
    WorldBossRandPointInfo point_info                   = 2; //世界boss rand点数据
}
message SCRoleMapChangeNtf {
    int32       world_boss_count             = 1; //世界boss挑战次数
    repeated int32 world_boss_challenge_list = 2; //当天挑战过的世界bossid列表(id*10 + summonidx)
}

/////////////////////////////////////////////////////////chat相关
message CSChatMessageReq{   //project game|social|guild    //RouteRule game
    int32       type                         = 1;//消息类型1私人聊天，2世界频道聊天
    ChatMessageInfo      message             = 2;//消息内容
    uint64      target_id                    = 3;//私人聊天，好友聊天时发送的目标玩家
    ChatPlayerBriefInfo      from_id         = 4;//私人聊天，好友聊天时发送的来源玩家
}
message SCChatMessageAck{
    int32       error                   = 1; //错误码
    uint64      target_id               = 2; //目标玩家(离线玩家ID)
    ChatMessageInfo      message        = 3;//消息内容
    int32 type                          = 4;
}

message SCChatMessageNtf{
    repeated MessageContentInfo msg_list    = 1;
    repeated SystemMessage      s_msg_list  = 2;
    //int32       type                         = 1;//消息类型1私人聊天，2世界频道聊天
    //ChatMessageInfo      message             = 2;//消息内容
    //ChatPlayerBriefInfo      from_id         = 3;//消息来源玩家
    //uint64  target_id                        = 4;//targetId显示该私聊信息
}
//私聊玩家在线状态刷新
message CSChatPlayerStateReq {  //project game|social    //RouteRule game
    repeated uint64 target_id_list           = 1; //私聊玩家列表
}
message SCChatPlayerStateAck {  //project game
    repeated PlayerStateInfo state_list      = 1; //在线状态列表
}
//获取某个玩家的离线信息
message CSChatOfflineMsgReq {   //project game|db    //RouteRule game
    uint64      target_id               = 1; //目标玩家(离线玩家ID)
    uint64      self_id                 = 2;
}
message SCChatOfflineMsgAck {   //project game
    int32       error                   = 1; //错误码
    ChatPlayerBriefInfo target_player   = 2; //私聊目标
    repeated ChatMessageInfo msg_list   = 3; //私聊消息列表
}
//玩家上线时获取离线玩家列表
message SCChatOfflinePlayerNtf {
    RoleChat offline_player_list            = 1;
}

message SCSystemMessageNtf{ //project game
    repeated SystemMessage sys_msg           = 1;//公告消息
}

/////////////////////////////////////////////////////////battle处理
//收益相关处理(online/offline)
message CSPlayerIncomeReq{  //project game  //RouteRule game    //confirm
}
message SCPlayerIncomeAck{
    int32       error           = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //分解获得的资源数据
}
//挑战boss奖励
message CSPlayerBossRewardReq{  //project game  //RouteRule game    //confirm
    uint32      challenge_time           = 1; //该boss挑战时间
    uint32      map_id                   = 2;
    uint32      map_level                = 3;
    uint64      record_time_stamp        = 4;
}
message SCPlayerBossRewardAck{
    int32       error                    = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //奖励
    uint64      server_time_stamp        = 3; //服务器时间戳
}
//通知客户端需要保存战斗过程记录
message SCPlayerBattleRecordDetailSaveNtf {
    uint64 battle_record_uid             = 1; //战斗唯一ID
    uint64 record_time_stamp             = 2;
}
//保存战报详细信息
message CSPlayerBattleRecordDetailSaveReq {   //project battlerecord  //RouteRule battlerecord
    uint64 battle_record_uid             = 1; //战斗唯一ID 回传服务器下发的唯一ID
    string battle_record                 = 2;
    string open_id                       = 3;
}
message SCPlayerBattleRecordDetailSaveAck {
    int32 error                          = 1; //错误码
}
//获取战报详细信息
message CSPlayerBattleRecordDetailReq { //project battlerecord  //RouteRule battlerecord
    uint64 battle_record_uid             = 1; //战斗唯一ID 回传服务器下发的唯一ID
    string open_id                       = 2;
}
message SCPlayerBattleRecordDetailAck {
    int32  error                         = 1; //错误码
    uint64 battle_record_uid             = 2; //战斗唯一ID 回传服务器下发的唯一ID
    string battle_record                 = 3;
}
//获取战报信息
message CSPlayerBattleRecordReq {   //project game|rank //RouteRule game
    int32 record_type                       = 1;
    repeated uint32 param_list              = 2;
}
message SCPlayerBattleRecordAck {   //project game
    int32 error                             = 1;
    repeated BattleRecordInfo record_list   = 2;
}

message SCPlayerBattleDataChangeNtf{
    uint64      last_income_time         = 1; //上一次领取收益时间，0表示未初始化
    uint32      map_level                = 2; //当前场景ID，默认为1
    uint32      map_id                   = 3; //当前地图ID，默认为1
    uint64      max_income_time          = 4; //最大收益累计时间
    QuickBattleData quick_battle		 = 5; //快速战斗
    uint32      reward_map_count         = 6; //未领取奖励次数

}
// 战斗加速时间通知
message SCPlayerBattleAcctTimeNtf {
    // 战斗加速时间(客户端显示根据last_record_battle_acce_time+battle_acce_duration为最大能使用的结束时间戳)
    uint64 last_record_battle_acce_time  = 1; // 上次记录时的时间
    uint64 battle_acce_duration          = 2; // 当前剩余的时间
}
//获取小地图排名
message CSGetMapRankReq {   //project game  //RouteRule game
}

message SCGetMapRankAck {
    int32       error                = 1; //错误码
    uint32      self_rank            = 2; //自身排名
    uint32      total_rank           = 3; //当前参加排名的人数
    repeated RankPlayerInfo top_player_list  = 4; //排名前3玩家
}

//获取本局战斗状态(胜利/失败)
message CSBattleResultReq {
    ActorPosition   actor_pos        = 1; //单位所在位置
}
message SCBattleResultAck {
    int32       error                = 1; //错误码，发送的战斗数据有误
    bool        win_lose             = 2; //true胜利，false失败
}

message CSQuickBattleIncomeReq {	//project game  //RouteRule game

}

message SCQuickBattleIncomeAck {
	int32       error           		= 1; //错误码
    repeated    KeyValueType  item_list	= 2; //快速挂机获得的资源列表
}

//boss战斗开始
message CSBattleBossFightReq{	//project game    //RouteRule game
}
message SCBattleBossFightAck{
    int32 error                         = 1;
    int32 left_cd_time                  = 2; //剩余刷新时间s
    repeated KeyValueType factor_list   = 3; //衰减系数
}

//请求地图冲榜活动数据
message CSMapActivityReq {     //project game  //RouteRule game
    
}

message SCMapActivityAck {
    int32       error                   = 1;    //错误码
    int32       map_score               = 2;    //推图积分
    int32       bag_score               = 3;    //礼包积分
    int32       self_rank               = 4;    //自己排名
    int32       self_level              = 5;    //自己推图关卡
    uint64      end_time                = 6;    //结束时间
    bool        challeng_reward         = 7;    //挑战奖励是否领取
    bool        rank_reward             = 8;    //排名奖励是否领取
    repeated RushRankTop3   top_data    = 9;    //前3名
    uint32      rush_level              = 10;   //活动推图关卡
}

/////////////////////////////////////////////////////////恶魔协会
//恶魔刷新(会根据当前的时间做刷新消耗，客户端需要判断是否进行刷新，进行确认)
message CSEvilRefreshReq {  //project game    //RouteRule game
   bool b_force                         = 1; //点击刷新方式刷新evil
}
message SCEvilRefreshAck {
    int32       error           		= 1; //错误码
    repeated int32 pos_idx_list            = 2;
}
message SCEvilChangeNtf {
    BattleEvilData evil_info            = 1;
    repeated KeyValueType add_item_list = 2; //恶魔提升获得奖励
}
//恶魔挑战(该位置上有boss则挑战，如果已经死亡的boss表示花费道具消除CD)
message CSEvilChallengeReq {    //project game    //RouteRule game
    int32 pos_idx                        = 1; //位置
}
message SCEvilChallengeAck {
    int32  error           		        = 1; //错误码
    int32  pos_idx                      = 2; //返回客户端发送位置
    int32  add_count                    = 3;
}

/////////////////////////////////////////////////////////task相关
message CSGetTaskRewardReq {    //project game  //RouteRule game
    uint32      task_id             = 1; //领取奖励的任务ID
}
message SCGetTaskRewardAck {
    int32       error                    = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //任务奖励
}
message SCTaskChangeNtf {
    repeated TaskData task_change_list     = 1; //当前改变状态的任务
    KeyValueType daily_task_score          = 2; //活跃度/活跃度对应的奖励，按位处理(完成任务累加的积分)
    KeyValueType week_task_score           = 3;
    uint64 latest5_hour_time               = 4;
    uint64 latest_week5_hour_time          = 5;
}
message CSGetTaskScoreRewardReq {   //project game  //RouteRule game
    int32 reward_type                      = 1; //1daily 2week
    int32 reward_idx                       = 2; //奖励索引
}
message SCGetTaskScoreRewardAck {
    int32       error                    = 1; //错误码
    repeated    KeyValueType  item_list  = 2; //任务奖励
}

/////////////////////////////////////////////////////////道场
message SCArenaNtf {
    int32   challenge_count                  = 1; //剩余挑战次数
    int32   reward_count                     = 2; //剩余积分获得次数
    int32   buy_count                        = 3; //剩余购买次数
    int32   win_count                        = 4; //胜利次数
    int32   total_count                      = 5; //总挑战次数
    int32   score                            = 6; //积分
    repeated int32 self_hero_list            = 7;
    int32   season_id                        = 8; //当前赛季
    uint64  season_end_time                  = 9; //当前赛季结束时间
    uint64  next_season_start_time           = 10; //下个赛季开启时间
    int32   minTopScore                      = 11; //入榜最小积分
}
message SCArenaChangeNtf {
    int32   challenge_count                  = 1; //剩余挑战次数
    int32   reward_count                     = 2; //剩余积分获得次数
    int32   buy_count                        = 3; //剩余购买次数
    int32   win_count                        = 4; //胜利次数
    int32   total_count                      = 5; //总挑战次数
    int32   score                            = 6; //积分
    int32   season_id                        = 7; //当前赛季
    int32   rank_idx                         = 8; //当前排名
    int32   win_streak_count                 = 9; //连胜
    int32   fail_streak_count                = 10; //连败
    int32   minTopScore                      = 11; //入榜最小积分
}
//获取道场数据
message CSArenaReq {    //project game  //RouteRule game
}
//挑战(获得对手)
message CSArenaMatchReq{ //project game  //RouteRule game
    repeated int32 hero_list            = 1;
}
message SCArenaMatchAck {
    int32       error                               = 1; //错误码
    FightRoleInfo fight_info                        = 2; //对方玩家信息
}
//挑战结果(失败/成功)
message CSArenaResultReq { //project game  //RouteRule game //confirm
    int32       fight_result                        = 1; //0失败，1成功
}
message SCArenaResultAck {
    int32       error                               = 1; //错误码
    repeated    KeyValueType   reward_list          = 2; //奖励列表
    int32       old_score                           = 3;
    int32       cur_score                           = 4;
}
//购买挑战次数
message CSArenaBuyCountReq{ //project game  //RouteRule game
    int32 buy_count                 = 1;
}
message SCArenaBuyCountAck{
    int32       error                               = 1; //错误码
}
//获取赛季排行榜
message CSArenaRankListReq { //project game  //RouteRule game
    int32  rank_type               = 1; //1上赛季，0本赛季
    int32  start_idx               = 2; //1[1-10] 2[11-20] 3[21-30] ...
}
message SCArenaRankListAck {
    int32 error                                  = 1; //错误码
    repeated ArenaRankInfo rank_list             = 2;
    int32 self_rank                              = 3;
    int32 rank_type                              = 4;//1上赛季，0本赛季
    int32 start_idx                              = 5;
    int32 self_rank_score                        = 6; //赛季对应自身排名积分
}

//请求英灵殿冲榜活动数据
message CSArenaActivityReq {     //project game  //RouteRule game
}

message SCArenaActivityAck {
    int32       error                   = 1;    //错误码
    int32       fight_count             = 2;    //战斗次数
    int32       self_rank               = 3;    //自己排名
    int32       self_level              = 4;    //自己层数
    uint64      end_time                = 5;    //结束时间
    bool        challeng_reward         = 6;    //挑战奖励是否领取
    bool        rank_reward             = 7;    //排名奖励是否领取
    repeated RushRankTop3   top_data    = 8;    //前3名
}

/////////////////////////////////////////////////////////mail
//获取邮件数据
message CSMailListReq { //project game  //RouteRule game
}
message SCMailListAck {
    int32   total_mail_count               = 1; //当前邮件总数量
    repeated MailContent mail_list         = 2;
}
//邮件读取
message CSMailReadReq { //project game  //RouteRule game
    repeated int32 mail_id_list                    = 1;
}
message SCMailReadAck{
    int32 error                                  = 1; //错误码
}
//获取邮件附件
message CSMailRewardReq {   //project game  //RouteRule game
    repeated int32 mail_id_list                    = 1;
}
message SCMailRewardAck {
    int32 error                            = 1; //错误码
    repeated KeyValueType reward_list      = 2; //附件资源
}
//删除已读邮件
message CSMailDelReadReq {  //project game  //RouteRule game
}
message SCMailDelReadAck {
    int32 error                                  = 1; //错误码
}
//邮件信息变更通知
message SCMailChangeNtf {
    repeated KeyValueType mail_state_list       = 1; //变更状态邮件列表
    repeated int32 del_mail_list                = 2; //被删除邮件列表
    repeated MailContent add_mail_list          = 3; //新增加邮件
    int32 total_mail_count                      = 4; //当前邮件总数量
}

/////////////////////////////////////////////////////////competition赛季玩法
//赛季玩法信息获取(根据赛季不同类型获取对应信息)
message CSCompetitionReq {  //project game  //RouteRule game
    int32 competition_id                         = 1; //对应赛季ID
}
message SCCompetitionNtf {
    CompetitionInfo competition_data             = 1; //对应赛季信息
    uint64 next_competition_time                 = 2; //下个赛季开启时间
    IdolSeasonData data                          = 3; //偶像季数据
}
message SCCompetitionAck {
    int32 error                                  = 1; //错误码
    int32 competition_id                         = 2; //对应赛季ID
}
//第二赛季上交道具获取积分
message CSCompetitionScoreReq { //project game  //RouteRule game
    repeated KeyValueType item_list             = 1; //key是配置id，不是动态生成的id
}
message SCCompetitionScoreAck {
    int32 error                                 = 1; //错误码
    int32 com_score                             = 2; //当前玩家积分
    int32 next_com_score                        = 4; //下一档积分差距
    int32 self_rank                             = 5; //当前排名
    int32 total_rank                            = 6; //总人数
    int32 section_id                            = 7; //当前预计获得的宝箱奖励
    int32 last_com_score                        = 8; //低一档最大积分(玩家积分)
}

/////////////////////////////////////////////////////////Shop操作   //紧急需求，迁移版署版本，商店功能后续废弃重做
message CSShopBuyItemReq {    //project game   //RouteRule game
    int32      goods_id          = 1;
    int32      goods_num         = 2;
    int32      goods_type        = 3;
}

message SCShopBuyItemAck {
    int32      error                = 1;
    int32      goods_id             = 2;
    int32      goods_type           = 3;
    int32      cur_num              = 4;
    uint64     cur_buy_time         = 5;
    repeated KeyValueType item_list = 6;
}

message CSShopInfoReq {     //project game   //RouteRule game
    int32      goods_type        = 1;
}

message SCShopInfoAck {
    int32       error               = 1;
    ShopData    shop_data           = 2; //商店信息
}

message CSShopRefreshReq {      //project game   //RouteRule game
    int32      goods_type        = 1;
}

message SCShopRefreshAck {
    int32      error                = 1;
    ShopData   shop_data            = 2; //商店信息
}

//红包兑换请求
message CSRedBagExchangeReq {      //project game   //RouteRule game
}

message SCRedBagExchangeAck {
    int32      error                = 1;
    repeated   KeyValueType reward  = 2;
}
/////////////////////////////////////////////////////////social好友
message CSFriendReq {   //project game   //RouteRule game
    int32 type      = 1; //1我关注 2我的粉丝 3屏蔽列表
}
message SCFriendAck {
    int32 type                   = 1; //操作类型
    int32 total_count            = 2; //总数量
    int32 total_limit            = 3; //数量上限
    repeated uint64 uid_list     = 4; //玩家ID列表
}

//添加关注(添加好友，这边添加好友是单向的)
message CSFriendAddReq {    //project game   //RouteRule game
    uint64 add_uid                  = 1; //关注玩家uid
}
//成功关注玩家后，会有添加关注玩家的简介信息
message SCFriendAddAck {
    int32      error                      = 1;
    CommonPlayerBriefInfo brief_info      = 2; //玩家简介信息
}
//其他玩家关注自己时，添加到自己的粉丝列表中
message SCFriendAddNtf {
    CommonPlayerBriefInfo brief_info      = 1; //玩家简介信息
}

//取消关注
message CSFriendDelReq {    //project game   //RouteRule game
    uint64 del_uid                  = 1; //取消关注玩家uid
}
message SCFriendDelAck {
    int32  error                    = 1;
    uint64 del_uid                  = 2;
}
//其他玩家取消关注该玩家时，从自己的粉丝列表中移除
message SCFriendDelNtf {
    uint64 del_uid                  = 1;
}

//添加/删除屏蔽名单(添加和删除同一条协议，不在黑名单中加入黑名单，在黑名单中移除黑名单)
message CSFriendBlackReq {  //project game   //RouteRule game
    uint64 black_uid                = 1; //屏蔽玩家uid
}
message SCFriendBlackAck {
    int32  error                      = 1;
    CommonPlayerBriefInfo brief_info        = 2; //玩家简介信息
}

//获取推荐好友列表
message CSFriendRecommendReq {  //project game   //RouteRule game
}
message SCFriendRecommendAck {
    int32  error                                    = 1;
    repeated CommonPlayerBriefInfo brief_info_list  = 2; //推荐好友列表
}
message SCFriendRecommendNtf {
    repeated CommonPlayerBriefInfo brief_info_list  = 2; //推荐好友列表
}

//搜索玩家
message CSFriendSearchReq { //project game   //RouteRule game
    string target_name          = 1; //搜索玩家昵称
}
message SCFriendSearchAck {
    int32  error                                     = 1;
    repeated CommonPlayerBriefInfo brief_info_list   = 2;
}


/////////////////////////////////////////////////////////common
//小红点消息通知
message SCRoleRedNtf {
    RoleRed     red                 = 1;
}
//设置新手引导
message CSRoleGuideNtf {   //project game  //RouteRule game
    int32 guide_id                  = 2;//新手引导步骤ID
}
//剧情上线通知
message SCRoleStoryNtf {
    repeated int32   Story             = 1;  //播放过的剧情
    KeyValueType   map_cart            = 2;  //地图卡通
}
//剧情
message CSRoleStoryReq {   //project game  //RouteRule game
    KeyValueType   story_id         = 1;  //播放的剧情
}
message SCRoleStoryAck {
    int32   error             = 1;  //错误码
    KeyValueType  story_id    = 2;  //播放的剧情
}

//大地图动画
message CSNewMapCartoonReq{     //project game  //RouteRule game //confirm
    KeyValueType   map_cart            = 1;  //地图卡通 key：动画ID， value:状态
}
message SCNewMapCartoonAck{
    int32          error        = 1;  //错误码
    KeyValueType   map_cart     = 2;  //地图卡通 key：动画ID， value:状态
}

//强制引导
message CSCompulsoryGuidanceReq {   //project game  //RouteRule game
    int32   story_id          = 1;  //引导步骤ID
    int32   status            = 2;  //引导状态
}
message SCCompulsoryGuidanceAck {
    int32   error             = 1;  //错误码
    int32   story_id          = 2;  //引导步骤ID
    int32   status            = 3;  //引导状态
}

/////////////////////////////////////////////////////////活动
//签到信息请求
message CSSignUpInfoReq {   //project game  //RouteRule game

}

message SCSignUpInfoAck {
    int32       error               = 1; //错误码
    SignUp      sign_info           = 2; //签到活动
    int32       cur_sign_day        = 3; //当前可签到天
    int64       next_sign_time      = 4; //下次签到时间
}

//请求签到
message CSSignUpReq {   //project game  //RouteRule game

}

message SCSignUpAck {
    int32    error                    = 1; //错误码
    repeated KeyValueType day_list    = 2; //日奖励
    repeated KeyValueType accu_list   = 3; //累计奖励
    repeated KeyValueType double_list = 4; //双倍奖励
    int64    next_sign_time           = 5; //下次签到时间
    SignUp   sign_info                = 6; //签到活动
    int32    cur_sign_day             = 7; //当前可签到天
}

/////////////////////////////////////////////////////////爬塔功能
message CSClimbingTowerInfoReq { //project game  //RouteRule game

}

message SCClimbingTowerInfoAck {
    int32    now_tower_level           = 1; //当前可通关层数
    int64    pass_time                 = 2; //当前爬塔通过时间戳
    repeated FriendTowerInfo  infos    = 3; //好友/工会通关信息，自己可通关 + 2
    uint64   tower_level_day_reward_time = 4;
}

message CSFriendPassTowerInfoReq { //project game  //RouteRule game
    int32   begin_index          = 1;  //开始层数
    int32   end_index            = 2;  //结束层数
}

message SCFriendPassTowerInfoAck {
    repeated FriendTowerInfo  infos    = 1; //好友/工会通关信息，自己可通关 + 2
}

message MinTowerInfo{
    int32 tower_level                            = 1; //塔层数
    int32 fight_power                            = 2; //通过战力
    CommonPlayerBriefInfo brief                  = 3; //玩家昵称
    uint64 record_time                           = 4;
    uint32 battle_time                           = 5;
}

message CSTowerLevelMinFightPowerReq {  //project game  //RouteRule game
    int32 tower_level                           = 1;
} 

message SCTowerLevelMinFightPowerAck {
    MinTowerInfo   min_tower_info               = 1;
} 

message SCTowerLevelMinFightPowerNtf{
    repeated MinTowerInfo   min_tower_info = 1; //我的通关 + 3 层的最小通关战力
}

message CSClimbingTowerBeginReq {   //project game  //RouteRule game
    int32       tower_level         = 1; //塔层数
}

message SCClimbingTowerBeginAck {
    int32       error               = 1; //错误码
    int32       tower_level         = 2; //塔层数
    repeated KeyValueType factor_list           = 3; //衰减系数
}

message CSClimbingTowerEndReq { //project game  //RouteRule game    //confirm
    int32       tower_level         = 1; //塔层数
    int32       loading_time        = 2; //战斗loading时间
    uint64 record_time_stamp        = 3;
}

message SCClimbingTowerEndAck {
    int32       error                   = 1; //错误码
    int32       tower_level             = 2; //塔层数 成功 则tower_level+1
    FriendTowerInfo pass_info           = 3; //则tower_level + 3层通过的好友/工会成员等
    int64       pass_time               = 4; //通过时间
    repeated KeyValueType  reward_list  = 5; //爬塔奖励
    repeated KeyValueType  ex_reward_list  = 6; //爬塔额外奖励
}

message CSClimbingTowerRankReq {    //project game  //RouteRule game

}
message SCClimbingTowerRankAck {
    int32 error                                  = 1;  //错误码
    repeated KeyValueType64      rank_list       = 2;  //爬塔列表 Key:uid ,Value:rank
    int32 self_rank                              = 3;  //自己的rank
}

//上线爬塔冲榜数据请求
message CSOnlineRushInfoReq {     //project game  //RouteRule game
    
}
message SCOnlineRushInfoAck {
    repeated RushActivityData rush_data     = 1;    //冲榜数据
}

//请求爬塔冲榜活动数据
message CSTowerActivityReq {     //project game  //RouteRule game
    
}
message SCTowerActivityAck {
    int32       error                   = 1;    //错误码
    int32       fight_count             = 2;    //战斗次数
    int32       self_rank               = 3;    //自己排名
    int32       self_level              = 4;    //自己层数
    uint64      end_time                = 5;    //结束时间
    bool        challeng_reward         = 6;    //挑战奖励是否领取
    bool        rank_reward             = 7;    //排名奖励是否领取
    repeated RushRankTop3   top_data    = 8;    //前3名
}

/////////////////////////////////////////////////////////公会操作相关
//创建公会请求
message CSBuildGuildReq{    //project game|guild  //RouteRule game
    string      guild_name            = 1;  //公会名字
    int32       guild_badge           = 2;  //公会徽章
    uint64      uid                   = 3;  //创建人ID//服务器填写
}
//创建公会返回
message SCBuildGuildAck{    //project game
    int32       error               = 1;  //错误码
    GuildBrief  guild_brief         = 2;  //公会ID
}
//解散公会请求
message CSDisbandGuildReq{  //project game|guild  //RouteRule game
    uint64      uid                   = 1;  //创建人ID//服务器填写
    uint64      guild_id              = 2;  //公会ID//服务器填写
}
//解散公会返回
message SCDisbandGuildAck{  //project game
    int32       error               = 1;  //错误码
}
//申请加入公会请求
message CSApplyGuildReq{    //project game|guild  //RouteRule game
    uint64      guild_id            = 1;    //公会ID
    uint64      uid                 = 2;    //UID
    int32       level               = 3;    //玩家等级//服务器填写
    int32       op_type             = 4;    //操作类型：1加入公会，2取消加入公会
}
//申请加入公会返回给请求人
message SCApplyGuildAck{    //project game
    int32       error               = 1;  //错误码
    uint64      guild_id            = 2;  //公会ID
    int32       op_type             = 3;    //操作类型：1加入公会，2取消加入公会
}
//退出公会请求
message CSQuitGuildReq{ //project game|guild  //RouteRule game
    uint64      guild_id            = 1;    //公会ID//服务器填写
    uint64      uid                 = 2;    //UID//服务器填写
}
//退出公会返回
message SCQuitGuildAck{ //project game
    int32       error               = 1;  //错误码
}
//请求踢除公会成员请求
message CSKickGuildMemberReq{   //project game|guild  //RouteRule game
    uint64      uid                 = 1;    //成员ID
    uint64      guild_id            = 2;    //公会ID//服务器填写
    uint64      pre_uid             = 3;    //会长ID
}
//请求踢除公会成员返回
message SCKickGuildMemberAck{   //project game
    int32       error               = 1;  //错误码
    uint64      uid                 = 2;  //成员ID
}
message SCKickGuildMemberNtf {  //project game|social
    uint64      guild_id            = 1;  //成员ID
    uint64      uid                 = 2;  //UID
}
//提降玩家官职请求
message CSChangeMemberTitleReq{ //project game|guild  //RouteRule game
    uint64      uid                 = 1;  //成员ID
    int32       title               = 2;  //成员头衔
    uint64      pre_uid             = 3;  //成员ID//服务器填写
    uint64      guild_id            = 4;  //公会ID//服务器填写
}
//提降玩家官职返回
message SCChangeMemberTitleAck{ //project game
    int32       error               = 1;  //错误码
    uint64      uid                 = 2;  //成员ID
    int32       title               = 3;  //成员头衔
}
message SCChangeMemberTitleNtf{ //project game|social
    uint64      guild_id                    = 1;  //公会ID
    repeated KeyValueType64        uid_list = 2;
    uint64      uid                         = 3;  //服务器使用
}
//公会改名
message CSGuildRenameReq {  //project game|guild  //RouteRule game
    string  guild_name              = 1;
    uint64  guild_id                = 2;    //服务器填写
    uint64  uid                     = 3;    //服务器填写
}
message SCGuildRenameAck {  //project game
    int32   error                   = 1;
    string  guild_name              = 2;
}
//公会公告修改
message CSGuildReNoticeReq {    //project game|guild  //RouteRule game
    string  guild_notice            = 1;    //新公告
    uint64  guild_id                = 2;    //公会ID//服务器填写
    uint64  uid                     = 3;    //操作人ID//服务器填写
}
message SCGuildReNoticeAck {    //project game
    int32   error                   = 1;
    string  guild_notice            = 2;
}
//设置公会招募信息
message CSSetGuildInfoReq {  //project game|guild  //RouteRule game
    uint64          guild_id        = 1; //公会ID
    int32           guild_badge     = 2; //公会徽章
    int32           join_level      = 3; //加入等级
    int32           join_type       = 4; //加入类型
    string          recruit_notice  = 5; //招募公告
    uint64          uid             = 6; //UID
}
message SCSetGuildInfoAck{  //project game
    int32           error           = 1;  //错误码
    int32           guild_badge     = 2; //公会徽章
    int32           join_level      = 3; //加入等级
    int32           join_type       = 4; //加入类型
    string          recruit_notice  = 5; //招募公告
}
//公会日志请求
message CSGuildLogInfoReq { //project game|guild  //RouteRule game
    uint64      guild_id            = 1;    //服务器填写
    int64       log_time            = 2;
}
message SCGuildLogInfoAck { //project game
    repeated    GuildLog      log   = 1;
    bool        is_end              = 2;
}

//公会申请列表请求
message CSGuildApplyDataReq {   //project game|guild  //RouteRule game
    uint64          uid                 = 1;  //成员ID//服务器填写
    uint64          guild_id            = 2;  //公会ID
}
//公会申请列表返回
message SCGuildApplyDataAck {   //project game
    int32               error             = 1;
    repeated uint64     uid_list          = 2;
}
//处理入会申请
message CSApplyInfoHandleReq{   //project game|guild  //RouteRule game
    KeyValueType64      apply                = 1;  //key：UID value：1：同意， 2：拒绝
    int32               handle_type          = 2;  //0:处理apply： 1:全部接受，2:全部拒绝
    uint64              guild_id             = 3;  //公会ID//服务器填写
    uint64              uid                  = 4;  //成员ID//服务器填写
    repeated uint64     uid_list             = 5;  //处理的uid列表
}
//处理入会申请返回
message SCApplyInfoHandleAck{   //project game
    int32                   error	        = 1;
    uint64                  guild_id        = 2;  //公会ID
    int32                   handle_type     = 3;  //0:处理apply： 1:全部接受，2:全部拒绝
    repeated KeyValueType64	uid_list        = 4;  //处理Key：UID， Value：1：同意，2：拒绝，3、未处理 value2：ErrorCode
}

message SCApplyInfoHandleNtf {  //project social|game
    int32           apply_result    = 1;  //申请结果 1:通过 2:拒绝
    uint64          uid             = 2;  //申请人ID//服务器使用
    uint64          guild_id        = 3;  //公会ID
    GuildNotifyData data            = 4;  //公会信息列表
}

//查看其他公会信息
message CSGuildInfoReq{ //project game|guild  //RouteRule game
    uint64          guild_id        = 1;  //公会ID
    uint64          uid             = 2;  //申请人ID//服务器使用
}
//返回其他公会信息
message SCGuildInfoAck{ //project game
    int32       error                 = 1;
    GuildBase   guild_Base            = 2;  //公会信息      //公会日志太大了，单独请求，这里不发
    repeated    MemberBrief mem_brief = 3;  //公会成员基础信息
    bool        apply                 = 4;  //是否申请
}

//查看自己公会信息
message CSGetSelfGuildInfoReq{ //project game|guild  //RouteRule game
    uint64          guild_id        = 1;  //公会ID//服务器填写
    uint64          uid             = 2;  //UID//服务器填写
}
//返回自己公会信息
message SCGetSelfGuildInfoAck{ //project game
    int32       error                 = 1;
    GuildBase   guild_Base            = 2;  //公会信息      //公会日志太大了，单独请求，这里不发
    repeated    MemberBrief mem_brief = 3;  //公会成员基础信息
    RoleGuild   role_guild            = 4;  //公会个人活跃度
    uint32      total_active          = 5;  //近7天公会活跃度
    bool        apply_list            = 6;  //公会是否有申请
    int32       guild_battle_state    = 7;  //公会战状态(1:未开始，2：进行中，3：已结束)
    uint64      next_state_begin      = 8;  //下阶段开始时间
    uint32      cp_num                = 9;  //公会贡献点
    uint32      guild_battle_rank     = 10;  //公会贡献点名次
}

//公会成员信息请求
message CSGuildMemberInfoReq {  //project game|guild  //RouteRule game
    uint64          guild_id            = 1;  //公会ID
    repeated uint64 uid_list            = 2;  //公会成员列表
}
message SCGuildMemberInfoAck {  //project game
    int32    error                        = 1;  //错误码
    uint64   guild_id                     = 2;  //公会ID
    repeated MemberInfo     member_data   = 3;  //成员信息，玩家公会数据+简介
}
//请求推荐公会
message CSRecommendGuildInfoReq{    //project game|guild  //RouteRule game
    uint64 uid                           = 1;  //服务器使用
    int32  req_count                     = 2;  //请求次数//服务器使用
}
//返回推荐的公会
message SCRecommendGuildInfoAck{    //project game
    int32       error                       = 1;    //错误码
    repeated    GuildNotifyData  data       = 2;    //公会信息列表
}

message CSOnlinePlayerGuildReq {    //project game|guild  //RouteRule game
    uint64      uid             = 1;    //uid//服务器填写
    uint64      guild_id        = 2;    //公会ID//服务器填写
}

//玩家上线时，公会服务器返回数据
message SCOnlinePlayerGuildAck {    //project game
    GuildNotifyData  data           = 1;    //公会简介
    int64   next_join               = 2;    //下次加入公会时间
    bool    boss                    = 3;    //true:有可挑战boss
    repeated MessageContentInfo msgRec = 4;
    bool    in_guild_battle         = 5;    //true公会战入口开启，false公会战入口关闭
}

message CSSearchGuildReq {    //project game|guild  //RouteRule game
    string      search_string             = 1;   //查找公会（名字或者ID）
    uint64      uid                       = 2;    //uid//服务器填写
}

message SCSearchGuildAck {    //project game
    int32           error                 = 1;   //错误码
    string          search_string         = 2;   //查找公会
    repeated GuildNotifyData    data      = 3;   //公会简介信息
}

message SCQuitGuildCDNtf {
    int32           quit_num                 = 1;   //退出次数
    int64           next_join                = 2;   //下次加入时间
}

//公会boss数据请求
message CSGuildBossInfoReq {    //project game|guild  //RouteRule game
    uint64  guild_id                        = 1;    //公会ID//服务器填写
}
message SCGuildBossInfoAck {    //project game
    int32                       error           = 1;   //错误码
    repeated GuildBossData      boss_data       = 2;
    repeated KeyValueType       boss_fight      = 3;    //boss战斗次数/key：bossID value：当前战斗过的次数
    uint64                      elite_boss_cd   = 4;    //精英bossCD时间
}
//公会boss战斗日志请求
message CSGuildBossLogReq { //project game|guild  //RouteRule game
    uint64  log_time                        = 1;    //log时间
    uint32  boss_id                         = 2;    //战斗的BOSSID
    uint64  guild_id                        = 3;    //公会ID//服务器填写
}
message SCGuildBossLogAck { //project game
    int32   error                           = 1;   //错误码
    uint32  boss_id                         = 2;    //战斗的BOSSID
    repeated  GuildBossLogDetial    logs    = 3;
    bool    is_end                          = 4;    //true:结束，false:未结束
}

//挑战boss
message CSGuildBossChallengeReq {   //project game|guild  //RouteRule game  //confirm
    uint32  boss_id                 = 1;    //战斗的BOSSID
    uint32  damage	                = 2;    //对boss造成的伤害
    uint32  battle_time             = 3;    //对boss造成的伤害
    uint64  guild_id                = 4;    //公会ID//服务器填写
    uint64  uid                     = 5;    //服务器填写
}
message SCGuildBossChallengeAck {   //project game
    int32   error                   = 1;   //错误码
    uint32  boss_id                 = 2;    //战斗的BOSSID
    repeated KeyValueType   reward  = 3;    //获得的奖励
    uint32  damage                  = 4;    //造成的伤害
}
//召唤boss
message CSGuildBossSummonReq {  //project game|guild  //RouteRule game
    uint32  boss_id                 = 1;    //召唤的BOSSid
    uint64  guild_id                = 2;    //公会ID//服务器填写
    uint64  uid                     = 3;    //uid
}
message SCGuildBossSummonAck {  //project game
    int32   error                   = 1;   //错误码
    uint32  boss_id                 = 2;    //召唤的BOSSid
    uint32  guild_active            = 3;    //公会活跃度
    int64   fight_start             = 4;    //战斗结束
    int32   fight_count             = 5;    //当前boss剩余次数
}
//大事馈赠奖励查看
message CSGuildBossExtraRewardReq { //project game|guild  //RouteRule game
    uint32  boss_id                 = 1;    //BossId
    uint64  guild_id                = 2;    //公会ID//服务器填写
}
message SCGuildBossExtraRewardAck { //project game
    int32   error                   = 1;   //错误码
    uint32  boss_id                 = 2;    //BossId
    uint32  max_dam                 = 3;    //最大伤害
    CommonPlayerBriefInfo brief     = 4;    //玩家简介
}
//公会改名NTF
message SCGuildNameChangeNtf { //project game
    uint64  guild_id                 = 1;    //公会ID
    string  guild_name               = 2;    //公会名字
    uint64  uid                      = 3;    //UID//服务器用
}
//公会boss刷新
message SCGuildBossChangeNtf { //project game
    uint64  guild_id                 = 1;    //公会ID
    uint32  boss_id                  = 2;    //bossID
    int32   fight_count              = 3;    //boss剩余次数
}

//公会战

//公会战开始/结束时刻通知
message SCGuildBattleStageNtf {
    bool in_guild_battle                              = 1;    //true公会战入口开启，false公会战入口关闭
}

//公会战贡献点Req
message CSGuildBattleCPRankReq {        //project game  //RouteRule game
}

message SCGuildBattleCPRankAck {
    int32    error                          = 1;    //
    repeated GuildBattleCP cp_list          = 2;    //贡献点列表
    int32    self_guild_rank                = 3;    //自己公会贡献点名次
    int32    self_guild_cp                  = 4;    //自己公会贡献点
}

//公会战对阵表
message CSGuildBattleCountPartReq {     //project game  //RouteRule game

}

message SCGuildBattleCountPartAck {
    int32  error                            = 1;    //错误码
    uint64 champion                         = 2;    //冠军
    int32  cur_stge                         = 3;    //当前阶段
    uint64 tournament_prepare               = 4;    //8-4准备时间
    uint64 tournament_begin                 = 5;    //8-4开始
    uint64 tournament_end                   = 6;    //8-4结束
    uint64 semifinals_prepare               = 7;    //4-2准备时间
    uint64 semifinals_begin                 = 8;    //4-2开始
    uint64 semifinals_end                   = 9;    //4-2结束
    uint64 finals_prepare                   = 10;    //2-1准备时间
    uint64 finals_begin                     = 11;    //2-1开始
    uint64 finals_end                       = 12;    //2-1结束
    repeated CountTableData        data     = 13;   //对阵表数据
}

//mvp 数据请求
message CSGuildBattleMvpInfoReq {   //project game  //RouteRule game
    int32   guild_battle_idx                = 1;    //公会战索引（1 / 2，3 /  4，5，6，7）
}

message SCGuildBattleMvpInfoAck {
    int32   error                           = 1;
    int32   guild_battle_idx                = 2;    //公会战索引（1 / 2，3 /  4，5，6，7）
    repeated  GuildBattleDetail  detail     = 3;    //公会战 公会的详细信息
    CountTableData count_part               = 4;    //对阵信息
}

message CSGuildBattleMvpDetailReq { //project game  //RouteRule game
    int32 mvp_type                          = 1;    //mvp类型（1：积分 2：击杀）
    int32 req_rank                          = 2;    //请求的起始排名
    int32 guild_battle_idx                  = 3;    //公会战索引（1 / 2，3 /  4，5，6，7）
}

message SCGuildBattleMvpDetailAck {
    int32 mvp_type                          = 1;    //mvp类型（1：积分 2：击杀）
    repeated GuildBattleMvp mvp             = 2;    //mvp列表（目前就2个）
    int32 req_rank                          = 3;    //请求的起始排名
    int32 guild_battle_idx                  = 4;    //公会战索引（1 / 2，3 /  4，5，6，7）
}
//公会战结束

//获取对阵双方信息(打开界面时的信息)
message CSGuildBattleInfoReq {  //project game|guild  //RouteRule game
    int32 guild_battle_idx                       = 1; //1 |2,3 |4,5,6 7(7场战斗中的一场)
    uint64 self_guild_id                         = 2; //用来判断是参赛者还是旁观者 服务器使用
}
message SCGuildBattleInfoAck {  //project game
    int32   error                                = 1; //错误码
    int32 guild_battle_idx                       = 2;
    uint64 battle_start_time                     = 3;
    uint64 battle_end_time                       = 4;
    repeated KeyValueType64 battle_data_list     = 5; //[key：guildid, value:score,value2:daochang, value3:badge,strval:name]
    GuildBattleSelfData self_data                = 6; //个人信息
    GuildPosIdxData challenge_pos_data           = 7; //当前战位信息
    int32  buy_challenge_num                     = 8; //购买的战斗次数（跟人走）
}
//设置自动购买，复活CD(数据变更通过SCGuildBattleInfoNtf)
message CSGuildBattleSettingReq {   //project game|guild  //RouteRule game
    int32 guild_battle_idx                      = 1;
    bool auto_challenge                         = 2;
    bool auto_reborn                            = 3;
    uint64 self_guild_id                        = 4; //服务器使用
}
message SCGuildBattleSettingAck {   //project game
    int32   error                               = 1; //错误码
    int32 guild_battle_idx                      = 2;
    GuildBattleSelfData self_data               = 3; //个人信息
}
//挑战次数手动购买
message CSGuildBattleBuyChallengeReq {  //project game|guild  //RouteRule game
    int32 guild_battle_idx                      = 1;
    uint64 self_guild_id                        = 2; //服务器使用
}
message SCGuildBattleBuyChallengeAck {  //project game
    int32   error                               = 1; //错误码
    GuildBattleSelfData self_data               = 2; //个人信息
    int32  buy_challenge_num                    = 3; //购买的战斗次数（跟人走）
    int32 guild_battle_idx                      = 4; //
}
//手动重置复活CD
message CSGuildBattleRebornReq {    //project game|guild  //RouteRule game
    int32 guild_battle_idx                      = 1;
    uint64 self_guild_id                        = 2; //服务器使用
}
message SCGuildBattleRebornAck {    //project game
    int32   error                               = 1; //错误码
    GuildBattleSelfData self_data               = 2; //个人信息
    int32 guild_battle_idx                      = 3; //
}
//战斗排行(1积分排行/2击杀排行)
message CSGuildBattleRankListReq {  //project game|guild  //RouteRule game
    int32 guild_battle_idx                      = 1;
    int32 rank_type                             = 2; //1积分，2击杀
    int32 page_idx                              = 3;
}
message SCGuildBattleRankListAck {  //project game
    int32   error                                = 1; //错误码
    int32 page_idx                               = 2;
    int32 guild_battle_idx                       = 3;
    repeated GuildBattleRank rank_data_list      = 4;
    repeated KeyValueType64 battle_data_list     = 5; //[key：guildid, value:score,value2:daochang, value3:badge,strval:name]
    bool is_finish                               = 6; //当前战斗是否结束
    bool win_guild                               = 7; //胜利公会ID
    int32 rank_type                              = 8; //1积分，2击杀
}
//获取位置信息,上限20
message CSGuildBattlePosIdxListReq {    //project game|guild  //RouteRule game
    int32 guild_battle_idx                       = 1;
    repeated int32 pos_idx_list                  = 2;
}
message SCGuildBattlePosIdxListAck {    //project game
    int32   error                                = 1; //错误码
    int32 guild_battle_idx                       = 2;
    repeated GuildPosIdxData pos_data_list       = 3; //占位信息
}
//占领记录
message CSGuildBattleLogReq {   //project game|guild  //RouteRule game
    int32 guild_battle_idx                       = 1;
    uint64 begin_time                            = 2;
}
message SCGuildBattleLogAck {   //project game
    int32 error                                  = 1; //错误码
    int32 guild_battle_idx                       = 2;
    repeated GuildBattleLog log_list             = 3;
    bool is_end                                  = 4;
}
//挑战占位
message CSGuildBattleChallengeReq { //project game  //RouteRule game
    int32 guild_battle_idx                       = 1;
    int32 pos_idx                                = 2;
}
message SCGuildBattleChallengeAck {
    int32 error                                  = 1; //错误码
    int32 guild_battle_idx                       = 2;
    int32 pos_idx                                = 3;
    FightRoleInfo fight_info                     = 4; //对方玩家信息
    GuildPosIdxData challenge_pos_data           = 5;
    repeated KeyValueType fight_buff_list        = 6; //buff列表
    repeated KeyValueType self_buff_list         = 7; //自己的buff列表
    GuildBattleSelfData self_data                = 8; //个人信息 服务器使用
    int32  buy_challenge_num                     = 9; //购买的战斗次数（跟人走）
}
message SCGuildBattleChallengeNtf {
    int32 guild_battle_idx                       = 1;
    int32 pos_idx                                = 2;
    GuildBattleSelfData self_data                = 3; //个人信息
    int32  buy_challenge_num                     = 4; //购买的战斗次数（跟人走）
}
message CSGuildBattleChallengeResultReq {   //project game|guild  //RouteRule game
    int32 guild_battle_idx                       = 1;
    int32 battle_time                            = 2; //战斗持续时间
    int32 pos_idx                                = 3;
    uint64 pos_uid                               = 4; //对手id 玩家赋值uid，机器人赋值机器人id(做校验使用)
    bool battle_result                           = 5; //true胜利 false失败
    uint64 self_guild_id                         = 6; //服务器使用
    CommonPlayerBriefInfo bf_info                = 7; //服务器使用
}
message SCGuildBattleChallengeResultAck {   //project game
    int32 error                                  = 1; //错误码
    int32 guild_battle_idx                       = 2;
}
//数据变更通知
message SCGuildBattleDataChangeNtf {    //project game|social
    uint64 ntf_uid                               = 1;
    int32 guild_battle_idx                       = 2;
    GuildPosIdxData pos_data                     = 3;
    GuildBattleSelfData self_data                = 4; //个人信息
    bool from_social                             = 5; //服务器使用 来自social的消息
}
//保持战斗状态消息通知(60s内未收到消息判定为失败)
message CSGuildBattleChallengePingReq { //project game|guild  //RouteRule game
    int32 guild_battle_idx                       = 1;
    int32 pos_idx                                = 2; //正在挑战的占位
}
message SCGuildBattleChallengePingAck { //project game
    int32 error                                  = 1; //错误码
}
//客户端刷新最新pk数据(道场数量/积分数量)
message CSGuildBattlePKDataReq {    //project game|guild  //RouteRule game
    int32 guild_battle_idx                       = 1;
}
message SCGuildBattlePKDataAck {    //project game
    int32 error                                  = 1; //错误码
    int32 guild_battle_idx                       = 2;
    repeated KeyValueType64 battle_data_list     = 3; //
}
//购买战斗buff
message CSGuildBattleBuyBuffReq {   //project game|guild  //RouteRule game
    int32 guild_battle_idx                       = 1;
    repeated int32 buff_id_list                  = 2;
}
message SCGuildBattleBuyBuffAck {   //project game
    int32 error                                  = 1; //错误码
    int32 guild_battle_idx                       = 2;
    GuildBattleSelfData self_data                = 3; //个人信息
}

message GuildDemonRank {
    uint64 uuid                                     = 1; //公会ID/玩家ID 
    int32 rank                                      = 2; //排名
    uint64 damage                                   = 3; //战斗伤害
    string guild_name                               = 4; //公会名
    int32 guild_badge                               = 5; //公会徽章
}

message GuildDemonGuildRank {
    GuildNotifyData  data                           = 1; //公会信息列表
    int32 rank                                      = 2; //排名
    uint64 damage                                   = 3; //战斗伤害
}

//公会魔王信息请求
message CSGuildDemonInfoReq {       //project game|guild  //RouteRule game
    uint64 guild_id                                 = 1;    //服务器用
    uint64 uid                                      = 2;    //服务器用
}
message SCGuildDemonInfoAck {       //project game
    int32 demon_id                                  = 1;    //当天的公会bossID
    uint64 next_up_time                             = 2;    //下一次升级时间
    int32 demon_level                               = 3;    //魔王等级
    uint64 end_time                                 = 4;    //当天挑战结束时间
    int32 left_fight_count                          = 5;    //剩余战斗次数
    int32 left_buy_count                            = 6;    //剩余战斗次数
    uint64 total_boss_damage                        = 7;    //boss总伤害
    uint64 damage                                   = 8;    //我的战斗伤害
    uint64 mvp_damage                               = 9;    //mvp伤害
    CommonPlayerBriefInfo mvp_brief                 = 10;    //玩家昵称
    repeated DemonDamage rank_list                  = 11;    //公会玩家排名列表
    uint64 req_uid                                  = 12;    //请求的玩家ID
}

//公会魔王战斗请求
message CSGuildDemonFightReq {      //project game|guild  //RouteRule game
    int32 demon_id                                  = 1;
    uint64 damage                                   = 2;    //总伤害
}
message SCGuildDemonFightAck {      //project game
    int32 error                                     = 1;
    int32 demon_id                                  = 2; //bossid
    int32 fight_count                               = 3; //剩余战斗次数
    uint64 total_damage                             = 4; //boss总伤害
    uint64 self_damage                              = 5; //自己总伤害
    repeated KeyValueType base_reward               = 6; //战斗基础奖励
}

//请求公会魔王公会排名
message CSGuildDemonGuildRankReq {      //project game|guild  //RouteRule game
    int32 page                                      = 1;    //页签
    uint64 guild_id                                 = 2;    //公会ID
    uint64 uid                                      = 3;    //服务器用
}
message SCGuildDemonGuildRankAck {      //project game
    int32 error                                     = 1;
    int32 page                                      = 2;    //页签
    repeated GuildDemonGuildRank rank_list          = 3;    //列表
    GuildDemonGuildRank self_guild                  = 4;    //自己公会
    bool is_end                                     = 5;    //是否结束
    uint64 uid                                      = 6;    //服务器用
}

//请求公会魔王最强公会个人排名
message CSGuildDemonMVPRankReq {      //project game|guild  //RouteRule game
    int32 page                                      = 1;    //页签
    uint64 guild_id                                 = 2;    //
    uint64 uid                                      = 3;    //服务器用
}
message SCGuildDemonMVPRankAck {      //project game
    int32 error                                     = 1;
    int32 page                                      = 2;    //页签
    repeated GuildDemonRank rank_list               = 3;    //列表
    GuildDemonRank self_guild_mvp                   = 4;    //自己公会MVP
    CommonPlayerBriefInfo mvp_brief                 = 5;    //玩家昵称
    bool is_end                                     = 6;    //是否结束
    uint64 uid                                      = 7;    //服务器用
}

//请求购买公会魔王战斗次数
message CSGuildDemonBuyFightCountReq {      //project game  //RouteRule game
    int32 fight_count                               = 1;    //购买次数
}
message SCGuildDemonBuyFightCountAck {      //project game
    int32 error                                     = 1;    //
    int32 left_buy_count                            = 2;    //剩余购买次数
    int32 left_fight_count                          = 3;    //剩余战斗
}

/////////////////////////////////////////////////////////pet
//宠物数据变更(客户端需要判断数据库不为空时才处理)
message SCPetChangeNtf {
    repeated PetData pet_list                  = 1; //变更/增加
    repeated uint32 del_pet_list               = 2; //删除宠物id列表
    repeated PetManualST  pet_manual_list      = 3; //宠物图鉴
    repeated AssistIdxData assist_pet_list     = 4; //援助宠物列表
}
//宠物升级
message CSPetLevelUpReq {   //project game  //RouteRule game
    uint32 pet_id                            = 1;
}
message SCPetLevelUpAck {
    int32 error                           = 1; //错误码
    uint32 pet_id                         = 2;
}
//宠物进阶
message CSPetAdvanceReq {   //project game  //RouteRule game
    uint32       pet_id                   = 1; //需要进阶的宠物
    repeated uint32 pet_list              = 2; //进阶消耗材料
}
message SCPetAdvanceAck {
    int32       error                           = 1; //错误码
}
//宠物领悟
message CSPetSkillLevelUpReq {  //project game  //RouteRule game
    uint32 pet_id                               = 1;
    uint32 cost_pet_id                          = 2;
}
message SCPetSkillLevelUpAck {
    int32       error                           = 1; //错误码
    uint32 pet_id                               = 2;
    int32 skill_id                              = 3;
}
//宠物分解
message CSPetDecomposeReq {    //project game  //RouteRule game
    repeated uint32 pet_id_list                 = 1;
}
message SCPetDecomposeAck {
    int32       error                           = 1; //错误码
    repeated KeyValueType item_list             = 2; //分解返回材料
}
//获取羁绊列表数据
message CSPetBondListReq {  //project game  //RouteRule game
}
message SCPetBondListAck {
    int32       error                           = 1; //错误码
    repeated PetBondData bond_list              = 2;
    repeated KeyValueType64Str uid_name_list    = 3; //名字列表
}
//玩家主动操作导致的羁绊数据变更（进阶，分解）
message SCPetBondListNtf {
    repeated PetBondData bond_list              = 1;
}
//获取激活羁绊所需的宠物列表(援助列表，好友/公会)
message CSPetBondAssistListReq {    //project game  //RouteRule game
    int32 bond_cfg_id                           = 1; //key:1品质 2进阶等级 3特殊属性
}
message SCPetBondAssistListAck {
    int32 error                                         = 1;
    int32 bond_cfg_id                                   = 2;
    repeated AssistData bond_pet_list                   = 3; //
}
//宠物羁绊激活
message CSPetBondActiveReq {    //project game  //RouteRule game
    repeated PetBondData bond_data_list               = 1;
}
message SCPetBondActiveAck {
    int32       error                           = 1; //错误码
    repeated PetBondData bond_data_list         = 2;
    repeated KeyValueType64Str uid_name_list    = 3; //名字列表
}
//宠物援助
message CSPetAssistReq {    //project game  //RouteRule game
    repeated uint32 pet_id_list          = 1;
}
message SCPetAssistAck {
    int32       error                    = 1; //错误码
    repeated  AssistIdxData  assist_list    = 2; //援助宠物
}
//上阵/下阵
message CSPetBattleReq {    //project game  //RouteRule game
    repeated KeyValueType battle_list = 1;
}
message SCPetBattleAck {
    int32       error           = 1; //错误码
}
//图鉴奖励获取
message CSPetManualRewardReq {  //project game  //RouteRule game
    int32 pet_cfg_id            = 1;
    int32 pet_adv_level         = 2; //进阶等级奖励
    int32 pet_id                = 3;
}
message SCPetManualRewardAck {
    int32 error = 1; //错误码
    repeated KeyValueType reward_list = 2;
    int32 pet_cfg_id = 3;
}
//最早收集到宠物最高进阶等级获取
message CSPetAdvAchievementReq {    //project game  //RouteRule game
    int32   pet_cfg_id              = 1;
}
message SCPetAdvAchievementAck {
    int32 error                     = 1; //错误码
    int32   pet_cfg_id              = 2;
    CommonPlayerBriefInfo brief     = 3; //玩家昵称
    uint64 achievement_time         = 4; //达成该成就时的时间
}

//请求宠物冲榜活动数据
message CSPetActivityReq {     //project game  //RouteRule game
}

message SCPetActivityAck {
    int32       error                   = 1;    //错误码
    int32       self_rank               = 2;    //自己排名
    int32       self_score              = 3;    //自己分数
    uint64      end_time                = 4;    //结束时间
    bool        challeng_reward         = 5;    //挑战奖励是否领取
    bool        rank_reward             = 6;    //排名奖励是否领取
    repeated RushPetData    top_data    = 7;    //这里只发送前10名
}

message CSPetActivityRankReq {  //project game|rank  //RouteRule game
    int32 page                          = 1;
}
message SCPetActivityRankAck {  //project game
    int32       error                   = 1;    //错误码
    int32       page                    = 2;
    repeated RushPetData    top_data    = 3;    
}

//宠物印记(装备)
//印记数据变更
message SCPetEquipDataNtf {
    repeated PetEquipData pet_equip_list            = 1; //宠物印记
    bool ignore                                     = 2; //true不弹框提示，false正常提示
}
//印记升级/进阶
message CSPetEquipLevelUpReq {  //project game  //RouteRule game
    uint32 pet_equip_id                             = 1; //动态生成的id
}
message SCPetEquipLevelUpAck {
    int32 error                                     = 1; //错误码
    PetEquipData pet_equip                          = 2;
}
//印记启用
message CSPetEquipUpReq {   //project game  //RouteRule game
    uint32 pet_id                                   = 1;
    repeated KeyValueType slot_list                 = 2; //key=slotindex val=petequipid
}
message SCPetEquipUPAck {
    int32 error                                     = 1; //错误码
    uint32 pet_id                                   = 2;
    repeated KeyValueType slot_list                 = 3; //key=slotindex val=petequipid
}
//印记卸下
message CSPetEquipDownReq { //project game  //RouteRule game
    uint32 pet_id                                   = 1;
    int32 slot_index                                = 2;
}
message SCPetEquipDownAck {
    int32 error                                     = 1; //错误码
    uint32 pet_id                                   = 2;
    int32 slot_index                                = 3;
}

//宠物系统优化
//背包界面只下发必要数据，后续通过打开宠物界面主动获取
message CSPetDetailInfoReq {    //project game  //RouteRule game
    repeated uint32 pet_id_list                     = 1; //宠物动态ID
}
message SCPetDetailInfoAck {
    repeated PetData pet_info_list                  = 1; //宠物详细信息
}
////宠物契约
//契约槽位数据变更通知
message SCPetQiyueDataNtf {
    int32 hero_id                                   = 1; //伙伴(hero)动态id
    PetQiyueInfo qiyue_info                         = 2; //当前伙伴跟随的宠物契约信息
}
//契约槽位解锁
message CSPetQiyueSlotUnlockReq { //project game  //RouteRule game
                                  int32 hero_id                                   = 1; //伙伴(hero)动态id
}
message SCPetQiyueSlotUnlockAck {
    int32 error                                     = 1; //错误码
    int32 hero_id                                   = 2; //伙伴(hero)动态id
}
//契约操作添加宠物(替换也使用该协议)
message CSPetQiyueSlotInReq { //project game  //RouteRule game
    int32 hero_id                                   = 1; //伙伴(hero)动态id
    int32 slot_idx                                  = 2; //1-4
    uint32 pet_id                                   = 3; //放入契约槽位宠物(宠物动态id)
}
message SCPetQiyueSlotInAck {
    int32 error                                     = 1; //错误码
    int32 hero_id                                   = 2; //伙伴(hero)动态id
    int32 slot_idx                                  = 3; //1-4
}
//卸载契约槽宠物
message CSPetQiyueSlotOutReq {    //project game  //RouteRule game
    int32 hero_id                                   = 1; //伙伴(hero)动态id
    int32 slot_idx                                  = 2; //1-4,0表示一键卸下该伙伴跟随宠物的觉醒材料宠物
}
message SCPetQiyueSlotOutAck {
    int32 error                                     = 1; //错误码
    int32 hero_id                                   = 2; //伙伴(hero)动态id
    int32 slot_idx                                  = 3; //1-4,0表示一键卸下该伙伴跟随宠物的觉醒材料宠物
}
//契约总属性面板中出阵宠物契约属性
message CSPetQiyueBattlePetAttrReq {    //project game  //RouteRule game
}
message SCPetQiyueBattlePetAttrAck {
    int32 error                                     = 1; //错误码
    repeated ActorAttrType  actor_list              = 2; //
}

/////////////////////////////////////////////////////////远征之门
message SCExpeditionChangeNtf {
    BattleExpedition expedition_info            = 1;
    bool day_reset                              = 2;
}

//点击挑战按钮
message CSExpeditionChallengePreReq {   //project game  //RouteRule game
    int32 expedition_type                     = 1; //区域ID
}
message SCExpeditionChallengePreAck {
    int32 error                                 = 1; //错误码
}
//客户端上报hp，sp，并获取奖励(buff)
message CSExpeditionChallengeReq {  //project game  //RouteRule game
    int32 expedition_type                               = 1;
    int32 battle_level                                  = 2;
    repeated BattleExpeditionActor hero_info_list       = 3; //英雄血量
    repeated BattleExpeditionActor boss_change_hp_list  = 4; //扣血列表(客户端扣血顺序逻辑帧)
    int32 battle_time                                   = 5; //战斗持续时长(单位秒)
    int32 battle_idx                                    = 6; //1,2,3
    int32 flag                                          = 7; //1战斗开始，2刷新，3战斗结束
}
message SCExpeditionChallengeAck{
    int32 error                                 = 1; //错误码
    int32 flag                                  = 2; //1战斗开始，2刷新，3战斗结束 4(胜利的方式战斗结束服务之赋值)
    repeated int32 buff_list                    = 3; //buff列表
}
//战斗结束后选择buff id
message CSExpeditionSelectBuffReq { //project game  //RouteRule game
    int32 select_buff_id                        = 1; //配置表id
}
message SCExpeditionSelectBuffAck {
    int32 error                                 = 1; //错误码
}
//领取区域地图宝箱奖励(未领取在隔天重置时统一发送邮件)
message CSExpeditionRewardReq { //project game  //RouteRule game
    int32 expedition_type                       = 1; //区域地图id(类型)
    int32 boss_idx                              = 2; //为0表示一键领取
}
message SCExpeditionRewardAck {
    int32 error                                 = 1; //错误码
    repeated KeyValueType reward_item_list      = 2; //奖励物品
}
//设置上阵玩家
message CSExpeditionBattleHeroReq { //project game  //RouteRule game
    repeated int32  battle_hero_list            = 1;
}
message SCExpeditionBattleHeroAck {
    int32 error                                 = 1; //错误码
}
//求助其他玩家(自己英雄死亡发送求助操作)
message CSExpeditionCallForHelpReq {    //project game  //RouteRule game
    uint64 assist_help_uid                      = 1; //为0表示公会求助，如果不存在公会返回错误
}
message SCExpeditionCallForHelpAck {
    int32 error                                 = 1; //错误码
}
//对方回应求助操作，通知给求助玩家
message SCExpeditionCallForHelpNtf {
    int32 assist_state                          = 1; //1成功求助
    CommonPlayerBriefInfo brief                 = 2;
}
//救助 求助的玩家
message CSExpeditionHelpReq {   //project game  //RouteRule game
    uint64 be_helped_uid                        = 1;
    int32 msg_type                              = 2; //来自私聊还是来自公会(1私聊 3公会)
    uint64 help_msg_send_time                   = 3; //求助消息发送时的时间
}
message SCExpeditionHelpAck {
    int32 error                                 = 1; //错误码
    repeated KeyValueType reward_item_list      = 2; //奖励物品
}
//勇士积分排行
message CSExpeditionScoreRankListReq {   //project game  //RouteRule game
    int32 start_idx                             = 1;//1[1-10] 2[11-20] 3[21-30] ...
}
message SCExpeditionScoreRankListAck {
    int32 error                                  = 1; //错误码
    repeated ExpeditionRankInfo rank_list        = 2;
    ExpeditionRankInfo self_rank_info            = 3;
    int32 start_idx                              = 4;
}
//远征之门通关地图奖励获取
message CSExpeditionPassRewardReq { //project game  //RouteRule game
    int32 expedition_type                        = 1; //关卡地图区域Type
}
message SCExpeditionPassRewardAck {
    int32 error                                 = 1; //错误码
    repeated KeyValueType reward_item_list      = 2; //奖励物品
}
/////////////////////////////////////////////////////////精彩活动
message SCActivitiesStartupNtf {
    repeated ActivitiesData open_activity_list       = 1; //开启的活动列表
    //精彩活动
    uint64   cur_day_end_time                        = 2; //当前天结束时间戳
    //活动数据
    repeated ActivitiesDetailData activity_data_list = 3;

    //首充大礼包时间(达到给定数值记录时间)
    uint64 first_charge_time                         = 4; //非0表示可以进行奖励领取
    int32 first_charge_reward_state                  = 5;
    //超值礼包数据
    repeated ActivitiesUnlockRechargeData unlock_charge_list       = 6;
}
//开启的活动通知
message SCActivitiesOpenListNtf {
    repeated ActivitiesData activity_list        = 1; //开启的活动列表
}
//活动数据变更通知
message SCActivitiesChangeNtf {
    repeated ActivitiesDetailData activity_data_list        = 1;
    uint64  cur_day_end_time                                = 2; //当前天结束时间戳
}
//连续登录奖励获取
//14日目标任务
//百元礼包
//每日累计充值
message CSActivitiesRewardReq { //project game  //RouteRule game
    int32 activity_id                           = 1;
    int32 param                                 = 2; //领取day对应天的奖励 | 任务id
    int32 reward_num                            = 3; //兑换次数
}
message SCActivitiesRewardAck {
    int32 activity_id                           = 1;
    int32 error                                 = 2; //错误码
    repeated KeyValueType reward_item_list      = 3; //奖励物品
}
//积分奖励获取
message CSActivitiesScoreRewardReq {    //project game  //RouteRule game
    int32 activity_id                           = 1;
    int32 box_idx                               = 2; //配置表中的唯一id
}
message SCActivitiesScoreRewardAck {
    int32 activity_id                           = 1;
    int32 error                                 = 2; //错误码
    repeated KeyValueType reward_item_list      = 3; //奖励物品
}
///支付活动相关
//开启超值礼包通知
message SCActivitiesDiscountsNtf {
    repeated ActivitiesUnlockRechargeData discount_data_list  = 1;
}
//获取首充奖励
message CSActivitiesFirstChargeRewardReq {  //project game  //RouteRule game
}
message SCActivitiesFirstChargeRewardAck {
    int32 error                                 = 1;
    repeated KeyValueType reward_item_list      = 2; //奖励物品
}
message SCActivitiesFirstChargeChangeNtf {
    int32 first_charge_reward_state             = 1; //获取奖励状态
    uint64 first_charge_time                    = 2; //非0表示可以进行奖励领取
}
//获取全局服务器数据
message CSActivitiesCollectionServerDataReq {   //project game  //RouteRule game
    int32 activity_id                           = 1;
}
message SCActivitiesCollectionServerDataAck {
    int32 error                                 = 1; //错误码
    int32 activity_id                           = 2;
    repeated KeyValueType data_list             = 3; //全局相关数据
}
//消耗道具获得好感度(3.8活动)
message CSActivitiesLikabilityRewardReq {   //project game  //RouteRule game
    int32 activity_id                           = 1;
    int32 item_cfg_id                           = 2; //道具
    int32 likability_level                      = 3; //道具对应档位
}
message SCActivitiesLikabilityRewardAck {
    int32 error                                 = 1; //错误码
    int32 activity_id                           = 2;
    repeated KeyValueType reward_item_list      = 3; //奖励物品
}

message CSActivitiesExchangeReq {   //project game  //RouteRule game
    int32 reward_idx                            = 1;
    int32 activity_id                           = 2;
    repeated ExchangeInfo data                  = 3;
}

message SCActivitiesExchangeAck {   //project game  //RouteRule game
    int32 error                                 = 1;
    int32 reward_idx                            = 2;
    int32 activity_id                           = 3;
    int32 exchange_time                         = 4;    //剩余兑换次数
}

//集字活动提醒设置
message CSActivitiesWordNoticeSetReq { //project game  //RouteRule game
    int32 activity_id                           = 1;
    int32 collect_id                            = 2;
    bool no_notice                              = 3;
}
message SCActivitiesWordNoticeSetAck {
    int32 error                                 = 1;
    int32 activity_id                           = 2;
    int32 collect_id                            = 3;
    bool no_notice                              = 4;
}
//转盘活动
//刷新转盘道具(未开启本轮时操作)
message CSActivityWheelRefreshReq { //project game  //RouteRule game
    int32 activity_id                           = 1;
}
message SCActivityWheelRefreshAck {
    int32 error                                 = 1; //错误码
}
//开启本轮转盘(开始获取奖励)
message CSActivityWheelOpenRewardReq {  //project game  //RouteRule game
    int32 activity_id                           = 1;
}
message SCActivityWheelOpenRewardAck {
    int32 error                                 = 1; //错误码
}
//转一次/转本轮(获取所有奖励)
message CSActivityWheelRewardReq {  //project game  //RouteRule game
    int32 activity_id                           = 1;
    bool reward_all                             = 2;//false:转一次  true:获取所有奖励
}
message SCActivityWheelRewardAck {
    int32 error                                 = 1; //错误码
    bool reward_all                             = 2; //转一次/转本轮
    repeated WheelRewardItemInfo reward_list    = 3; //奖励
}
//关闭本轮转盘
message CSActivityWheelCloseRewardReq { //project game  //RouteRule game
    int32 activity_id                           = 1;
}
message SCActivityWheelCloseRewardAck {
    int32 error                                 = 1; //错误码
}

//活动召唤
//召唤
message CSActivitySummonReq { //project game  //RouteRule game
    int32 activity_id                           = 1; //活动id
    int32 summon_count                          = 2; //抽取次数(单抽，10连抽)
}
message SCActivitySummonAck {
    int32 error                                 = 1; //错误码
    int32 activity_id                           = 2; //活动ID
    int32 draw_count                            = 3; //抽卡类型1：抽1次，5：抽五次
    repeated DrawItem           item_list       = 4; //抽取的奖励列表
    repeated DrawItem           extra_item      = 5; //保底奖励
    int32 draw_times                            = 6; //draw_type对应的抽取次数
    int32 add_point                             = 7; //增加的保底点数
}

message CSActivitySignInReq {   //project game  //RouteRule game
    int32 activity_id                           = 1; //活动id
}

message SCActivitySignInAck {
    int32 error                                 = 1; //错误码
    int32 activity_id                           = 2; //活动id
    repeated KeyValueType   reward_list         = 3; //奖励列表
    repeated KeyValueType   ext_reward_list     = 4; //额外奖励
    uint64 next_sign_time                       = 5; //下次签到时间
    int32 sign_days                             = 6; //当前签到天数
}

// bt砸蛋活动
message CSActivitySmashEggsReq {    //project game  //RouteRule game
    int32 activity_id                           = 1; // 活动id
    int32 draw_count                            = 2; // 抽取次数(单抽，10连抽)
    int32 draw_type                             = 3; // 4金蛋 5彩蛋
}
message SCActivitySmashEggsAck {
    int32 error                                 = 1; //错误码
    int32 activity_id                           = 2; //活动ID
    int32 draw_count                            = 3; //抽卡类型[1:抽1次, 5:抽5次, 10:抽10次]
    int32 draw_type                             = 4; // 4金蛋 5彩蛋

    repeated DrawItem           item_list       = 5; //抽取的奖励列表
    repeated DrawItem           extra_item      = 6; //保底奖励
    int32 draw_times                            = 7; //draw_type对应的抽取次数
    int32 add_point                             = 8; //增加的保底点数
    repeated SystemMessage msg_list             = 9; // 活动内的操作消息(砸蛋奖励获取消息)
}
// 砸蛋记录获取
message CSActivitySmashEggsMsgReq { //project game  //RouteRule game
    int32 activity_id                           = 1; // 活动id
    int32 draw_type                             = 2; // 4金蛋 5彩蛋
}
message SCActivitySmashEggsMsgAck {
    repeated SystemMessage act_msg_list         = 1; // 活动内的操作消息(砸蛋奖励获取消息)
}

/////////////////////////////////////////////////////////拉新(好友邀请功能)
message SCInvitationStartupNtf {
    RoleInvitation invitation_info                      = 1;
}
message SCInvitationChangNtf{
    RoleInvitation invitation_info                      = 1;
    repeated uint64 del_member_uid_list                 = 2;
}
//获取邀请码功能信息(无自身邀请码则生成)
message CSInvitationNumberReq { //project game  //RouteRule game
}
message SCInvitationNumberAck {
    int32 error                                         = 1; //错误码
}
//获取邀请码对应玩家信息
message CSInvitationNumberUserInfoReq { //project game  //RouteRule game
    uint64 invitation_number                            = 1; //自己的邀请码
}
message SCInvitationNumberUserInfoAck {
    int32 error                                         = 1; //错误码
    CommonPlayerBriefInfo brief                         = 2; //邀请码对应玩家简介信息
    int32 member_num                                    = 3; //邀请码对一个玩家的成员数量
}

//填写其他玩家邀请码成为学员
message CSInvitationBeToMemberReq { //project game  //RouteRule game
    uint64 master_invitation_number                     = 1; //导师邀请码
    uint64 master_uid                                   = 2; //导师uid(做合法性校验)
}
message SCInvitationBeToMemberAck {
    int32 error                                         = 1; //错误码
}
//拍一拍
message CSInvitationClickReq {  //project game  //RouteRule game
    repeated uint64 member_uid_list                     = 1; //学员uid(填写0表示一键拍一拍)
}
message SCInvitationClickAck {
    int32 error                                         = 1; //错误码
    repeated KeyValueType reward_item_list              = 2; //奖励物品
}
//拍一拍回应
message CSInvitationClickReplayReq {    //project game  //RouteRule game
    uint64 master_uid                                   = 1; //有可能玩家已经被解除关系
}
message SCInvitationClickReplayAck {
    int32 error                                         = 1; //错误码
    repeated KeyValueType reward_item_list              = 2; //奖励物品
}
//导师删除学员
message CSInvitationDelMemberReq {  //project game  //RouteRule game
    repeated uint64 del_member_uid_list                 = 1;
}
message SCInvitationDelMemberAck {
    int32 error                                         = 1; //错误码
    repeated uint64 del_member_uid_list                 = 2;
}
//获取任务奖励
message CSInvitationTaskRewardReq { //project game  //RouteRule game
    repeated uint32 task_id_list                        = 1;
}
message SCInvitationTaskRewardAck {
    int32 error                                         = 1; //错误码
    repeated uint32 task_id_list                        = 2;
    repeated KeyValueType reward_item_list              = 3; //奖励物品
}
/////////////////////////////////////////////////////////充值
//获取充值信息(订单信息，商品信息)
message CSPayInfoGetReq {   //project game  //RouteRule game
    int32 goods_id                                      = 1;
    int32 goods_type                                    = 2; //系统(首充)
    int32 count                                         = 3;
}
message SCPayInfoGetAck {
    int32 error                                         = 1; //错误码
    int32 goods_id                                      = 2;
    int32 goods_type                                    = 3;
    string goods_name                                   = 4;
    uint64 cp_order_id                                  = 5; //产品订单号
    float amount                                        = 6; //支付总额
    int32 count                                         = 7; //购买数量
    int32 s_id                                          = 8; //当前服务器zone
}
//充值信息变更通知
message SCPayInfoNtf {
    float      total_recharge        = 1; //累计充值
    float      day_recharge          = 2; //每日累计充值
    float      bt_zhen_day_recharge  = 3; // bt真每日累计充值
    int32      bt_jia_day_recharge   = 4; // bt假每日累计充值
    uint64     bt_jia_total_recharge = 5; // bt假累计充值
}
//上线获取成功成但是没有获取奖励的订单数据
message CSPayInfoOrderOKListGetReq {    //project game  //RouteRule game
}
message SCPayInfoOrderOKListGetAck {
    repeated KeyValueType reward_item_list              = 1; //奖励物品
}

// 充值钱包商店购买(假钱购买)
// bt服务器版本使用
message CSCreditRechargeShopItemBuyReq {    //project game  //RouteRule game
    int32 goods_id                                      = 1;
    int32 count                                         = 2;
}
message SCCreditRechargeShopItemBuyAck {
    int32 error                                         = 1; //错误码
    int32 goods_id                                      = 2;
    repeated KeyValueType reward_item_list              = 3; //奖励物品
    RuneShopItem shop_item                              = 4;
}
// 充值钱包当前已经使用额度和使用额度上限变化通知
// 特权商店数据变化通知
message SCRuneBaseDataNtf {
    RuneBaseData rune_base_data                         = 1;
}
// 特权卡商店每日礼包领取
message CSRuneSpecialPrivilegeRewardReq {   //project game  //RouteRule game
}
message SCRuneSpecialPrivilegeRewardAck {
    int32 error                                         = 1; //错误码
    repeated KeyValueType reward_item_list              = 2; //奖励物品
}
/////////////////////////////////////////////////////////百人道场
//基础收益 / 占领收益 / 剩余挑战次数 变更通知
message SCDaoChang100DataChangNtf{
    RoleDaoChang100 ntf_data                     = 1;
    DaoChang100PosIdxData self_pos_data          = 2;
}
//获取玩家(玩家自身和其他玩家)占位信息
message CSDaoChang100PlayerInfoReq {  //project game|rank  //RouteRule game
    uint64 player_uid                           = 1;
}
message SCDaoChang100PlayerInfoAck {  //project game
    int32 error                                  = 1; //错误码
    uint64 player_uid                            = 2;
    DaoChang100PosIdxData player_pos_data        = 3;
    bool has_new_log                             = 4; //占位过期日志
}
//获取百人道场位置信息数据
//列表上限20
message CSDaoChang100Req {  //project game  //RouteRule game
    repeated int32 pos_idx_list                  = 1;
}
message SCDaoChang100Ack {
    int32 error                                  = 1; //错误码
    repeated DaoChang100PosIdxData pos_data_list = 2; //占位信息
}
//获取占领记录
message CSDaoChang100LogReq {   //project game  //RouteRule game
    uint64 begin_time                            = 1;
}
message SCDaoChang100LogAck {
    int32 error                                  = 1; //错误码
    repeated DaoChang100Log log_list             = 2;
    bool is_end                                  = 3;
}
//挑战占位(挑战成功后发送通知消息SCDaoChang100DataChangNtf)
message CSDaoChang100ChallengeReq { //project game  //RouteRule game
    int32 pos_idx                                = 1;
}
message SCDaoChang100ChallengeAck {
    int32 error                                  = 1; //错误码
    int32 pos_idx                                = 2;
    FightRoleInfo fight_info                     = 3; //对方玩家信息
    DaoChang100PosIdxData challenge_pos_data     = 4;
}
message CSDaoChang100ChallengeResultReq {   //project game  //RouteRule game
    int32 battle_time                            = 1; //战斗持续时间
    int32 pos_idx                                = 2;
    uint64 pos_uid                               = 3; //对手id 玩家赋值uid，机器人赋值机器人id(做校验使用)
    bool battle_result                           = 4; //true胜利 false失败
}
//获取收益奖励
message CSDaoChang100TimeRewardReq {    //project game  //RouteRule game
}
message SCDaoChang100TimeRewardAck {
    int32 error                                  = 1; //错误码
    repeated KeyValueType reward_list            = 2;
    int32 reward_num                             = 3; //领取的base奖励次数
}
//购买挑战次数
message CSDaoChang100BuyChallengeCountReq { //project game  //RouteRule game
}
message SCDaoChang100BuyChallengeCountAck {
    int32 error                                  = 1; //错误码
}
//道场口号设置
message CSDaoChang100SetTipsReq {   //project game  //RouteRule game
    string tip_desc                              = 1; //
}
message SCDaoChang100SetTipsAck {
    int32 error                                  = 1; //错误码
}

//礼包码获取奖励
message CSGiftRewardReq {   //project game|social|gmweb  //RouteRule game
    string gift_code                            = 1;
    uint64 uuid                                 = 2;
}
message SCGiftRewardAck {   //project social|game
    int32 error                                 = 1; //错误码
    uint64 uuid                                 = 2; //服务器使用
    repeated KeyValueType  reward_list          = 3; //礼包奖励
}

//道场转盘
message SCDaoChang100WheelChangNtf {
    RoleDaoChang100 ntf_data                     = 1;
}
//打开界面是获取信息(第三赛季未到时无数据，后续打开生成奖励物品)
message CSDaoChang100WheelReq { //project game  //RouteRule game
}
message SCDaoChang100WheelAck {
    int32 error                                 = 1; //错误码
}
//刷新转盘道具(未开启本轮时操作)
message CSDaoChang100WheelRefreshReq {  //project game  //RouteRule game
}
message SCDaoChang100WheelRefreshAck {
    int32 error                                 = 1; //错误码
}
//开启本轮转盘(开始获取奖励)
message CSDaoChang100WheelOpenRewardReq {   //project game  //RouteRule game
}
message SCDaoChang100WheelOpenRewardAck {
    int32 error                                 = 1; //错误码
}
//转一次/转本轮(获取所有奖励)
message CSDaoChang100WheelRewardReq {   //project game  //RouteRule game
    bool reward_all                             = 1;//false:转一次  true:获取所有奖励
}
message SCDaoChang100WheelRewardAck {
    int32 error                                 = 1; //错误码
    bool reward_all                             = 2; //转一次/转本轮
    repeated WheelRewardItemInfo reward_list    = 3; //奖励
}
//关闭本轮转盘
message CSDaoChang100WheelCloseRewardReq {  //project game  //RouteRule game
}
message SCDaoChang100WheelCloseRewardAck {
    int32 error                                 = 1; //错误码
}
//获取转盘日志
message CSDaoChang100WheelLogReq {  //project game|db  //RouteRule game
}
message SCDaoChang100WheelLogAck {  //project game
    repeated WheelLogData log_list                  = 1;
}
message SCDaoChang100WheelLogNtf {  //project game
    repeated WheelLogData log_list                  = 1;
}

message SCCompetitionStarInfoNtf  {
    int32 cur_score                             = 1; //当前积分
    int32 next_final                            = 2; //高一档最后一名
    int32 before_first                          = 3; //低一档第一名
}

message CSCompetitionStarInfoReq {   //project game  //RouteRule game
}
message SCCompetitionStarInfoAck {
    int32 error                                 = 1; //错误码
    repeated int32   stars                      = 2; //当前拥有的星星
}

//占卜一次
message CSCompetitionStarDivineReq {   //project game  //RouteRule game
    bool use_ticket                             = 1;
}
message SCCompetitionStarDivineAck {
    int32 error                                 = 1; //错误码
    repeated int32   stars                      = 2; //当前拥有的星星
    int32 star                                  = 3; //本次抽到的星星
    bool light                                  = 4; //true点亮， false灭掉
}

//领奖/关闭本轮占卜
message CSCompetitionStarCloseRewardReq {  //project game  //RouteRule game
}
message SCCompetitionStarCloseRewardAck {
    int32 error                                 = 1; //错误码
    repeated int32   stars                      = 2; //当前拥有的星星，重置
    repeated KeyValueType reward_list           = 3; //奖励列表
}

//累计在线奖励获取
message CSAccOnlineRewardReq {  //project game|db  //RouteRule game
}
message SCAccOnlineRewardAck {
    int32 error                                 = 1; //错误码
    repeated KeyValueType  reward_list          = 3; //奖励内容
}


//偶像季 主动投票
message CSCompetitionOnVoteReq {    //project game  //RouteRule game
	int32 ticket_count                          = 1; //票数
	uint64 uid                                  = 2; //投票目标
}
message SCCompetitionOnVoteAck {
	int32 error                                 = 1; //错误码
	uint64 uid                                  = 2; //投票目标
	int32 total_count                           = 3; //uid总票数
	//前三名的票数
	repeated FansRankData vote_list             = 4; //前三名数据
    repeated PlayerShowData detail              = 5; //详细信息 
	FansRankData vote_target					= 6; //投票目标
    int32 ticket_count                          = 7; //本次投票数量
    repeated KeyValueType64 reward_data         = 8; //key uid， value 分数 value2表示领奖数据(value2按位取值)
}

//偶像季 请求自己的粉丝榜
message CSCompetitionSelfFansInfoReq {  //project game  //RouteRule game

}
message SCCompetitionSelfFansInfoAck {
    int32 error                                 = 1; //错误码
	repeated FansVoteData   fan_list            = 2; //粉丝投我的数据（Key 粉丝ID， value 票数）(策划只需要，固定前十名)
}

//偶像季 得票排行榜单
message CSCompetitionVoteRankReq {  //project game  //RouteRule game
	int32 page                                  = 1;
}
message SCCompetitionVoteRankAck {
	int32 error                                 = 1; //错误码
	int32 page                                  = 2;
	repeated FansRankData rank_data             = 3; //排行榜
    bool is_end                                 = 4; //是否结束
}

//偶像季 粉丝奖励榜
message CSCompetitionFansRewardRankReq {    //project game  //RouteRule game
	int32 page                                  = 1; //应援主角
}
message SCCompetitionFansRewardRankAck {
	int32 error                                 = 1; //错误码
	int32 page                                  = 2; //应援主角
	repeated FansBoxData data_list              = 3; //粉丝奖励榜列表
	repeated KeyValueType64 reward_data         = 4; //key uid， value 分数 value2表示领奖数据(value2按位取值)
    bool is_end                                 = 5; //是否结束
}

//偶像季 粉丝领奖
message CSCompetitionFansGetRewardReq { //project game  //RouteRule game
	uint64 uid                                  = 1; //应援主角
	int32 reward_level                          = 2; //奖励等级
}
message SCCompetitionFansGetRewardAck {
	int32 error                                 = 1; //错误码
	uint64 uid                                  = 2; //应援主角
	int32 reward_level                          = 3; //奖励等级
	repeated KeyValueType reward_list           = 4; //
    int32 reward_flag                           = 5; //领奖标记
}

//偶像季  请求每日奖励
message CSCompetitionFansDayRewardReq {    //project game  //RouteRule game
    int32 id                                    = 1; //领取ID
}

message SCCompetitionFansDayRewardAck {    
    int32 error                                 = 1; //错误码
    int32 id                                    = 2; //领取ID
}

//偶像季  请求玩家票数排行榜
message CSCompetitionGetPlayerVoteRankReq {    //project game  //RouteRule game
    uint64 uid                                    = 1; //领取ID
}

message SCCompetitionGetPlayerVoteRankAck {    
    int32 error                                 = 1; //错误码
    FansRankData idol_rank_data                 = 2; //排行榜
}

/////////////////////////////////////////////////////////GM操作
message CSGMCommandReq {    //project game   //RouteRule game
    string      gm_cmd          = 1;//gm命令
    uint32      gm_param1       = 2;
    uint32      gm_param2       = 3;
    repeated uint32   gm_param_list   = 4;
}
message SCGMCommandAck {
    string      gm_cmd          = 1;//gm命令
}

//vip变动通知
message SCVipChangeNtf {
    int32 vip_level                 = 1;    //vip等级
    int32 vip_exp                   = 2;    //vip总经验
}

//抽卡
message CSDrawCardReq { //project game   //RouteRule game
    int32 draw_type                  = 1;    //1:宠物抽卡， 2：卡片抽卡，
    int32 draw_count                 = 2;    //抽卡类型1：抽1次，5：抽五次
}

message DrawItem {
    int32 item_id                   = 1;    //道具Id
    int32 item_num                  = 2;    //道具数量
    bool  is_new                    = 3;    //是否新获得
}

message SCDrawCardAck {
    int32 error                             = 1;    //错误码
    int32 draw_type                         = 2;    //1:宠物抽卡， 2：卡片抽卡，
    int32 draw_count                        = 3;    //抽卡类型1：抽1次，5：抽五次
    repeated DrawItem           item_list   = 4;    //抽取的奖励列表
    repeated DrawItem           extra_item  = 5;    //保底奖励
    int32 draw_times                        = 6;    //draw_type对应的抽取次数
    int32 add_point                         = 7;    //增加的保底点数
}

//商店
message RuneShopItem {
    int32 goods_id                  = 1;   //商品ID
    int64 end_time                  = 2;   //商品结束时间（限时商店使用）
    int32 buy_nums                  = 3;   //可购买数量
    bool  buy_limit                 = 4;   //是否限购
    bool  first_buy                 = 5;   //是否首次购买
    float price                     = 6;   //价格
}

//卢恩商店信息请求
message CSRuneShopInfoReq { //project game   //RouteRule game
    int32 shop_type                 = 1;    //商店类型
    int32 sub_shop                  = 2;    //商店子类型
}

message SCRuneShopInfoAck {
    int32 shop_type                     = 1;    //商店类型
    int32 sub_shop                      = 2;    //商店子类型
    repeated RuneShopItem goods_list    = 3;    //商店道具类型
    int64 end_time                      = 4;    //礼包商店截止时间（根据子类型）
}

//购买完成后，通知客户端购买后的商品信息
message SCRuneShopBuyItemNtf {
    int32 error                       = 1;   //错误码
    int32 shop_type                   = 2;   //商店类型
    int32 sub_shop                    = 3;   //商店子类型
    RuneShopItem shop_item            = 4;   //商店商品信息
}

//卢恩商店红点信息
message SCRuneFreeRedChangeInfoNtf {
    repeated KeyValueType    rune_red       = 1;    //Key:ShopType,Value:SubShop
    repeated int32           limit_red      = 2;    //限时礼包商店，售卖物品
}

//经验变化推送客户端
message SCExploreExpChangeNtf {
    int32 total_exp                     = 1;        // 总经验
    int32 MissionExp                    = 2;        // 经验
    int32 level                         = 3;        // 等级
}

//请求探索功能数据
message CSExploreInfoReq {  //project game    //RouteRule game

}

message SCExploreInfoAck {
    int32 total_exp                     = 1;        // 总经验
    int32 level                         = 2;        // 等级
    uint64 startTime                    = 3;        // 开始时间
    uint64 endTime                      = 4;        // 结束时间
    uint64 nextStartTime                = 5;        // 下一场开启时间
    int32 missionExp 		                = 6;        // 活跃度经验
    int32 curRoune                      = 7;        // 当前轮次
    bool  bUnlock                       = 8;        // 是否解锁
    bool  fullAward                     = 9;        // 满级已领取奖励
    repeated KeyValueType draw_rewar    = 10;        //key，等级，value：按位取，第一位表示普通奖励，第二位表示高级奖励
}

//满级之后奖励领取
message CSExploreExtraRewardReq {        //project game    //RouteRule game

}

message SCExploreExtraRewardAck {
    int32 error                                                                = 1;
    int32 total_exp                                                        = 2; //当前总经验
    int32 mission_exp                               =3;
    repeated KeyValueType award_item    = 4;
}

//普通等级奖励领取
message CSExploreRewardReq {        //project game    //RouteRule game
    int32 level                                                                = 1;        //领取等级
    int32 reward_type                                                = 2;        //领取类型：1表示普通奖励，2高级奖励
}

message SCExploreRewardAck {
    int32 error                                                                = 1;
    int32 type                      =2;
    int32 level                     =3;
    repeated KeyValueType award_item    = 4;
    repeated KeyValueType draw_rewar    = 5;        //key，等级，value：按位取，第一位表示普通奖励，第二位表示高级奖励
}
/////////////////////////////////////////////////////////
message SCPayForGoodsNtf {
    int32 goods_type                  = 1;   //商店类型
    int32 goods_id                    = 2;   //商品ID
    int32 goods_num                   = 3;   //商品数量
    repeated KeyValueType   item_list = 4;   //购买获得道具
    uint64 cp_order_id                = 5;   //订单号
}

//测试发送所有玩家位置信息AOI
message SCGMSyncAllPlayerNtf{
    repeated Player     players          = 1;
}

message SCWebGMNoticeNtf {
    GMNoticeInfo notice_info            = 1;
}

//客户端加速外挂
message CSAntiCheatReq {    //project game   //RouteRule game
    int32   cheat_type                  = 1; 
}
//
message SCAntiCheatAck {
    int32 error                       = 1;   //错误码
}
//问卷奖励获取
message CSQuestionRewardReq {   //project game   //RouteRule game
}
//问卷奖励获取 ack回应
message SCQuestionRewardAck {
    int32 error                             = 1;   //错误码
    repeated KeyValueType reward_item_list  = 2; //奖励物品
}

//当前累计在线奖励获取
message CSOnlineTimeRewardReq { //project game   //RouteRule game

}
message SCOnlineTimeRewardAck {
    int32 error                             = 1;   //错误码
    repeated KeyValueType reward_item_list  = 2;   //奖励物品
}
message SCOnlineTimeRewardNtf {
    int32      total_online_time     = 1; //当前累计在线时间(隔天重置)s
    uint64      online_stamp         = 2; //上线时的时间戳 ms
    int32       online_reward_id     = 3; //奖励id（配置表中的唯一ID）
}


///////////////////////信物相关///////////////////////
message CSOnlineGetKeepSakeReq {    //project game   //RouteRule game

}

message SCOnlineGetKeepSakeAck {
    RoleKeepSake role_keep_sake                 = 1;
}

message CSKeepSakeRankReq{    //project game|rank    //RouteRule game
    int32    keep_sake_id                       = 1;
}
message SCKeepSakeRankAck{    //project game
    int32    error                         = 1;
    int32    keep_sake_id                  = 2;
    CommonPlayerBriefInfo player_info      = 3;
    uint64 achievement_time                = 4;
}

message CSKeepSakeLevelUpReq {  //project game   //RouteRule game
    int32    keep_sake_id                  = 1;
}

message SCKeepSakeLevelUpAck {
    int32    error                         = 1;
}

message SCKeepSakeChangeNtf {
    KeepSake keep_sake                      = 1;
    repeated KeyValueType materials         = 2;
}

/////////////////////////////////////////////////////////跨服协议处理
/////////////////////////////////////////////////////////跨服远航试炼
message SCCrossYuanHangTrialDataNtf {
    RoleYuanHangTrial yuanhangtrial_data            = 1; //返回远航试炼数据(个人)
}
//刷新远航试炼品质
message CSCrossYuanHangTrialRefreshTrialTypeReq {   //project game   //RouteRule game
    bool force                                      = 1; //是否直接升级为顶级
}
message SCCrossYuanHangTrialRefreshTrialTypeAck {
    int32 error                                     = 1; //错误码
}
//发起远航试炼
message CSCrossYuanHangTrialReq { //project game   //RouteRule game
}
message SCCrossYuanHangTrialAck {
    int32 error                                     = 1; //错误码
    YuanHangTrialData trial_data                    = 2; //返回远航试炼数据(个人)
}
//获取远航试炼奖励(试炼结束奖励)
message CSCrossYuanHangTrialRewardReq { //project game   //RouteRule game
}
message SCCrossYuanHangTrialRewardAck {
    int32 error                                     = 1; //错误码
    repeated KeyValueType  reward_list              = 2; //奖励内容
}
//远航试炼挑战
message CSCrossYuanHangTrialChallengeReq {  //project game   //RouteRule game
    uint64 challenge_uid                            = 1;
    uint64 challenge_uid_end_time                   = 2;
}
message SCCrossYuanHangTrialChallengeAck {
    int32 error                                     = 1; //错误码
    uint64 challenge_uid                            = 2;
    uint64 challenge_uid_end_time                   = 3;
    FightRoleInfo fight_info                        = 5; //被挑战玩家战斗数据
}
//挑战结果通知
message CSCrossYuanHangTrialChallengeResultReq {    //project game   //RouteRule game
    uint64 challenge_uid                            = 1;
    uint64 challenge_uid_end_time                   = 2;
    int32 fight_time                                = 3; //战斗持续时间(判断合法性)
    bool win                                        = 4; //true胜利 false失败
}
message SCCrossYuanHangTrialChallengeResultAck {
    int32 error                                     = 1; //错误码
    repeated KeyValueType  reward_list              = 2; //奖励内容
    int32 old_score                                 = 3; //获得的积分
    int32 new_score                                 = 4; //累加后的当前积分
}
//获取远航试炼排行榜
message CSCrossYuanHangTrialRankListReq {   //project game   //RouteRule game
    int32 start_idx                                 = 1;
}
message SCCrossYuanHangTrialRankListAck {
    int32       error                               = 1; //错误码
    int32       start_idx                           = 2;
    uint32      self_rank                           = 3; //自身排名
    uint64      self_score                          = 4; //自身积分
    uint32      total_rank                          = 5; //当前参加排名的人数
    repeated CommonRankInfo rank_list               = 6;
}
//获取远航界面可视列表
//每次打开界面，或者隔一段时间发送一次，服务器会返回这段时间内变化的数据
message CSCrossYuanHangTrialViewListReq {   //project game   //RouteRule game
    bool notify                                     = 1; //true表示通知服务器需要更新，false是正常的获取界面数据
}
message SCCrossYuanHangTrialViewListAck {
    int32 error                                         = 1; //错误码
    repeated YuanHangTrialData trial_view_list      = 2; //界面上可视列表
}
message CSCrossYuanHangTrialViewListOutReq {    //project game   //RouteRule game
}
message SCCrossYuanHangTrialViewListNtf {
    repeated YuanHangTrialData trial_view_list      = 1; //界面上可视列表
}
//查询飞艇信息
message CSCrossYuanHangTrialInfoReq {   //project game   //RouteRule game
    uint64 trial_uid                                = 1;
    uint64 trial_end_time                           = 2;
}
message SCCrossYuanHangTrialInfoAck {
    int32 error                                     = 1;
    YuanHangTrialData trial_data                    = 2;
    string nick_name                                = 3;
}
//日志获取
message CSCrossYuanHangTrialLogReq {    //project game   //RouteRule game
    uint64 log_time                                 = 1;
}
message SCCrossYuanHangTrialLogAck {
    int32 error                                     = 1; //错误码
    repeated YuanHangTrialLogData log_list          = 2; //挑战被挑战日志记录
    bool is_end                                     = 3;
}

////巅峰爬塔
//获取巅峰爬塔对战数据
//获取挑战列表
message CSCrossTopTowerFightListReq {   //project game   //RouteRule game
}
message SCCrossTopTowerFightListAck {
    int32 error                                     = 1; //错误码
    RoleCrossTopTower toptower_data                 = 2; //变更层数数据(不一定是所有数据，切记！！！)
}
//发起挑战，判断合法性
message CSCrossTopTowerChallengeReq {   //project game   //RouteRule game
    int32 fight_idx                                 = 1; //挑战对手层数[1-10]
}
message SCCrossTopTowerChallengeAck {
    int32 error                                     = 1; //错误码
    TopTowerFightRoleInfo fight_info                = 2; //该位置玩家战斗信息
}
//获取挑战者view信息
message CSCrossTopTowerChallengeViewInfoReq {   //project game   //RouteRule game
    int32 fight_idx                                 = 1; //挑战对手层数[1-10]
}
message SCCrossTopTowerChallengeViewInfoAck {
    int32 error                                     = 1; //错误码
    TopTowerFightRoleInfo fight_info                = 2; //该位置玩家战斗信息
}
//战斗结果通知
message CSCrossTopTowerChallengeResultReq { //project game   //RouteRule game
    bool is_win                                     = 1;
    int32 fight_idx                                 = 2; //挑战对手层数[1-10]
}
message SCCrossTopTowerChallengeResultAck {
    int32 error                                     = 1; //错误码
    repeated KeyValueType  reward_list              = 2; //奖励内容
    TopTowerFightRoleInfo fight_info                = 3; //对应层数数据变更通知
}
//买路操作(直接胜利)
message CSCrossTopTowerForceWinReq {    //project game   //RouteRule game
    int32 fight_idx                                 = 1; //挑战对手层数[1-10]
}
message SCCrossTopTowerForceWinAck {
    int32 error                                     = 1; //错误码
    repeated KeyValueType  reward_list              = 2; //奖励内容
    TopTowerFightRoleInfo fight_info                = 3; //对应层数数据变更通知
}
//获取买路排行榜
message CSCrossTopTowerForceWinRankListReq {    //project game   //RouteRule game
    uint64 uid                                      = 1;
    int32 start_idx                                 = 2;
}
message SCCrossTopTowerForceWinRankListAck {
    int32 start_idx                                 = 1;
    uint32      self_rank                           = 2; //自身排名
    uint64      self_score                          = 3; //自身积分
    uint32      total_rank                          = 4; //当前参加排名的人数
    repeated CommonRankInfo rank_list               = 5;
}

////全局跨服功能
//获取服务器列表信息(状态)
//server_type (31教堂地图)
message CSGCrossGetServerStateReq { //project game   //RouteRule game
    int32 server_type                               = 1; //服务器类型id(node中的type)
}
message SCGCrossGetServerStateAck {
    int32 error                                     = 1; //错误码
    int32 server_type                               = 2; //服务器类型id(node中的type)
    repeated ServerStateInfo server_list            = 3; //多个gcrossmap时就有多个
}
//角色进入地图
message CSGCrossPlayerEnterMapReq{ //project game //RouteRule game
    int32 map_type                                  = 1; //不同系统玩法
    int32 line_num                                  = 2; //选择的线路(1线 2线...)
    Vector3 pos                                     = 3;
    Vector3 dir                                     = 4;
}
message SCGCrossPlayerEnterMapAck{
    int32 error                                     = 1; //错误码
    int32 line_num                                  = 2;
    UnitPosAndDir self_info                         = 3;
}
//离开地图
message CSGCrossPlayerLeaveMapReq { //project game //RouteRule game
    Vector3 pos                                     = 1; //玩家离开时的位置
}
//客户端1s内发送的位置同步包(视野同步)
message CSGCrossPlayerMapSyncPosReq {   //project game //RouteRule game
    Vector3 pos                                    = 1; //位置
    Vector3 dir                                    = 2; //朝向
    int32 cur_space_id                             = 3; //当前所在场景ID
    int32 is_on_ground                             = 4; //是否在地面上
}
//位置同步消息(用来做视野同步)
message SCGCrossPlayerMapSyncPosNtf {
    repeated UnitPosAndDir     unit_info_list          = 1;
}
//客户端模拟使用
message CSGCrossPlayerMapSyncParamReq { //project game //RouteRule game
    Vector3 pos                                    = 1; //位置
    int32 param_id                                 = 2; //通用参数标签
}
message SCGCrossPlayerMapSyncParamNtf{
    repeated UnitPosAndDir     unit_info_list          = 1;
}
//通知玩家当前有其他玩家进入自己视野
message SCGCrossPlayerEnterNtf {
    repeated UnitPosAndDir     unit_info_list          = 1;
}
message SCGCrossPlayerLeaveNtf {
    repeated UnitPosAndDir     unit_info_list          = 1;
}
//获取其他玩家角色信息，AOI地图显示使用(注意:每次发送不超过10个玩家，超过10个后服务器不会返回,做保护处理)
message CSGCrossPlayerShowInfoReq {  //project game //RouteRule game
    repeated uint64 player_list                        = 1;//拉取角色信息列表
}
message SCGCrossPlayerShowInfoNtf{
    repeated PlayerShowInfo show_info_list             = 1; //玩家角色信息
}

/////////////////////////////////////////////////////////

//客户端打点信息上报
message ClientParamInfo {
    string device_model                   = 1; //设备型号
    int32 device_height                   = 2; //屏幕高度
    int32 device_width                    = 3; //屏幕宽度
    string os_name                        = 4; //操作系统
    string os_ver                         = 5; //操作系统版本
    string mac_addr                       = 6; //设备mac地址
    string udid                           = 7; //设备唯一标示符
    string isp                            = 8; //网络运营商
    string network                        = 9; //网络连接
    string app_channel                    = 10; //运营渠道
    string app_ver                        = 11; //客户端版本号
    string trans_id                        = 12; //transid
    string unisdk_deviceid                = 13; //unisdk_deviceid
    int32 is_emulator                     = 14; //是否模拟
    int32 is_root                         = 15; //是否root
    string account_id                     = 16;
    string old_accountid                  = 17;
    string IMEI                           = 18; //移动设备国际识别码
    string country_code                   = 19; //国家代码
    string enter_sn                       = 20; //enter_sn
    string oaid                           = 21; //设备OAID
    string engine_ver                     = 22; //引擎版本
}
message CSClientParamNtf {  //project game   //RouteRule game
    ClientParamInfo client_info = 1;
}

//获取英雄属性/宠物属性
message ActorAttrType {
    bool is_hero_pet                      = 1; //true=hero false=pet
    uint32 actor_id                       = 2; //生成的动态ID
    repeated KeyValueFloat32   attr_list  = 3;
}
message CSActorAttrGetReq { //project game   //RouteRule game
    bool is_all_battle                    = 1;
    repeated ActorAttrType  actor_list    = 2; //结构中的attr_list不用
}
message SCActorAttrGetAck {
    int32    error                         = 1;
    repeated ActorAttrType actor_attr_list = 2;
}
message SCActorAttrGetNtf {
    repeated ActorAttrType actor_attr_list = 1;
}

// 高级技能经验兑换
message CSConverSkillExpReq{   //project game //RouteRule game
    int32 cnt = 1;              // 兑换数量
}

message SCConverSkillExpAck{
    int32    error                         = 1;
}

// 称号状态更新
message SCHeadUpdateNtf{
    repeated HeadData head = 1;
}

// 称号操作
message CSHeadOperateReq{ //project game //RouteRule game
    int32 operateType = 1;   // 1.激活  2.佩戴 3.卸下
    int32 headId = 2;
}

message SCHeadOperateAck{
    int32 operateType = 1;
    int32 headId = 2;
    int32 error  = 3;
}

// 请求称号
message CSHeadDataReq{ //project game //RouteRule game
}

message SCHeadDataAck{
}

// 使用许愿宝箱
message CSWishBoxUseReq{    //project game //RouteRule game
    uint64 item_id = 1;
    int32 select_item = 2;
}

message SCWishBoxUseAck{
    int32 error  = 1;
    int32 index = 2;        // 宝箱位置
}

// 解锁许愿宝箱槽位
message CSWishUnlockSlotReq {  //project game //RouteRule game

}

message SCWishUnlockSlotAck {
    int32 error  = 1;
}

// 许愿箱加速 + 领奖
message CSWishSlotReq {     //project game //RouteRule game
    int32 index = 1;
}

message SCWishSlotReqAck {
    serverproto.KeyValueType award_item = 1;          // 许愿物品
    serverproto.KeyValueType lucky_item = 2;          // 暴击物品
    int32 error  = 3;
}

message SCUpdateWishSlotNtf{
    repeated WishSlot slots = 1;
}

//上线合服通知
message SCCombineServerOnlineNtf {
    int32 error             = 1;
    uint64 combine_time	    = 2;	//毫秒//合服时间
}

// 合服公告内容请求
message CSCombineServerInfoReq {  //project game //RouteRule game

}

message SCCombineServerInfoAck {
    int32 error             = 1;
	uint64 combine_time	    = 2;	//毫秒//合服时间
	string notice		    = 3;	//合服公告
}

/////////////////////////////////////////////////////////
//bt 服务器使用
// 通用错误通知协议
message SCErrorMessageNtf {
    int32 error             = 1; //错误码
}
// 试炼之塔试炼馈赠(每天获取一次奖励)
message CSClimbingTowerDayRewardReq {   //project game //RouteRule game
}
message SCClimbingTowerDayRewardAck {
    int32 error                                     = 1;
    repeated KeyValueType  reward_list              = 2; // 奖励内容
    uint64 next_day_reward_time                     = 3; // 下次可领取奖励时间戳
}
// 波利商城
message CSBoliShopLevelUpReq {  //project game //RouteRule game
    int32 num                                       = 1; // 消耗RO币数量
}
message SCBoliShopLevelUpAck {
    int32 error                                     = 1;
    ShopData    shop_data                           = 2; // 商店信息
}
// 波利商城选择特权礼包
message CSBoliShopRewardReq {   //project game //RouteRule game
    int32 reward_level                              = 1; // 获取奖励的等级
    int32 idx                                       = 2; //[1,3]
}
message SCBoliShopRewardAck {
    int32 error                                     = 1;
    repeated KeyValueType  reward_list              = 2; //奖励内容
}
// 波利商城购买
message CSBoliShopBuyReq {  //project game //RouteRule game
    int32 goods_id                                  = 1;
    int32 goods_num                                 = 2;
}
message SCBoliShopBuyAck {
   int32 error                                     = 1;
   repeated KeyValueType  item_list                = 2; // 商品信息
   int32 cur_num                                   = 3;
   uint64 cur_buy_time                             = 4;
   int32 goods_id                                  = 5;
}
// 获取商店信息
// bt服务器获取购买信息
// 100充值钱包商店
// RO币礼包商城
message CSBTShopInfoReq {   //project game   //RouteRule game
   int32 shop_type                 = 1;    //商店类型
   int32 sub_shop                  = 2;    //商店子类型
}
message SCBTShopInfoAck {
    int32 shop_type                     = 1;    //商店类型
    int32 sub_shop                      = 2;    //商店子类型
    repeated RuneShopItem goods_list    = 3;    //商店道具类型
    int64 end_time                      = 4;    //礼包商店截止时间（根据子类型）
}
// 获取波利商店信息
message CSBoliShopInfoReq { //project game   //RouteRule game
}
message SCBoliShopInfoAck {
    int32       error                               = 1;
    ShopData    shop_data                           = 2; // 商店信息
}
message SCBoliDataChangeNtf {
    BTBoliData boli_data                            = 3;
}

//RO币礼包购买
message CSBTRoCoinShopItemBuyReq {  //project game   //RouteRule game
    int32 goods_id                                      = 1;
    int32 goods_num                                     = 2;
}
message SCBTRoCoinShopItemBuyAck {
    int32 error                                         = 1; //错误码
    int32 goods_id                                      = 2;
    repeated KeyValueType reward_item_list              = 3; //奖励物品
    RuneShopItem shop_item                              = 4;
    int32 goods_type                                    = 5;
    int32 sub_type                                      = 6;
}
////超值首充&百元大礼包
message SCBTFirstRechargeNtf {
    uint64 first_recharge_time                 = 1;
    uint32 first_recharge_reward_state         = 2; //首充礼包档位奖励获取状态(位处理)
}
//超值首充奖励获取
message CSBTFirstRechargeRewardReq {    //project game   //RouteRule game
    int32 reward_idx                           = 1; //[1,3]
}
message SCBTFirstRechargeRewardAck {
    int32 error                                = 1; //错误码
    repeated KeyValueType reward_item_list     = 2; //奖励物品
    int32 reward_idx                           = 3; //[1,3]
}
//百元大礼包领取奖励
message SCBTRecharge100Ntf {
    uint64 recharge100_time                    = 1; //充值解锁百元大礼包的时间戳
    int32 recharge100_reward_day               = 2; //可领取哪几天的奖励(1表示可领取第一天奖励，2表示可领取前两天奖励)
    int32 recharge100_reward_state             = 3; //已经领取到那一天的奖励(1表示第一天已经领取，2表示领取了1-2天的奖励)
}
message CSBTRecharge100RewardReq {  //project game   //RouteRule game
}
message SCBTRecharge100RewardAck {
    int32 error                                = 1; //错误码
    repeated KeyValueType reward_item_list     = 2; //奖励物品
}