RoServer/RO_Server_Trunk-branch_0.1.39/roserver/game/msg/role_msg.go

package msg

import (
	"crypto/md5"
	"encoding/hex"
	"rocommon"
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/baseserver/set"
	model2 "roserver/game/model"
	"roserver/serverproto"
	"strconv"
	"unicode/utf8"
)

func init() {
	//获取名字
	serverproto.Handle_GAME_CSNameReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSNameReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSNameReq msg=%v", role.GetUUid(), msg)

		if len(msg.Name) <= 0 {
			ackMsg := &serverproto.SCNameAck{
				Error: int32(serverproto.ErrorCode_ERROR_NAME_EMPTY),
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		nickName := role.(*model2.Role).GetRoleBase().GetRoleName()
		globalCfg, ok := serverproto.GlobalCfgLoader[int32(serverproto.GlobalType_Global_Max_Name_Len)]
		if !ok || globalCfg == nil {
			ackMsg := &serverproto.SCNameAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
				Name:  msg.Name,
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		nameLen := utf8.RuneCountInString(msg.Name)
		if nameLen <= 0 || nameLen > int(globalCfg.IVal) || nickName == msg.Name {
			ackMsg := &serverproto.SCNameAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		nameMsg := &serverproto.SSNameReq{
			Name: msg.Name,
			Zone: int32(service.GetServiceConfig().Node.Zone),
		}
		role.(*model2.Role).SendDb(nameMsg)
	})
	//来自db的消息
	serverproto.Handle_GAME_SSNameNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSNameNtf)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSNameNtf msg=%v", role.GetUUid(), msg)

		if msg.Type == 0 { //创号取名流程
			if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
				role.(*model2.Role).GetRoleBase().Rename(msg.Name)
			}

			ackMsg := &serverproto.SCNameAck{
				Error: msg.Error,
				Name:  msg.Name,
			}
			role.ReplayGate(ackMsg, true)
		} else if msg.Type == 1 { //改名卡改名流程
			if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
				role.(model2.RoleLogicOuter).ChangeRoleName(msg.Name)
			} else {
				ackMsg := &serverproto.SCRenameAck{
					Error: msg.Error,
					Name:  msg.Name,
				}
				role.ReplayGate(ackMsg, true)
			}
		}
	})

	//获取服务器时间ms
	serverproto.Handle_GAME_CSGetServerTimeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		ackMsg := &serverproto.SCGetServerTimeAck{
			ServerTime: util.GetTimeMilliseconds(),
		}
		role.ReplayGate(ackMsg, true)
	})

	//客户端游戏参数设置
	serverproto.Handle_GAME_CSClientParamNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClientParamNtf)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive CSClientParamNtf msg=%v", role.GetUUid(), msg)
		role.SetClientParam(msg.ClientInfo)
	})

	//设置新手引导
	serverproto.Handle_GAME_CSRoleGuideNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRoleGuideNtf)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSRoleGuideNtf msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SetRoleGuide(msg.GuideId)
	})

	//角色设置属性点
	serverproto.Handle_GAME_CSAddAttrPointReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSAddAttrPointReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSAddAttrPointReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).AddAttrPoint(msg.HeroId, msg.AttrList)
	})

	//客户端MD5帮忙编译
	serverproto.Handle_GAME_CSMd5GetReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSMd5GetReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSMd5GetReq msg=%v", role.GetUUid(), msg)
		// 计算 MD5
		hash := md5.Sum([]byte(msg.Md5))
		ack := &serverproto.SCMd5GetAck{
			Md5: hex.EncodeToString(hash[:]),
		}
		role.ReplayGate(ack, true)
	})
	//设置剧情
	serverproto.Handle_GAME_CSRoleStoryReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRoleStoryReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSRoleStoryReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SetRoleStory(msg.StoryId)
	})
	serverproto.Handle_GAME_CSNewMapCartoonReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSNewMapCartoonReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSNewMapCartoonReq msg=%v", role.GetUUid(), msg)
		if msg.MapCart != nil {
			role.(model2.RoleLogicOuter).SetMapCartoon(msg.MapCart.Key, msg.MapCart.Value)
		}
	})

	//角色重置属性点
	serverproto.Handle_GAME_CSResetAttrPointReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSResetAttrPointReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSResetAttrPointReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).ResetAttrPoint(msg.HeroId)
	})

	//使用 潜力果实增加素质点
	serverproto.Handle_GAME_CSAddQualityPointReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSAddQualityPointReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSAddQualityPointReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).OnAddQualityPoint(msg)
	})

	//激活头像
	serverproto.Handle_GAME_CSActiveHeadReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActiveHeadReq)

		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActiveHeadReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActiveHead(msg.HeadId)
	})

	//设置头像
	serverproto.Handle_GAME_CSSetHeadIdReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSetHeadIdReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSetHeadIdReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SetRoleHeadPic(msg.HeadId)
	})

	//请求头像相关信息
	serverproto.Handle_GAME_CSHeadInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeadInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeadInfoReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).HeadInfoReq()
	})

	//头像框道具使用
	serverproto.Handle_GAME_CSUseHeadFrameItemReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSUseHeadFrameItemReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSUseHeadFrameItemReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).UseHeadFrameItem(msg.ItemId, msg.ItemNum)
	})

	//请求头像相关信息
	serverproto.Handle_GAME_CSChangeHeadFrameReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSChangeHeadFrameReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSChangeHeadFrameReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SetRoleHeadFrameId(msg.HeadFrameId)
	})

	//请求头像相关信息
	serverproto.Handle_GAME_CSHeadFrameInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeadFrameInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeadFrameInfoReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).GetRoleHeadFrameInfo()
	})

	//改名
	serverproto.Handle_GAME_CSRenameReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRenameReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSRenameReq msg=%v", role.GetUUid(), msg)

		nameLen := utf8.RuneCountInString(msg.Name)
		globalCfg, ok := serverproto.GlobalCfgLoader[int32(serverproto.GlobalType_Global_Max_Name_Len)]
		if !ok || globalCfg == nil {
			ackMsg := &serverproto.SCRenameAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
				Name:  msg.Name,
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		if nameLen <= 0 || nameLen > int(globalCfg.IVal) || msg.Name == role.(*model2.Role).GetRoleBase().GetRoleName() {
			ackMsg := &serverproto.SCRenameAck{
				Error: int32(serverproto.ErrorCode_ERROR_RENAME_NAME_LEN_ERROR),
				Name:  msg.Name,
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		//屏蔽字过滤
		if model2.SensitiveUtil.IsMatch(msg.Name) {
			ackMsg := &serverproto.SCRenameAck{
				Error: int32(serverproto.ErrorCode_ERROR_RENAME_NAME_INVALID),
				Name:  msg.Name,
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		bRet := role.(*model2.Role).GetRoleBase().ChangeNameItemEnough(msg.Name, false)
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCRenameAck{
				Error: int32(bRet),
				Name:  msg.Name,
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		//todo...
		//	role.(model2.RoleLogicOuter).ChangeRoleName(msg.Name)
		nameMsg := &serverproto.SSNameReq{
			OldName: role.GetNickName(),
			Name:    msg.Name,
			Zone:    int32(service.GetServiceConfig().Node.Zone),
			Type:    1,
		}
		role.(*model2.Role).SendDb(nameMsg)
	})

	//获取玩家简介信息，显示头像名称相关，不包括详细信息
	serverproto.Handle_GAME_CSGetOtherPlayerBriefInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGetOtherPlayerBriefInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSGetOtherPlayerBriefInfoReq msg=%v", role.GetUUid(), msg)

		ackMsg := &serverproto.SCGetOtherPlayerBriefInfoAck{
			Type: msg.Type,
		}
		if len(msg.PlayerList) > 20 {
			role.ReplayGate(ackMsg, true)
			return
		}

		dbMsg := &serverproto.SSGetRoleBriefInfoReq{
			Type: msg.Type,
		}
		for idx := range msg.PlayerList {
			//公会申请列表，客户端排序，需要一次性下发
			if msg.Type == model2.StateGuildApply {
				dbMsg.PlayerUidList = append(dbMsg.PlayerUidList, msg.PlayerList[idx])
				continue
			}
			tmpRole := model2.RoleMag.GetRoleFromUUid(msg.PlayerList[idx])
			if tmpRole == nil {
				tmpRole = model2.RoleMag.GetRoleFromOffline(msg.PlayerList[idx])
			}
			if tmpRole != nil {
				bf := &serverproto.CommonPlayerBriefInfo{}
				tmpRole.(*model2.Role).GetRoleBriefInfo(bf)
				ackMsg.BriefInfo = append(ackMsg.BriefInfo, bf)
			}

			if tmpRole == nil {
				dbMsg.PlayerUidList = append(dbMsg.PlayerUidList, msg.PlayerList[idx])
			}
		}
		if len(ackMsg.BriefInfo) > 0 {
			role.ReplayGate(ackMsg, true)
		}
		if len(dbMsg.PlayerUidList) > 0 {
			role.(*model2.Role).SendDb(dbMsg)
		}
	})
	//from social 获取玩家在线状态
	serverproto.Handle_GAME_SSGetRoleBriefInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRoleBriefInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSGetRoleBriefInfoAck msg=%v", role.GetUUid(), msg)

		//有该玩家信息并添加到黑名单列表中
		if msg.Type == model2.StateTypeBlack_Add {
			if len(msg.BriefInfo) > 0 {
				role.(*model2.Role).GetRoleSocial().HandlerBlackList(true, msg.BriefInfo[0].Uid, msg.BriefInfo[0])
				msg.Type = model2.StateTypeBlack
			} else {
				ackMsg := serverproto.SCFriendBlackAck{
					Error: int32(serverproto.ErrorCode_ERROR_ROLE_NOT_FOUND),
				}
				role.ReplayGate(ackMsg, true)
				return
			}
		}
		ssMsg := &serverproto.SSOnlineStateReq{
			ProType:  2, //表示好友系统操作
			ListType: msg.Type,
		}
		for idx := 0; idx < len(msg.BriefInfo); idx++ {
			if msg.BriefInfo[idx].Uid > 0 {
				ssMsg.BriefInfoList = append(msg.BriefInfo)
			}
		}
		if len(ssMsg.BriefInfoList) > 0 {
			role.(*model2.Role).SendSocial(ssMsg)
		}
	})

	//查看玩家详细信息
	serverproto.Handle_GAME_CSGetOtherPlayerDetailInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGetOtherPlayerDetailInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSGetOtherPlayerDetailInfoReq msg=%v", role.GetUUid(), msg)

		targetRole := model2.RoleMag.GetRoleFromUUid(msg.TUid)
		if targetRole == nil {
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendSocial(msg)
			return
		}
		ackMsg := &serverproto.SCGetOtherPlayerDetailInfoAck{
			Uid:        msg.Uid,
			Error:      int32(serverproto.ErrorCode_ERROR_OK),
			TargetInfo: &serverproto.ViewRoleInfo{},
		}
		targetRole.(model2.RoleLogicOuter).PackRoleViewInfo(ackMsg.TargetInfo)
		role.ReplayGate(ackMsg, true)
	})

	//来自Social的查询结果，直接推送客户端
	serverproto.Handle_GAME_SCGetOtherPlayerDetailInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGetOtherPlayerDetailInfoAck)
		util.DebugF("receive SCGetOtherPlayerDetailInfoAck msg=%v", msg)
		role := model2.RoleMag.GetRoleFromUUid(msg.Uid)
		if role == nil {
			return
		}
		role.ReplayGate(msg, true)
	})

	//来自social的请求被观察者的信息
	serverproto.Handle_GAME_SSGetViewedTargetInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetViewedTargetInfoReq)
		util.DebugF("receive SSGetViewedTargetInfoReq msg=%v", msg)
		//直接返回被查看角色的数据
		ackMsg := &serverproto.SSGetViewedTargetInfoAck{
			Uid:  msg.Uid,
			TUid: msg.TUid,
			Info: &serverproto.ViewRoleInfo{},
		}

		targetRole := model2.RoleMag.GetRoleFromUUid(msg.TUid)
		if targetRole == nil {
			//发送取social
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
		} else {
			//打包目标数据
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
			targetRole.(model2.RoleLogicOuter).PackRoleViewInfo(ackMsg.Info)
		}
		targetRole.(*model2.Role).SendSocial(ackMsg)
	})

	//////伙伴相关操作
	//培养
	serverproto.Handle_GAME_CSHeroLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroLevelUpReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).HeroLevelUp(msg.HeroId)
	})
	//进阶
	serverproto.Handle_GAME_CSHeroAdvanceReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroAdvanceReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroAdvanceReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).HeroAdvance(msg.HeroId)
	})
	//突破
	serverproto.Handle_GAME_CSHeroStrengthReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroStrengthReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroStrengthReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).HeroStrength(msg.HeroId)
	})
	//上阵
	serverproto.Handle_GAME_CSHeroBattleReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroBattleReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroBattleReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).HeroBattle(msg.HeroId, msg.IsBattle)
	})
	//伙伴碎片合成
	serverproto.Handle_GAME_CSChipComposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSChipComposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSChipComposeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ComposeChip(msg.ConfigId)
	})
	//伙伴碎片分解
	serverproto.Handle_GAME_CSHeroChipDecomposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroChipDecomposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroChipDecomposeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ChipDecompose(msg.ChipList, msg.ChipTypeList)
	})

	//转职
	serverproto.Handle_GAME_CSHeroChangeJobReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroChangeJobReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroChangeJobReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).HeroChangeJob(msg.HeroId, msg.JobId)
	})

	//伙伴战力请求
	serverproto.Handle_GAME_CSHeroFighPowerReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroFighPowerReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroFighPowerReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).FightPowerReq(msg.HeroId)
	})
	//招募
	serverproto.Handle_GAME_CSHeroActiveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroActiveReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroActiveReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).HeroRecruit(msg.HeroId)
	})
	//更换职业(主角/伙伴)
	serverproto.Handle_GAME_CSHeroReplaceJobReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeroReplaceJobReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSHeroReplaceJobReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).HeroReplaceJob(msg.HeroId, msg.JobId)
	})
	//////装备相关
	//装备锻造(合成/锻造)
	serverproto.Handle_GAME_CSEquipForgeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSEquipForgeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSEquipForgingReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).EquipForge(msg.ConfigId, msg.Once, msg.EquipType, msg.SubEquipType)
	})
	//替换/上装备
	serverproto.Handle_GAME_CSEquipUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSEquipUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSEquipUpReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).EquipUp(msg.HeroId, msg.SlotIndex, msg.EquipId)
	})
	//一键卸载装备
	serverproto.Handle_GAME_CSEquipDownReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSEquipDownReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSEquipDownReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).EquipDown(msg.HeroId, msg.SubIndex)
	})
	//一键升级(升级位置上能升级的所有装备)
	serverproto.Handle_GAME_CSEquipLevelUpAllReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSEquipLevelUpAllReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSEquipLevelUpAllReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).EquipLevelUpAll(msg.HeroId)
	})

	//装备槽位升级(装备精炼)
	serverproto.Handle_GAME_CSEquipSlotLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSEquipSlotLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSEquipSlotLevelUpReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).EquipSlotLevelUp(msg.HeroId, msg.SubSlotIndex)
	})

	// 神器佩戴
	serverproto.Handle_GAME_CSSkillEquipUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipUpReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SkillEquipUp(msg.HeroId, msg.SkillEquipId, msg.SlotIndex)
	})

	// 神器卸下
	serverproto.Handle_GAME_CSSkillEquipDownReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipDownReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipDownReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SkillEquipDown(msg.HeroId, msg.SlotIndex)
	})

	// 神器升星
	serverproto.Handle_GAME_CSSkillEquipLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipLevelUpReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SkillEquipStarLevelUp(msg.HeroId, msg.SkillEquipId, msg.SelectCost)
	})

	// 神器转移
	serverproto.Handle_GAME_CSSkillEquipShiftReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipShiftReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipShiftReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SkillEquipShift(msg)
	})

	// 神器槽位升级
	serverproto.Handle_GAME_CSSkillEquipSlotLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipSlotLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipSlotLevelUpReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SkillEquipSlotLevelUp(msg.HeroId, msg.SlotIndex)
	})

	// 神器分解
	serverproto.Handle_GAME_CSSkillEquipDecomposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipDecomposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipDecomposeReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SkillEquipDecompose(msg.SkillEquipId)
	})

	// 神器重铸
	serverproto.Handle_GAME_CSSkillEquipRemadeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipRemadeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipRemadeReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).SkillEquipRemade(msg.SkillEquipId)
	})

	// 神器重铸池子请求
	serverproto.Handle_GAME_CSSkillEquipPoolReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillEquipPoolReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillEquipPoolReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).GetSkillEquipPool()
	})

	//////卡片
	//装备槽位镶嵌卡片
	serverproto.Handle_GAME_CSCardMountReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardMountReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardMountReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CardMount(msg.HeroId, msg.SubSlotIndex, msg.CardSlotIndex, msg.CardId)
	})
	//卡片卸下
	serverproto.Handle_GAME_CSCardDownReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardDownReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardDownReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CardDown(msg.HeroId, msg.SubSlotIndex, msg.CardSlotIndex)
	})
	//卡片一键装备
	serverproto.Handle_GAME_CSCardEquipAllReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardEquipAllReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardEquipAllReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CardMountAll(msg)
	})
	//卡片全部卸下
	serverproto.Handle_GAME_CSCardEquipDownReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardEquipDownReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardEquipDownReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).CardDownAll(msg.HeroId)
	})
	serverproto.Handle_GAME_CSCardUpGradeAllReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardUpGradeAllReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardUpGradeAllReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).CardUpGradeAll(msg)
	})
	serverproto.Handle_GAME_CSCardCollectInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardCollectInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardCollectInfoReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).CardCollect()
	})
	serverproto.Handle_GAME_CSCardCollectRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardCollectRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardCollectRewardReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).CardCollectReward(msg.CardId, msg.Level, msg.GetAll)
	})

	//卡片重置
	serverproto.Handle_GAME_CSCardComposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardComposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardComposeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CardCompose(msg.CardList)
	})
	//卡片分解
	serverproto.Handle_GAME_CSCardDecomposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardDecomposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardDecomposeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CardDecompose(msg.CardList, msg.CardType)
	})
	//
	serverproto.Handle_GAME_CSCardUpGradeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardUpGradeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardUpGradeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CardUpGrade(msg)
	})

	//请求卡片收集排行
	serverproto.Handle_GAME_CSCardCollectionRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardCollectionRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardCollectionRankReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).SendRank(msg)
	})

	//请求删除账号
	serverproto.Handle_GAME_CSUserDeleteReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSUserDeleteReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.ErrorF("uid=%v receive CSUserDeleteReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).SendDbUserDelete(msg.Status, 0, role.GetUUid(), role.GetOpenId(), role.GetSelectZone())
	})

	//请求删除账号信息
	serverproto.Handle_GAME_CSUserDeleteInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSUserDeleteInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardCollectionRankReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).SendDbUserDelete(0, 1, role.GetUUid(), role.GetOpenId(), role.GetSelectZone())
	})

	//请求删除账号
	serverproto.Handle_GAME_SSUserDeleteAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSUserDeleteAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.ErrorF("uid=%v receive SSUserDeleteAck msg=%v", role.GetUUid(), msg)
		if msg.Error == 2 {
			ack := &serverproto.SCUserDeleteInfoAck{Time: msg.Time}
			role.(*model2.Role).ReplayGate(ack, true)
		} else if msg.Error == 3 {
			ack := &serverproto.SCUserDeleteAck{Time: msg.Time}
			role.(*model2.Role).ReplayGate(ack, true)
		} else {
			ack := &serverproto.SCUserDeleteInfoAck{Error: 1}
			role.(*model2.Role).ReplayGate(ack, true)
		}
	})

	serverproto.Handle_GAME_SCCardCollectionRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCCardCollectionRankAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SCCardCollectionRankAck msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).ReplayGate(msg, true)
	})

	//卡片互换
	serverproto.Handle_GAME_CSCardLevelExchangeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCardLevelExchangeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCardLevelExchangeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CardLevelExchange(msg.SourceCardId, msg.TargetCardId)
	})

	//////技能相关
	//替换栏位中的技能
	serverproto.Handle_GAME_CSReplaceSkillReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSReplaceSkillReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSReplaceSkillReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SkillReplace(msg.HeroId, msg.Idx, msg.SkillId)
	})
	//激活职业对应阶段中的技能
	serverproto.Handle_GAME_CSActiveSkillReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActiveSkillReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActiveSkillReq msg:=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActiveSkill(msg.HeroId, msg.SkillId)
	})
	//交换技能
	serverproto.Handle_GAME_CSSwapSkillReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSwapSkillReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSwapSkillReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SwapSkill(msg.HeroId, msg.First, msg.Second)
	})

	//设置技能列表
	serverproto.Handle_GAME_CSSetSkillListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSetSkillListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSetSkillListReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SetSkillList(msg.HeroId, msg.SkillList)
	})

	//技能学习
	serverproto.Handle_GAME_CSSkillLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSkillLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillLevelUpReq msg:=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SkillLevelUp(msg.HeroId, msg.SkillId)
	})

	//重置技能等级
	serverproto.Handle_GAME_CSResetSkillLevelReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSResetSkillLevelReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillLevelUpReq msg:=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ResetSkillLevel(msg.HeroId, msg.IsAdvanced)
	})

	//高级技能经验兑换
	serverproto.Handle_GAME_CSConverSkillExpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSConverSkillExpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSkillLevelUpReq msg:=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ConverSkillExp(msg)
	})

	/////商店消息
	serverproto.Handle_GAME_CSShopBuyItemReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSShopBuyItemReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSShopBuyItemReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).BuyItem(msg.GoodsType, msg.GoodsId, msg.GoodsNum)
	})

	//商店信息请求
	serverproto.Handle_GAME_CSShopInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSShopInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSShopInfoReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ShopInfoReq(msg.GoodsType)
	})

	//商店信息请求
	serverproto.Handle_GAME_CSShopRefreshReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSShopRefreshReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSShopRefreshReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ShopRefresh(msg.GoodsType)
	})

	//红包商店兑换
	serverproto.Handle_GAME_CSRedBagExchangeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRedBagExchangeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSRedBagExchangeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).RedBagShopExchange()
	})

	//////时装相关
	//穿戴时装(替换)
	serverproto.Handle_GAME_CSFashionUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFashionUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSFashionUpReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).FashionUp(msg.FashionCfgId)
	})
	//卸下时装
	serverproto.Handle_GAME_CSFashionDownReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFashionDownReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSFashionDownReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).FashionDown(msg.FashionCfgId)
	})
	//时装合成
	serverproto.Handle_GAME_CSFashionComposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFashionComposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSFashionComposeReq msg=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).FashionCompose(msg.PaperCfgId)
	})
	//时装图纸分解
	serverproto.Handle_GAME_CSFashionPaperDecomposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFashionPaperDecomposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSFashionPaperDecomposeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).FashionPaperDecompose(msg.PaperCfgId)
	})

	// 时装洗练
	serverproto.Handle_GAME_CSFashionResetAttrReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFashionResetAttrReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSFashionPaperDecomposeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).FashionResetAttr(msg.FashionCfgId, msg.Enter)
	})

	serverproto.Handle_GAME_CSFashionUpLvlReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFashionUpLvlReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSFashionPaperDecomposeReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).FashionUpLvl(msg.FashionCfgId)
	})
	////收益处理 相关
	//收益相关处理(online/offline)
	serverproto.Handle_GAME_CSPlayerIncomeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPlayerIncomeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPlayerIncomeReq msg=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).Income()
	})
	//累计在线时间奖励
	serverproto.Handle_GAME_CSOnlineTimeRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSOnlineTimeRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSOnlineTimeRewardReq msg=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).OnlineTimeReward()
	})

	//挑战boss奖励
	serverproto.Handle_GAME_CSPlayerBossRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPlayerBossRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v cliId=%v receive CSPlayerBossRewardReq msg=%v", role.GetUUid(), cliId, msg)

		role.(model2.BattleLogicOuter).BossReward(msg.ChallengeTime, msg.MapId, msg.MapLevel, msg.RecordTimeStamp)
	})

	//请求一次boss战(打点数据)
	serverproto.Handle_GAME_CSBattleBossFightReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBattleBossFightReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v cliId=%v receive CSBattleBossFightReq msg=%v", role.GetUUid(), cliId, msg)

		role.(model2.BattleLogicOuter).BattleBossReq()
	})

	//测试关卡难度选择
	serverproto.Handle_GAME_CSMapLevelTypeChangeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSMapLevelTypeChangeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		ackMsg := &serverproto.SCMapLevelTypeChangeAck{
			Error: int32(serverproto.ErrorCode_ERROR_OK),
			Type:  -1,
		}
		//转为困难模式
		if msg.Type == 1 {
			if role.GetHardFight() == 1 {
				ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
			} else {
				role.SetHardFight(1)
			}
			//ackMsg.Type = role.GetHardFightHigh()
		} else if msg.Type == 0 { //转为普通模式
			if role.GetHardFight() == 0 {
				ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
			} else {
				role.SetHardFight(0)
			}
		} else if msg.Type == 2 { //噩梦模式
			if role.GetHardFight() == 2 {
				ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
			} else {
				//ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
				//暂时关闭噩梦模式
				role.SetHardFight(2)
			}
		}
		util.InfoF("uid=%v cliId=%v receive CSMapLevelTypeChangeReq msg=%v", role.GetUUid(), cliId, msg)
		role.ReplayGate(ackMsg, true)
		role.(*model2.Role).GetRoleBattle().SendBattleData()
	})

	//来自db的地图挑战排名更新(自身调整更新排名)
	serverproto.Handle_GAME_SSMapLevelChangeAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSMapLevelChangeAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSMapLevelChangeAck msg=%v nickname=%v", role.GetUUid(), msg, role.GetNickName())

		//通知客户端
		if msg.Notify {
			ackMsg := &serverproto.SCGetMapRankAck{
				Error:     int32(serverproto.ErrorCode_ERROR_OK),
				SelfRank:  msg.Rank,
				TotalRank: msg.RankPlayers,
			}
			ackMsg.TopPlayerList = append(msg.TopPlayerList)
			role.ReplayGate(ackMsg, true)
		}

		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(model2.BattleLogicOuter).SetMapRank(msg.Rank, msg.RankPlayers, msg.TopPlayerList, !msg.Notify)

			if msg.BattleRecordId > 0 {
				//通知客户端需要保存战斗过程记录
				ntfMsg := &serverproto.SCPlayerBattleRecordDetailSaveNtf{
					BattleRecordUid: msg.BattleRecordId,
					RecordTimeStamp: msg.RecordTimeStamp,
				}
				role.ReplayGate(ntfMsg, true)
			}

			if !msg.Notify {
				ackMsg := &serverproto.SCGetMapRankAck{
					Error:     int32(serverproto.ErrorCode_ERROR_OK),
					SelfRank:  msg.Rank,
					TotalRank: msg.RankPlayers,
				}
				ackMsg.TopPlayerList = append(msg.TopPlayerList)
				role.ReplayGate(ackMsg, true)
			}
		} else {
			if !msg.Notify {
				ackMsg := &serverproto.SCGetMapRankAck{
					Error: msg.Error,
				}
				role.ReplayGate(ackMsg, true)
			}

		}
	})

	serverproto.Handle_GAME_CSQuickBattleIncomeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v CSQuickBattleIncomeReq", role.GetUUid())
		role.(model2.BattleLogicOuter).GetQuickBattleReward()
	})

	//获取小地图排名
	serverproto.Handle_GAME_CSGetMapRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGetMapRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSGetMapRankReq msg=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).GetMapRank()
	})

	//获取战报信息(不包括战斗过程信息)
	serverproto.Handle_GAME_CSPlayerBattleRecordReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPlayerBattleRecordReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPlayerBattleRecordReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetBattleRecord(msg.RecordType, msg.ParamList)
	})
	//from rank
	serverproto.Handle_GAME_SCPlayerBattleRecordAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCPlayerBattleRecordAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SCPlayerBattleRecordAck msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).OnGetBattleRecordAck(msg)
	})

	//推图冲榜请求
	serverproto.Handle_GAME_CSMapActivityReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSMapActivityReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSMapActivityReq msg=%v", role.GetUUid(), msg)

		reqMsg := &serverproto.SSGetRushDataReq{
			Uid:      role.GetUUid(),
			RushType: model.Rush_Type_Map,
		}
		model2.SendRankService(reqMsg)
	})

	//推图领奖
	/*
		serverproto.Handle_GAME_CSMapActivityRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
			msg := ev.Msg().(*serverproto.CSMapActivityRewardReq)
			role := model2.RoleMag.GetRole(cliId)
			if role == nil {
				return
			}
			util.DebugF("uid=%v receive CSMapActivityRewardReq msg=%v", role.GetUUid(), msg)

			//如果是排行奖励，转发Rank
			reqMsg := &serverproto.SSGetRushRewardReq{
				Uid:        role.GetUUid(),
				RushType:   model.Rush_Type_Map,
				RewardType: msg.RewardType,
			}
			model2.SendRankService(reqMsg)
		})
	*/

	//////任务相关处理
	serverproto.Handle_GAME_CSGetTaskRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGetTaskRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSGetTaskRewardReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetTaskReward(msg.TaskId)
	})
	serverproto.Handle_GAME_CSGetTaskScoreRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGetTaskScoreRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSGetTaskScoreRewardReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetTaskScoreReward(msg.RewardType, msg.RewardIdx)
	})

	//使用道具(例如开宝箱等)
	serverproto.Handle_GAME_CSUseItemReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSUseItemReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSUseItemReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).UseItem(msg.ItemId, msg.ItemNum, msg.ItemIdxList, msg.ForceItemId)
	})
	//删除道具(时效道具)
	serverproto.Handle_GAME_CSDelItemReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSDelItemReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSDelItemReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).DelItemByList(msg.ItemIdList, model2.AddFrom_Expire)
	})

	//来自social/BattleBoss消息,公告消息通知
	serverproto.Handle_GAME_SSSystemMessageNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSSystemMessageNtf)
		util.DebugF("receive SSSystemMessageNtf msg=%v", msg)

		ntfMsg := &serverproto.SCSystemMessageNtf{}
		ntfMsg.SysMsg = append(msg.SysMsg)

		for idx := 0; idx < len(msg.SysMsg); idx++ {
			model2.AddWorldSMsg(msg.SysMsg[idx])
		}
		model2.RoleMag.SendMsg2OnlinePlayer(ntfMsg, 0)
	})

	//来自guild-social-game的公会系统通知
	serverproto.Handle_GAME_SSGuildNoticeToRoleNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildNoticeToRoleNtf)
		util.DebugF("receive SSGuildNoticeToRoleNtf msg=%v", msg)

		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		ntfMsg := &serverproto.SCSystemMessageNtf{}
		ntfMsg.SysMsg = append(msg.SysMsg)
		role.ReplayGate(ntfMsg, true)
	})

	//////英灵殿(arena)
	//获取英灵殿数据
	serverproto.Handle_GAME_CSArenaReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSArenaReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSArenaReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetArena()
	})
	//挑战(获得对手)，挑战
	serverproto.Handle_GAME_CSArenaMatchReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSArenaMatchReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSArenaMatchReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ArenaMatch(msg.HeroList)
	})
	//from db
	serverproto.Handle_GAME_SSArenaMatchAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaMatchAck)
		util.DebugF("receive SSArenaMatchAck msg=%v", msg)

		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		role.(*model2.Role).GetRoleArena().SetLastFighter(msg.FightInfo)
	})
	//挑战结果(失败/成功)
	serverproto.Handle_GAME_CSArenaResultReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSArenaResultReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSArenaResultReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ArenaResult(msg.FightResult)
	})
	//购买挑战次数
	serverproto.Handle_GAME_CSArenaBuyCountReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSArenaBuyCountReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSArenaBuyCountReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ArenaByCount(msg.BuyCount)
	})
	//获取赛季排行榜
	serverproto.Handle_GAME_CSArenaRankListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSArenaRankListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSArenaRankListReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ArenaRankList(msg.RankType, msg.StartIdx)
	})
	//from rank
	serverproto.Handle_GAME_SSArenaRankListAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaRankListAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSArenaRankListAck msg=%v", role.GetUUid(), msg)

		if msg.RankType == 0 && msg.StartIdx <= 0 {
			//表示获取自身排名需要通知客户端
			role.(model2.RoleLogicOuter).SetArenaRank(msg.SelfRank, true)
			return
		}

		role.(model2.RoleLogicOuter).SetArenaRank(msg.SelfRank, false)
		ackMsg := &serverproto.SCArenaRankListAck{
			Error:         msg.Error,
			RankList:      append(msg.RankList),
			SelfRank:      msg.SelfRank,
			RankType:      msg.RankType,
			StartIdx:      msg.StartIdx,
			SelfRankScore: msg.SelfRankScore,
		}
		//本赛季
		if msg.RankType == 0 {
			ackMsg.SelfRankScore = role.(*model2.Role).GetRoleArena().GetArenaScore()
		}
		role.ReplayGate(ackMsg, true)
	})
	//获取赛季奖励 from rank
	serverproto.Handle_GAME_SSArenaRankRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaRankRewardAck)
		util.DebugF("receive SSArenaRankRewardAck msg=%v", msg)

		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		if msg.SelfRank > 0 {
			model2.ArenaSeasonMag.GetSeasonReward(role.(*model2.Role), msg.SelfRank, msg.RewardSeasonId)
		}
	})
	//更新赛季数据 from rank
	serverproto.Handle_GAME_SSArenaRankUpdateAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaRankUpdateAck)
		util.DebugF("receive SSArenaRankUpdateAck msg=%v", msg)

		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			for _, data := range msg.RewardPlayerList {
				role := model2.RoleMag.GetRoleFromUUid(data.Key)
				if role.GetState() == model2.ROLE_STATE_ONLINE {
					model2.ArenaSeasonMag.GetSeasonReward(role.(*model2.Role), data.Value, msg.RewardSeasonId)
				}
			}
		}
	})
	//飞艇排行奖励 from cross
	serverproto.Handle_GAME_SSCrossYuanHangTrialRankUpdateAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCrossYuanHangTrialRankUpdateAck)
		util.InfoF("receive SSArenaRankUpdateAck msg=%v", msg)

		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			for _, data := range msg.RewardPlayerList {
				model2.CrossMag.GetSeasonReward(data.Key, data.Value, msg.RewardSeasonId)
			}
		}
	})

	//serverproto.Handle_GAME_SSCrossYuanHangTrialRankRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
	//	msg := ev.Msg().(*serverproto.SSCrossYuanHangTrialRankRewardAck)
	//	//util.DebugF("receive SSArenaRankRewardAck msg=%v", msg)
	//
	//	role := model2.RoleMag.GetRole(cliId)
	//	if role == nil {
	//		return
	//	}
	//
	//	if msg.SelfRank > 0 {
	//		model2.CrossMag.GetSeasonReward(role.(*model2.Role), msg.SelfRank, msg.RewardSeasonId)
	//	}
	//})
	//请求爬塔冲榜信息
	serverproto.Handle_GAME_CSArenaActivityReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSArenaActivityReq)
		util.DebugF("receive CSArenaActivityReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		reqMsg := &serverproto.SSGetRushDataReq{
			Uid:      role.GetUUid(),
			RushType: model.Rush_Type_Arena,
		}
		model2.SendRankService(reqMsg)
	})
	//上线请求爬塔冲榜信息
	/*
		serverproto.Handle_GAME_CSArenaActivityRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
			msg := ev.Msg().(*serverproto.CSArenaActivityRewardReq)
			util.DebugF("receive CSArenaActivityRewardReq msg:%v", msg)
			role := model2.RoleMag.GetRoleOrKick(cliId, ev)
			if role == nil {
				return
			}

			//如果是排行奖励，转发Rank
			reqMsg := &serverproto.SSGetRushRewardReq{
				Uid:        role.GetUUid(),
				RushType:   model.Rush_Type_Arena,
				RewardType: msg.RewardType,
			}
			model2.SendRankService(reqMsg)
		})
	*/

	//////mail
	//获取邮件
	serverproto.Handle_GAME_CSMailListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSMailListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSMailListReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetMailIst()
	})
	//邮件读取
	serverproto.Handle_GAME_CSMailReadReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSMailReadReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSMailReadReq msg:=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).MailRead(msg.MailIdList)
	})
	//获取邮件附件
	serverproto.Handle_GAME_CSMailRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSMailRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSMailRewardReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).MailReward(msg.MailIdList)
	})
	//删除已读邮件
	serverproto.Handle_GAME_CSMailDelReadReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSMailDelReadReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSMailDelReadReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).MailDelRead()
	})
	//发送邮件奖励 from social
	serverproto.Handle_GAME_SSAddMailNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSAddMailNtf)
		util.DebugF("receive SSAddMailNtf msg=%v", msg)

		if len(msg.NotifyList) > 0 {
			//判断当前玩家是否在线，或者在离线池中
			var dbUidLIst []uint64
			for _, uid := range msg.NotifyList {
				role := model2.RoleMag.GetRoleFromUUid(uid)
				if role == nil {
					role = model2.RoleMag.GetRoleFromOffline(uid)
				}
				if role != nil {
					role.(model2.RoleLogicOuter).AddMail1(msg.MailConfigId, msg.MailType,
						msg.RewardList, msg.MailParamList, msg.Title, msg.Content)
				} else {
					dbUidLIst = append(dbUidLIst, uid)
					//model2.SendDb(msg)
					//发送给db
					//role.(*model2.Role).SendDb(msg)
				}
			}
			if len(dbUidLIst) > 0 {
				msg.NotifyList = dbUidLIst
				model2.SendDb(msg)
			}
		} else {
			var uuIdSetList = set.New(set.NonThreadSafe)
			//online
			for key, val := range model2.RoleMag.GetRoleUUIdList() {
				if val == nil || key <= 0 {
					util.ErrorF("uuidList online multi key=%v", key)
					continue
				}
				if uuIdSetList.Has(val.GetUUid()) {
					util.ErrorF("uuidList online multi key=%v valUid=%v valState=%v", key, val.GetUUid(), val.GetState())
					continue
				}
				uuIdSetList.Add(val.GetUUid())

				util.DebugF("uid=%v key=%v state=%v OnlineRoleMailAddMail1 mailConfigId=%v type=%v itemList=%v",
					val.GetUUid(), key, val.GetState(), msg.MailConfigId, msg.MailType, msg.RewardList)
				val.(model2.RoleLogicOuter).AddMail1(msg.MailConfigId, msg.MailType,
					msg.RewardList, msg.MailParamList, msg.Title, msg.Content)
			}
			//offline
			for key, val := range model2.RoleMag.GetRoleOfflineList() {
				if val == nil || key <= 0 {
					util.ErrorF("uuidList offline multi key=%v", key)
					continue
				}
				if uuIdSetList.Has(val.GetUUid()) {
					util.ErrorF("uuidList offline multi key=%v valUid=%v valState=%v", key, val.GetUUid(), val.GetState())
					continue
				}
				uuIdSetList.Add(val.GetUUid())

				util.DebugF("uid=%v key=%v state=%v OfflineRoleMailAddMail1 mailConfigId=%v type=%v itemList=%v",
					val.GetUUid(), key, val.GetState(), msg.MailConfigId, msg.MailType, msg.RewardList)
				val.(model2.RoleLogicOuter).AddMail1(msg.MailConfigId, msg.MailType,
					msg.RewardList, msg.MailParamList, msg.Title, msg.Content)
			}
		}
	})

	//////赛季玩法
	//赛季玩法信息获取(根据赛季不同类型获取对应信息)
	serverproto.Handle_GAME_CSCompetitionReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetCompetition(msg.CompetitionId)
	})
	//from rank[CSCompetitionReq]
	serverproto.Handle_GAME_SSGetCompetitionDataAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetCompetitionDataAck)
		util.DebugF("receive SSGetCompetitionDataAck msg=%v", msg)

		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		role.(*model2.Role).GetRoleCompetition().DoGetCompetitionNtf(msg)
	})
	//赛季结算奖励，会有多条数据(根据在线玩家人数决定) from rank
	serverproto.Handle_GAME_SSCompetitionRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionRewardAck)
		util.DebugF("receive SSCompetitionRewardAck msg=%v", msg)

		convertData, ok := model.ConvertCompTypeList[msg.CompetitionId]
		if !ok {
			util.ErrorF("SSCompetitionRewardAck data not find [%v]", msg.CompetitionId)
			return
		}

		//zhaomu reward
		if convertData.GetCompetitionType() == int32(model.CompetitionType_ZhaoMu) ||
			convertData.GetCompetitionType() == int32(model.CompetitionType_XuanBa) ||
			convertData.GetCompetitionType() == int32(model.CompetitionType_DuoBao) ||
			convertData.GetCompetitionType() == int32(model.CompetitionType_ZhanBu) ||
			convertData.GetCompetitionType() == int32(model.CompetitionType_Idol) {
			for _, data := range msg.RewardUidList {
				rewardRole := model2.RoleMag.GetRoleFromUUid(data.Key)
				if rewardRole == nil {
					continue
				}
				rewardRole.(*model2.Role).GetRoleCompetition().DoCompetitionReward(
					convertData, msg.CompetitionSubId, data.Value)
			}
		}
	})
	//上线时一次性获取历史赛季奖励 from rank
	serverproto.Handle_GAME_SSCompetitionRewardHistoryAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionRewardHistoryAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionRewardHistoryAck msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleCompetition().DoCompetitionRewardHistory(msg.RewardUidList, msg.ECompetitionId, msg.ECompetitionSubId)
	})
	//上交道具获取积分
	serverproto.Handle_GAME_CSCompetitionScoreReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionScoreReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionScoreReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CompetitionAddScore(msg.ItemList)
	})
	//from rank ack
	serverproto.Handle_GAME_SSCompetitionUpdateScoreAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionUpdateScoreAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionUpdateScoreAck msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleCompetition().DoUpdateScoreNtf(msg)
	})

	//占星数据请求
	serverproto.Handle_GAME_CSCompetitionStarInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionStarInfoReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionStarInfoReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetDivineInfo()
	})

	//占星请求
	serverproto.Handle_GAME_CSCompetitionStarDivineReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionStarDivineReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionStarDivineReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).OnStarDivine(msg.UseTicket)
	})

	//占星领奖
	serverproto.Handle_GAME_CSCompetitionStarCloseRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionStarCloseRewardReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionStarCloseRewardReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetDivineReward()
	})

	//偶像季，给爱豆投票
	serverproto.Handle_GAME_CSCompetitionOnVoteReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionOnVoteReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionOnVoteReq msg=%v", role.GetUUid(), msg)

		//处理本地投票计算
		role.(*model2.Role).VoteIdol(msg.Uid, msg.TicketCount)
	})

	//偶像季，rank返回投票结果
	serverproto.Handle_GAME_SSCompetitionOnVoteNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionOnVoteNtf)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionOnVoteNtf msg=%v", role.GetUUid(), msg)

		if msg.TicketCount == 0 {
			//表示0票刷榜
			return
		}
		//发送到rank
		ackMsg := &serverproto.SCCompetitionOnVoteAck{
			Error:       int32(msg.Error),
			Uid:         msg.Uid,
			TotalCount:  msg.TotalCount,
			VoteList:    msg.VoteList,
			VoteTarget:  msg.VoteTarget,
			TicketCount: msg.TicketCount,
			Detail:      msg.Detail,
		}
		role.(*model2.Role).GetRoleCompetition().GetRewardDate(ackMsg)
		role.ReplayGate(ackMsg, true)
	})

	//偶像季，获取自己的粉丝列表
	serverproto.Handle_GAME_CSCompetitionSelfFansInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionSelfFansInfoReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionSelfFansInfoReq msg=%v", role.GetUUid(), msg)

		//判定是否可以获取列表
		bRet, competitionId := role.(*model2.Role).CheckInSeason()
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCompetitionSelfFansInfoAck{
				Error: int32(bRet),
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		//发送到rank
		reqMsg := &serverproto.SSCompetitionSelfFansInfoReq{
			Uid:           role.GetUUid(),
			CompetitionId: competitionId,
		}
		role.(*model2.Role).SendRank(reqMsg)
	})

	serverproto.Handle_GAME_SSCompetitionSelfFansInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionSelfFansInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionSelfFansInfoAck msg=%v", role.GetUUid(), msg)

		//发送到rank
		ackMsg := &serverproto.SCCompetitionSelfFansInfoAck{
			Error:   msg.Error,
			FanList: msg.FanList,
		}
		role.ReplayGate(ackMsg, true)
	})

	//偶像季，获取得票排行榜单
	serverproto.Handle_GAME_CSCompetitionVoteRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionVoteRankReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionVoteRankReq msg=%v", role.GetUUid(), msg)

		//判定是否可以获取列表
		bRet, competitionId := role.(*model2.Role).CheckInSeason()
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCompetitionVoteRankAck{
				Error: int32(bRet),
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		//发送到rank
		reqMsg := &serverproto.SSCompetitionVoteRankReq{
			Uid:           role.GetUUid(),
			Page:          msg.Page,
			CompetitionId: competitionId,
		}
		role.(*model2.Role).SendRank(reqMsg)
	})

	//偶像季，点亮宝箱排行版
	serverproto.Handle_GAME_SSCompetitionVoteRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionVoteRankAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionVoteRankAck msg=%v", role.GetUUid(), msg)

		//发送到rank
		ackMsg := &serverproto.SCCompetitionVoteRankAck{
			Error:    msg.Error,
			Page:     msg.Page,
			RankData: msg.RankData,
			IsEnd:    msg.IsEnd,
		}
		role.ReplayGate(ackMsg, true)
	})

	//偶像季，点亮宝箱排行版
	serverproto.Handle_GAME_CSCompetitionFansRewardRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionFansRewardRankReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionFansRewardRankReq msg=%v", role.GetUUid(), msg)

		bRet, competitionId := role.(*model2.Role).CheckInSeason()
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCompetitionFansRewardRankAck{
				Error: int32(bRet),
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		//发送到rank
		reqMsg := &serverproto.SSCompetitionFansRewardRankReq{
			Uid:           role.GetUUid(),
			Page:          msg.Page,
			CompetitionId: competitionId,
		}
		role.(*model2.Role).SendRank(reqMsg)
	})

	//偶像季，粉丝领取奖励
	serverproto.Handle_GAME_SSCompetitionFansRewardRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionFansRewardRankAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionFansRewardRankAck msg=%v", role.GetUUid(), msg)

		//发送到rank
		ackMsg := &serverproto.SCCompetitionFansRewardRankAck{
			Error:    msg.Error,
			Page:     msg.Page,
			DataList: msg.DataList,
			IsEnd:    msg.IsEnd,
		}
		role.(*model2.Role).GetSelfVoteData(ackMsg)

		role.ReplayGate(ackMsg, true)
	})

	//偶像季，粉丝领取奖励
	serverproto.Handle_GAME_CSCompetitionFansGetRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionFansGetRewardReq)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionFansGetRewardReq msg=%v", role.GetUUid(), msg)

		//校验是否给爱豆投票，是否满足档位所需的票数
		bRet := role.(*model2.Role).CheckFansReward(msg.Uid, msg.RewardLevel)
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCompetitionFansGetRewardAck{
				Error:       int32(bRet),
				Uid:         msg.Uid,
				RewardLevel: msg.RewardLevel,
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		//发送到rank//获取对应爱豆的箱子数量
		reqMsg := &serverproto.SSCompetitionFansGetRewardReq{
			Uid:           role.GetUUid(),
			IdolUid:       msg.Uid,
			RewardLevel:   msg.RewardLevel,
			CompetitionId: int32(model.CompetitionType_Idol),
		}
		role.(*model2.Role).SendRank(reqMsg)
	})

	//偶像季 粉丝馈赠领取奖励返回
	serverproto.Handle_GAME_SSCompetitionFansGetRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionFansGetRewardAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionFansGetRewardAck msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetFansReward(msg.IdolUid, msg.RewardLevel, msg.IdolBoxCount)
	})

	//偶像季， 赛季结束，给在线玩家发送，粉丝裤子鞥
	serverproto.Handle_GAME_SSCompetitionFansGetAllRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionFansGetAllRewardAck)
		util.DebugF("receive SSCompetitionFansGetAllRewardAck msg=%v", msg)

		convertData, ok := model.ConvertCompTypeList[msg.CompetitionId]
		if !ok {
			util.ErrorF("SSCompetitionRewardAck data not find [%v]", msg.CompetitionId)
			return
		}

		//zhaomu reward
		if convertData.GetCompetitionType() == int32(model.CompetitionType_Idol) {
			for _, data := range msg.Data {
				rewardRole := model2.RoleMag.GetRoleFromUUid(data.Uid)
				if rewardRole == nil {
					continue
				}
				if len(data.IdolList) <= 0 {
					return
				}

				rewardRole.(*model2.Role).GetAllFansReward(data.IdolList)
			}
		}
	})
	//偶像季每日领奖
	serverproto.Handle_GAME_CSCompetitionFansDayRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionFansDayRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionFansDayRewardReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetIdolDayReward(msg.Id)
	})

	//偶像季每日领奖
	serverproto.Handle_GAME_CSCompetitionGetPlayerVoteRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompetitionGetPlayerVoteRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompetitionGetPlayerVoteRankReq msg=%v", role.GetUUid(), msg)

		reqMsg := &serverproto.SSCompetitionGetPlayerVoteRankReq{
			Uid:           msg.Uid,
			ReqUid:        role.GetUUid(),
			CompetitionId: int32(model.CompetitionType_Idol),
		}
		role.(*model2.Role).SendRank(reqMsg)
	})

	//偶像季每日领奖
	serverproto.Handle_GAME_SSCompetitionGetPlayerVoteRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionGetPlayerVoteRankAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSCompetitionGetPlayerVoteRankAck msg=%v", role.GetUUid(), msg)

		reqMsg := &serverproto.SCCompetitionGetPlayerVoteRankAck{
			Error:        msg.Error,
			IdolRankData: msg.IdolRankData,
		}
		role.ReplayGate(reqMsg, true)
	})

	///sign
	serverproto.Handle_GAME_CSSignUpInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSignUpInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSignUpInfoReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleActivityOuter).GetSignUpInfo()
	})
	serverproto.Handle_GAME_CSSignUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSignUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSSignUpReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleActivityOuter).OnSignUp()
	})

	serverproto.Handle_GAME_CSCompulsoryGuidanceReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCompulsoryGuidanceReq)
		util.DebugF("receive CSCompulsoryGuidanceReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSCompulsoryGuidanceReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).CompulsoryGuidance(msg.StoryId, msg.Status)
	})

	//////恶魔协会
	serverproto.Handle_GAME_CSEvilRefreshReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSEvilRefreshReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSEvilRefreshReq ms=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).BattleEvilRefresh(msg.BForce)
	})
	serverproto.Handle_GAME_CSEvilChallengeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSEvilChallengeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSEvilChallengeReq msg=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).BattleEvilChallenge(msg.PosIdx)
	})

	//获取自己的爬塔信息
	serverproto.Handle_GAME_CSClimbingTowerInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerInfoReq)
		util.DebugF("receive CSClimbingTowerInfoReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		role.(model2.RoleLogicOuter).ClimbingTowerInfoReq()

		/*
			rankMsg := &serverproto.SSTowerMinFightPowerReq{
				TowerLevel: role.(*model2.Role).GetRoleTower().GetCurTower(),
			}
			role.(*model2.Role).SendRank(rankMsg)
		*/
	})

	//获取自己的爬塔信息
	serverproto.Handle_GAME_CSTowerLevelMinFightPowerReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSTowerLevelMinFightPowerReq)
		util.DebugF("receive CSTowerLevelMinFightPowerReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		rankMsg := &serverproto.SSTowerMinFightPowerReq{
			TowerLevel: msg.TowerLevel,
		}
		role.(*model2.Role).SendRank(rankMsg)
	})

	//获取爬塔馈赠奖励
	serverproto.Handle_GAME_CSClimbingTowerDayRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerDayRewardReq)
		util.DebugF("receive CSClimbingTowerDayRewardReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		role.(model2.RoleBTRouter).GetTowerLevelDayReward()
	})

	//获取好友的爬塔信息
	serverproto.Handle_GAME_CSFriendPassTowerInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFriendPassTowerInfoReq)
		util.DebugF("receive CSFriendPassTowerInfoReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		role.(model2.RoleLogicOuter).GetFriendTowerInfo(msg.BeginIndex, msg.EndIndex)
	})
	//爬塔开始
	serverproto.Handle_GAME_CSClimbingTowerBeginReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerBeginReq)
		util.DebugF("receive CSClimbingTowerBeginReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		role.(model2.RoleLogicOuter).ClimbingTowerBegin(msg.TowerLevel)
	})
	//爬塔结束
	serverproto.Handle_GAME_CSClimbingTowerEndReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerEndReq)
		util.DebugF("receive CSClimbingTowerEndReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		role.(model2.RoleLogicOuter).ClimbingTowerEnd(msg.TowerLevel, msg.LoadingTime, msg.RecordTimeStamp)
	})
	//无尽爬塔开始
	serverproto.Handle_GAME_CSClimbingTowerWjBeginReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerWjBeginReq)
		util.InfoF("receive CSClimbingTowerWjBeginReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		role.(model2.RoleLogicOuter).ClimbingTowerWjBegin(msg.TowerLevel)
	})
	//无尽爬塔结束
	serverproto.Handle_GAME_CSClimbingTowerWjEndReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerWjEndReq)
		util.InfoF("receive CSClimbingTowerWjEndReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		role.(model2.RoleLogicOuter).ClimbingTowerWjEnd(msg.TowerLevel, msg.LoadingTime, msg.RecordTimeStamp)
	})

	//无尽爬塔buff
	serverproto.Handle_GAME_CSClimbingTowerWjBuffReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerWjBuffReq)
		util.InfoF("receive CSClimbingTowerWjBuffReq msg:%v,1:%v,2:%v,3:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		role.(model2.RoleLogicOuter).ClimbingTowerWjBuff(msg.Buff1, msg.Buff2, msg.Buff3)
	})
	//无尽爬塔排行榜获取
	serverproto.Handle_GAME_CSClimbingTowerWjRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerWjRankReq)
		util.DebugF("receive CSClimbingTowerRankReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		//发送到rankserver，请求排行榜信息
		rankMsg := &serverproto.SSPassTowerLevelRankReq{
			Uid:  role.(*model2.Role).GetUUid(),
			Type: 1,
		}
		role.(*model2.Role).SendRank(rankMsg)
	})

	//无尽排行奖励 from rank
	serverproto.Handle_RANK_SSTowerWjRankUpdateAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSTowerWjRankUpdateAck)
		util.InfoF("receive SSTowerWjRankUpdateAck msg=%v", msg)

		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			for _, data := range msg.RewardPlayerList {
				model2.TowerMag.GetRankReward(data.Key, data.Value)
			}
		}
	})
	//爬塔排行榜获取
	serverproto.Handle_GAME_CSClimbingTowerRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSClimbingTowerRankReq)
		util.DebugF("receive CSClimbingTowerRankReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		//发送到rankserver，请求排行榜信息
		rankMsg := &serverproto.SSPassTowerLevelRankReq{
			Uid: role.(*model2.Role).GetUUid(),
		}
		role.(*model2.Role).SendRank(rankMsg)
	})
	//互粉好友数据
	serverproto.Handle_GAME_SSGetFriendTowerInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetFriendTowerInfoAck)
		util.DebugF("receive SSGetFriendTowerInfoAck msg:%v", msg)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		//发送到rankserver，请求排行榜信息
		role.(model2.RoleLogicOuter).GetFriendBriefFromDB(msg.Final, msg.Begin, msg.End, msg.Infos)
	})
	//爬塔通关最小战力
	serverproto.Handle_GAME_SSTowerMinFightPowerAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSTowerMinFightPowerAck)
		util.DebugF("receive SSTowerMinFightPowerAck msg:%v", msg)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		ackMsg := &serverproto.SCTowerLevelMinFightPowerAck{}
		if len(msg.TowerInfo) >= 1 {
			ackMsg.MinTowerInfo = &serverproto.MinTowerInfo{}

			info := &serverproto.MinTowerInfo{
				TowerLevel: msg.TowerInfo[0].Infos.TowerLevel,
				FightPower: msg.TowerInfo[0].FightPower,
				Brief:      msg.TowerInfo[0].Infos,
				RecordTime: msg.TowerInfo[0].RecordTime,
				BattleTime: msg.TowerInfo[0].BattleTime,
			}
			levelCfgData, ok := serverproto.ClimbingTowerCfgLoader[msg.TowerInfo[0].Infos.TowerLevel]
			if ok && msg.TowerInfo[0].BattleVersion < levelCfgData.Version {

			} else {
				ackMsg.MinTowerInfo = info
			}
		}
		role.ReplayGate(ackMsg, true)

		if msg.BattleRecordId > 0 && msg.Notify {
			ntfMsg := &serverproto.SCPlayerBattleRecordDetailSaveNtf{
				BattleRecordUid: msg.BattleRecordId,
				RecordTimeStamp: msg.RecordTimeStamp,
			}
			role.ReplayGate(ntfMsg, true)
		}
	})
	//通关排名
	serverproto.Handle_GAME_SSPassTowerLevelRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPassTowerLevelRankAck)
		util.DebugF("receive SSPassTowerLevelRankAck msg:%v", msg)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		if msg.Type == 1 {
			ackMsg := &serverproto.SCClimbingTowerWjRankAck{
				Error:    0,
				SelfRank: msg.SelfRank,
			}
			for _, data := range msg.TowerInfo {
				ackMsg.RankList = append(ackMsg.RankList, &serverproto.KeyValueType64{
					Key:   data.Uid,
					Value: data.Rank,
				})
			}
			role.ReplayGate(ackMsg, true)
		} else {
			ackMsg := &serverproto.SCClimbingTowerRankAck{
				Error:    0,
				SelfRank: msg.SelfRank,
			}
			for _, data := range msg.TowerInfo {
				ackMsg.RankList = append(ackMsg.RankList, &serverproto.KeyValueType64{
					Key:    data.Uid,
					Value:  data.Rank,
					Value2: 0,
					Value3: 0,
				})
			}
			role.ReplayGate(ackMsg, true)
		}
	})

	//TODO WANGZHAOCAN 爬塔冲榜开始
	//上线请求爬塔冲榜赛季信息
	serverproto.Handle_GAME_CSOnlineRushInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSOnlineRushInfoReq)
		util.DebugF("receive CSOnlineRushInfoReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		reqMsg := &serverproto.SSOnlineGetRushInfoReq{
			Uid: role.GetUUid(),
		}
		model2.SendRankService(reqMsg)
	})
	//请求爬塔冲榜信息
	serverproto.Handle_GAME_CSTowerActivityReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSTowerActivityReq)
		util.DebugF("receive CSTowerActivityReq msg:%v", msg)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		reqMsg := &serverproto.SSGetRushDataReq{
			Uid:      role.GetUUid(),
			RushType: model.Rush_Type_Tower,
		}
		model2.SendRankService(reqMsg)
	})
	//上线请求爬塔冲榜信息
	/*
		serverproto.Handle_GAME_CSTowerActivityRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
			msg := ev.Msg().(*serverproto.CSTowerActivityRewardReq)
			util.DebugF("receive CSTowerActivityRewardReq msg:%v", msg)
			role := model2.RoleMag.GetRoleOrKick(cliId, ev)
			if role == nil {
				return
			}

			//如果是排行奖励，转发Rank
			reqMsg := &serverproto.SSGetRushRewardReq{
				Uid:        role.GetUUid(),
				RushType:   model.Rush_Type_Tower,
				RewardType: msg.RewardType,
			}
			model2.SendRankService(reqMsg)
		})
	*/

	//--------------------------   rank 返回 --------------------------
	//爬塔冲榜信息返回
	serverproto.Handle_GAME_SSGetRushDataAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushDataAck)
		util.DebugF("receive SSGetRushDataAck msg:%v", msg)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		if msg.RushType == model.Rush_Type_Tower {
			ackMsg := &serverproto.SCTowerActivityAck{
				Error:     msg.Error,
				SelfRank:  msg.SelfRank,
				EndTime:   msg.EndTime,
				TopData:   msg.TopData,
				SelfLevel: msg.SelfLevel,
			}
			role.(model2.RoleLogicOuter).GetRushTowerInfo(ackMsg, msg.CurRushRound)
			role.ReplayGate(ackMsg, true)
		} else if msg.RushType == model.Rush_Type_Arena {
			ackMsg := &serverproto.SCArenaActivityAck{
				Error:     msg.Error,
				SelfRank:  msg.SelfRank,
				EndTime:   msg.EndTime,
				TopData:   msg.TopData,
				SelfLevel: msg.SelfLevel,
			}
			role.(model2.RoleLogicOuter).GetRushArenaInfo(ackMsg, msg.CurRushRound)
			role.ReplayGate(ackMsg, true)
		} else if msg.RushType == model.Rush_Type_Map {
			ackMsg := &serverproto.SCMapActivityAck{
				Error:     msg.Error,
				SelfRank:  msg.SelfRank,
				EndTime:   msg.EndTime,
				TopData:   msg.TopData,
				SelfLevel: msg.SelfLevel,
			}
			role.(model2.RoleLogicOuter).GetRushMapInfo(ackMsg, msg.CurRushRound)
			role.ReplayGate(ackMsg, true)
		} else if msg.RushType == model.Rush_Type_Pet {
			ackMsg := &serverproto.SCPetActivityAck{
				Error:     msg.Error,
				SelfRank:  msg.SelfRank,
				EndTime:   msg.EndTime,
				TopData:   msg.PetData,
				SelfScore: msg.SelfLevel,
			}
			role.(model2.RoleLogicOuter).GetRushPetInfo(ackMsg, msg.CurRushRound)
			role.ReplayGate(ackMsg, true)
		} else {
			ackMsg := &serverproto.SCRushActivityAck{
				Error:     msg.Error,
				SelfRank:  msg.SelfRank,
				EndTime:   msg.EndTime,
				TopData:   msg.TopData,
				SelfLevel: msg.SelfLevel,
				RushType:  msg.RushType,
			}
			role.(model2.RoleLogicOuter).GetRushInfo(ackMsg, msg.CurRushRound)
			role.ReplayGate(ackMsg, true)
		}
	})

	//冲榜商店信息返回
	serverproto.Handle_GAME_SSGetRushShopInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushShopInfoAck)
		util.DebugF("receive SSGetRushShopInfoAck msg:%v", msg)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		role.(model2.RoleLogicOuter).GetRushShopInfo(msg)
	})
	//冲榜上线信息返回
	serverproto.Handle_GAME_SSOnlineGetRushInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSOnlineGetRushInfoAck)
		util.DebugF("receive SSOnlineGetRushInfoAck msg:%v", msg)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		ackMsg := &serverproto.SCOnlineRushInfoAck{
			RushData: msg.RushData,
		}
		role.ReplayGate(ackMsg, true)
	})

	serverproto.Handle_GAME_SSRushDataChangeAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRushDataChangeAck)
		util.DebugF("receive SSRushDataChangeAck msg:%v", msg)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		//如果是挑战次数奖励
		if msg.RushType == model.Rush_Type_Tower {
			role.(*model2.Role).GetRoleTower().AddRushTowerScore(msg.RushRound, msg.Score)
		} else if msg.RushType == model.Rush_Type_Arena {
			role.(*model2.Role).GetRoleArena().AddRushArenaScore(msg.RushRound, msg.Score)
		} else if msg.RushType == model.Rush_Type_Map {
			role.(*model2.Role).GetRoleBattle().AddRushMapScore(msg.RushRound, msg.Score2, msg.Score3)
		} else if msg.RushType == model.Rush_Type_Pet {
			role.(*model2.Role).GetRolePet().AddRushPetScore(msg.RushRound)
		} else {
			role.(*model2.Role).GetRoleRush().AddRushScore(msg.RushType, msg.RushRound)
		}
	})

	serverproto.Handle_GAME_SSGetRushBaseRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushBaseRewardAck)
		util.DebugF("receive SSGetRushBaseRewardAck msg:%v", msg)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		//如果是挑战次数奖励
		if msg.Reward == true {
			if msg.RushType == model.Rush_Type_Tower {
				role.(*model2.Role).GetRoleTower().OnlineGetRushTowerBaseReward(msg.RewardRound)
			} else if msg.RushType == model.Rush_Type_Arena {
				role.(*model2.Role).GetRoleArena().OnlineGetRushArenaBaseReward(msg.RewardRound)
			} else if msg.RushType == model.Rush_Type_Map {
				role.(*model2.Role).GetRoleBattle().OnlineGetRushMapBaseReward(msg.RewardRound)
			} else if msg.RushType == model.Rush_Type_Pet {
				role.(*model2.Role).GetRolePet().OnlineGetRushPetBaseReward(msg.RewardRound)
			} else {
				role.(*model2.Role).GetRoleRush().OnlineGetRushBaseReward(msg.RushType, msg.RewardRound)
			}
		}
	})

	//冲榜奖励请求返回
	serverproto.Handle_GAME_SSGetRushRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushRewardAck)
		util.DebugF("receive SSGetRushRewardAck msg:%v", msg)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		//挑战次数奖励
		if msg.RewardType == model.Rush_Reward_Type_FightCount {
			if msg.RushType == model.Rush_Type_Tower {
				role.(model2.RoleLogicOuter).GetTowerFightCountReward(msg.RushRound, msg.RewardType)
			} else if msg.RushType == model.Rush_Type_Arena {
				role.(model2.RoleLogicOuter).GetArenaFightCountReward(msg.RushRound, msg.RewardType)
			} else if msg.RushType == model.Rush_Type_Map {
				role.(model2.RoleLogicOuter).GetRushMapLevelReward(msg.RushRound, msg.RewardType)
			} else if msg.RushType == model.Rush_Type_Pet {
				role.(model2.RoleLogicOuter).GetPetFightCountReward(msg.RushRound, msg.RewardType)
			} else {
				role.(model2.RoleLogicOuter).GetFightCountReward(msg.RushRound, msg.RushType, msg.RewardType)
			}
			return
		}
		//排名奖励处理
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) && len(msg.ItemList) > 0 {
			if msg.RushType == model.Rush_Type_Tower {
				role.(model2.RoleLogicOuter).GetRushTowerRankReward(msg)
			} else if msg.RushType == model.Rush_Type_Arena {
				role.(model2.RoleLogicOuter).GetRushArenaRankReward(msg)
			} else if msg.RushType == model.Rush_Type_Map {
				role.(model2.RoleLogicOuter).GetRushMapRankReward(msg)
			} else if msg.RushType == model.Rush_Type_Pet {
				role.(model2.RoleLogicOuter).GetRushPetRankReward(msg)
			} else {
				role.(model2.RoleLogicOuter).GetRushRankReward(msg)
			}
			return
		}
		//没上榜等异常情况。
		/*
			if msg.RushType == model.Rush_Type_Tower {
				ackMsg := &serverproto.SCTowerActivityRewardAck{
					Error: msg.Error,
				}
				role.ReplayGate(ackMsg, true)
			} else if msg.RushType == model.Rush_Type_Arena {
				ackMsg := &serverproto.SCArenaActivityRewardAck{
					Error: msg.Error,
				}
				role.ReplayGate(ackMsg, true)
			} else if msg.RushType == model.Rush_Type_Map {
				ackMsg := &serverproto.SCMapActivityRewardAck{
					Error: msg.Error,
				}
				role.ReplayGate(ackMsg, true)
			} else if msg.RushType == model.Rush_Type_Pet {
				ackMsg := &serverproto.SCPetActivityRewardAck{
					Error: msg.Error,
				}
				role.ReplayGate(ackMsg, true)
			} else {
				//todo 需要修改
				ackMsg := &serverproto.SCRushActivityRewardAck{
					Error:    msg.Error,
					RushType: msg.RushType,
				}
				role.ReplayGate(ackMsg, true)
			}
		*/
		ackMsg := &serverproto.SCRushActivityRewardAck{
			Error:    msg.Error,
			RushType: msg.RushType,
		}
		role.ReplayGate(ackMsg, true)

	})

	//爬塔冲榜信息返回
	serverproto.Handle_GAME_SSRushActivityRankRewardNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRushActivityRankRewardNtf)
		util.DebugF("receive SSRushActivityRankRewardNtf msg:%v", msg)

		//发送战斗次数奖励
		rushType := model.Rush_Type_Tower
		if msg.MailCfgId == model.GlobalMailIdRushArena {
			rushType = model.Rush_Type_Arena
		} else if msg.MailCfgId == model.GlobalMailIdRushMap {
			rushType = model.Rush_Type_Map
		} else if msg.MailCfgId == model.GlobalMailRushPetRankReward {
			rushType = model.Rush_Type_Pet
		} else if msg.MailCfgId == model.GlobalMailRushSkillRankReward {
			rushType = model.Rush_Type_Skill
		}

		if len(msg.MailData) > 0 {
			for _, mails := range msg.MailData {
				newCliId := &model.ClientID{
					SessID: mails.Uid,
				}
				role := model2.RoleMag.GetRole(*newCliId)
				if role == nil {
					continue
				}
				bRet := serverproto.ErrorCode_ERROR_OK
				if msg.MailCfgId == model.GlobalMailIdRushTower {
					bRet = role.(*model2.Role).GetRoleTower().CheckRankReward(msg.RushRound)
				} else if msg.MailCfgId == model.GlobalMailIdRushArena {
					bRet = role.(*model2.Role).GetRoleArena().CheckRankReward(msg.RushRound)
				} else if msg.MailCfgId == model.GlobalMailIdRushMap {
					bRet = role.(*model2.Role).GetRoleBattle().CheckRankReward(msg.RushRound)
				} else if msg.MailCfgId == model.GlobalMailRushPetRankReward {
					bRet = role.(*model2.Role).GetRolePet().CheckRankReward(msg.RushRound)
				} else {
					bRet = role.(*model2.Role).GetRoleRush().CheckRushRankReward(int32(rushType), msg.RushRound)
				}
				if bRet != serverproto.ErrorCode_ERROR_OK {
					continue
				}

				role.(model2.RoleLogicOuter).AddMail1(msg.MailCfgId, msg.MailType,
					mails.RewardList, mails.MailParamList, "", "")
				if msg.MailCfgId == model.GlobalMailIdRushTower {
					role.(*model2.Role).GetRoleTower().SetRankReward(msg.RushRound)
				} else if msg.MailCfgId == model.GlobalMailIdRushArena {
					role.(*model2.Role).GetRoleArena().SetRankReward(msg.RushRound)
				} else if msg.MailCfgId == model.GlobalMailIdRushMap {
					role.(*model2.Role).GetRoleBattle().SetRankReward(msg.RushRound)
				} else if msg.MailCfgId == model.GlobalMailRushPetRankReward {
					role.(*model2.Role).GetRolePet().SetRankReward(msg.RushRound)
				} else {
					role.(*model2.Role).GetRoleRush().SetRushRankReward(int32(rushType), msg.RushRound)
				}
			}
		}

		model2.RoleMag.SendRushReward(int32(rushType), msg.RushRound)
	})

	serverproto.Handle_GAME_SSGetRushRankRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushRankRewardAck)
		util.DebugF("receive SSGetRushRankRewardAck msg:%v", msg)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		if len(msg.RewardList) <= 0 {
			return
		}
		if role.(*model2.Role).GetRoleRush() != nil {
			role.(*model2.Role).GetRoleRush().OnlineGetRushReward(msg)
		}
	})
	//爬塔冲榜信息返回
	/*
		serverproto.Handle_GAME_SSGetRushRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
			msg := ev.Msg().(*serverproto.SSGetRushRankAck)
			util.DebugF("receive SSGetRushRankAck msg:%v", msg)
			newCliId := &model.ClientID{
				SessID: msg.Uid,
			}
			role := model2.RoleMag.GetRole(*newCliId)
			if role == nil {
				return
			}
			if len(msg.RankReward) <= 0 {
				return
			}
			for _, data := range msg.RankReward {
				//没有奖励，返回
				if len(data.RewardList) <= 0 {
					continue
				}
				bRet := serverproto.ErrorCode_ERROR_OK
				if msg.RushType == model.Rush_Type_Tower {
					bRet = role.(*model2.Role).GetRoleTower().CheckRankReward(msg.FinishRound)
				} else if msg.RushType == model.Rush_Type_Arena {
					bRet = role.(*model2.Role).GetRoleArena().CheckRankReward(msg.FinishRound)
				} else if msg.RushType == model.Rush_Type_Map {
					bRet = role.(*model2.Role).GetRoleBattle().CheckRankReward(msg.FinishRound)
				} else if msg.RushType == model.Rush_Type_Pet {
					bRet = role.(*model2.Role).GetRolePet().CheckRankReward(msg.FinishRound)
				} else {
					bRet = role.(*model2.Role).GetRoleRush().CheckRushRankReward(msg.RushType, msg.FinishRound)
				}
				if bRet != serverproto.ErrorCode_ERROR_OK {
					continue
				}

				mailCfgId := model.GlobalMailIdRushTower
				mailType := int32(serverproto.MailType_MailType_RushTower)
				if msg.RushType == model.Rush_Type_Arena {
					mailCfgId = model.GlobalMailIdRushArena
					mailType = int32(serverproto.MailType_MailType_RushArena)
				} else if msg.RushType == model.Rush_Type_Map {
					mailCfgId = model.GlobalMailIdRushMap
					mailType = int32(serverproto.MailType_MailType_RushMap)
				} else if msg.RushType == model.Rush_Type_Pet {
					mailCfgId = model.GlobalMailRushPetRankReward
					mailType = int32(serverproto.MailType_MailType_RushPet)
				} else if msg.RushType == model.Rush_Type_Skill {
					mailCfgId = model.GlobalMailRushSkillRankReward
					mailType = int32(serverproto.MailType_MailType_RushSkill)
				}

				role.(model2.RoleLogicOuter).AddMail1(mailCfgId, mailType,
					data.RewardList, data.MailParamList, "", "")
			}

			if msg.RushType == model.Rush_Type_Tower {
				role.(*model2.Role).GetRoleTower().SetRankReward(msg.FinishRound)
			} else if msg.RushType == model.Rush_Type_Arena {
				role.(*model2.Role).GetRoleArena().SetRankReward(msg.FinishRound)
			} else if msg.RushType == model.Rush_Type_Map {
				role.(*model2.Role).GetRoleBattle().SetRankReward(msg.FinishRound)
			} else if msg.RushType == model.Rush_Type_Pet {
				role.(*model2.Role).GetRolePet().SetRankReward(msg.FinishRound)
			} else {
				role.(*model2.Role).GetRoleRush().SetRushRankReward(msg.RushType, msg.FinishRound)
			}
		})
	*/

	//技能冲榜
	serverproto.Handle_GAME_CSRushActivityReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRushActivityReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSRushActivityReq ms=%v", role.GetUUid(), msg)

		//先判定是否可以参加活动。
		role.(*model2.Role).GetRoleRush().OnRushSkillScoreChange()

		reqMsg := &serverproto.SSGetRushDataReq{
			Uid:      role.GetUUid(),
			RushType: msg.RushType,
		}
		model2.SendRankService(reqMsg)
	})
	//技能盛典排行请求
	serverproto.Handle_GAME_CSRushSkillActivityRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRushSkillActivityRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSRushSkillActivityRankReq ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).SendRank(msg)
	})

	serverproto.Handle_GAME_SCRushSkillActivityRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCRushSkillActivityRankAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SCRushSkillActivityRankAck ms=%v", role.GetUUid(), msg)

		role.ReplayGate(msg, true)
	})
	serverproto.Handle_GAME_CSRushActivityRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRushActivityRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSRushActivityRewardReq ms=%v", role.GetUUid(), msg)

		//如果是排行奖励，转发Rank
		reqMsg := &serverproto.SSGetRushRewardReq{
			Uid:        role.GetUUid(),
			RushType:   msg.RushType,
			RewardType: msg.RewardType,
		}
		model2.SendRankService(reqMsg)
	})
	//TODO WANGZHAOCAN 冲榜相关结束

	//////宠物系统
	serverproto.Handle_GAME_CSPetActivityReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetActivityReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetActivityReq ms=%v", role.GetUUid(), msg)

		//先判定是否可以参加活动。
		role.(*model2.Role).GetRolePet().OnRushPetScoreChange()

		reqMsg := &serverproto.SSGetRushDataReq{
			Uid:      role.GetUUid(),
			RushType: model.Rush_Type_Pet,
		}
		model2.SendRankService(reqMsg)
	})

	serverproto.Handle_GAME_CSPetActivityRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetActivityRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetActivityRankReq ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).SendRank(msg)
	})
	serverproto.Handle_GAME_SCPetActivityRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCPetActivityRankAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SCPetActivityRankAck ms=%v", role.GetUUid(), msg)

		role.ReplayGate(msg, true)
	})
	/*
		serverproto.Handle_GAME_CSPetActivityRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
			msg := ev.Msg().(*serverproto.CSPetActivityRewardReq)
			role := model2.RoleMag.GetRoleOrKick(cliId, ev)
			if role == nil {
				return
			}
			util.DebugF("uid=%v receive CSPetActivityRewardReq ms=%v", role.GetUUid(), msg)

			//如果是排行奖励，转发Rank
			reqMsg := &serverproto.SSGetRushRewardReq{
				Uid:        role.GetUUid(),
				RushType:   model.Rush_Type_Pet,
				RewardType: msg.RewardType,
			}
			model2.SendRankService(reqMsg)
		})daas
	*/

	//宠物培养(升级)
	serverproto.Handle_GAME_CSPetLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetLevelUpReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetLevelUp(msg.PetId)
	})
	//宠物进阶
	serverproto.Handle_GAME_CSPetAdvanceReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetAdvanceReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetAdvanceReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetAdvance(msg.PetId, msg.PetList)
	})
	//宠物图鉴奖励获取
	serverproto.Handle_GAME_CSPetManualRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetManualRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetManualRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetManualReward(msg.PetCfgId, msg.PetId, msg.PetAdvLevel)
	})
	//宠物技能升级(领悟)
	serverproto.Handle_GAME_CSPetSkillLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetSkillLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetSkillLevelUpReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetSkillLevelUp(msg.PetId, msg.CostPetId)
	})
	//宠物分解
	serverproto.Handle_GAME_CSPetDecomposeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetDecomposeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetDecomposeReq ms=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).PetDecompose(msg.PetIdList)
	})
	//宠物上阵/下阵
	serverproto.Handle_GAME_CSPetBattleReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetBattleReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetBattleReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetBattle(msg.BattleList)
	})
	//获取羁绊列表数据
	serverproto.Handle_GAME_CSPetBondListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetBondListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetBondListReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetBondListGet()
	})
	//获取其他援助玩家的宠物信息(羁绊信息) from db
	serverproto.Handle_GAME_SSPetQueryAssistInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetQueryAssistInfoAck)
		util.DebugF("receive SSPetQueryAssistInfoAck msg=%v", msg)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		role.(*model2.Role).GetRolePet().OnPetBondListAssistQuery(msg)
	})
	//宠物援助
	serverproto.Handle_GAME_CSPetAssistReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetAssistReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetAssistReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetAssist(msg.PetIdList)
	})
	//获取激活羁绊所需的宠物列表(援助列表)
	serverproto.Handle_GAME_CSPetBondAssistListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetBondAssistListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetBondAssistListReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetBondAssistListGet(msg.BondCfgId)
	})
	//from db 获取激活羁绊所需的宠物列表(援助列表)
	serverproto.Handle_GAME_SSPetBondAssistListAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetBondAssistListAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSPetBondAssistListAck msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRolePet().OnPetBondAssistListGet(msg)
	})
	//宠物羁绊激活(选择自己或者其他玩家宠物进行羁绊激活)
	serverproto.Handle_GAME_CSPetBondActiveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetBondActiveReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetBondActiveReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetBondActive(msg.BondDataList)
	})
	//最早收集到宠物最高进阶等级获取
	serverproto.Handle_GAME_CSPetAdvAchievementReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetAdvAchievementReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetBondActiveReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetAdvAchievement(msg.PetCfgId)
	})
	serverproto.Handle_GAME_SSPetAdvAchievementAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetAdvAchievementAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetBondActiveReq ms=%v", role.GetUUid(), msg)

		ackMsg := &serverproto.SCPetAdvAchievementAck{
			PetCfgId:        msg.PetCfgId,
			Brief:           msg.Brief,
			AchievementTime: msg.AchievementTime,
		}
		role.ReplayGate(ackMsg, true)
	})
	//宠物印记升级
	serverproto.Handle_GAME_CSPetEquipLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetEquipLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetEquipLevelUpReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetEquipLevelUp(msg.PetEquipId)
	})
	//宠物印记启用
	serverproto.Handle_GAME_CSPetEquipUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetEquipUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetEquipUpReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetEquipUp(msg.PetId, msg.SlotList)
	})
	//宠物印记卸下
	serverproto.Handle_GAME_CSPetEquipDownReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetEquipDownReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetEquipDownReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetEquipDown(msg.PetId, msg.SlotIndex)
	})
	//宠物系统优化
	//背包界面只下发必要数据，后续通过打开宠物界面主动获取
	serverproto.Handle_GAME_CSPetDetailInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetDetailInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetDetailInfoReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetGetPetDetailInfo(msg.PetIdList)
	})

	////宠物觉醒
	//觉醒槽位解锁
	serverproto.Handle_GAME_CSPetQiyueSlotUnlockReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetQiyueSlotUnlockReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetQiyueSlotUnlockReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetQiyueUnlock(msg.HeroId)
	})
	//契约操作添加宠物(替换也使用该协议)
	serverproto.Handle_GAME_CSPetQiyueSlotInReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetQiyueSlotInReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetQiyueSlotInReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetQiyueSlotIn(msg.HeroId, msg.SlotIdx, msg.PetId)
	})
	//卸载契约槽宠物
	serverproto.Handle_GAME_CSPetQiyueSlotOutReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetQiyueSlotOutReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetQiyueSlotOutReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetQiyueSlotOut(msg.HeroId, msg.SlotIdx)
	})
	//契约总属性面板获取
	serverproto.Handle_GAME_CSPetQiyueBattlePetAttrReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetQiyueBattlePetAttrReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSPetQiyueBattlePetAttrReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).PetQiyueBattlePetAttr()
	})

	//////远征之门expedition
	//点击挑战按钮
	serverproto.Handle_GAME_CSExpeditionChallengePreReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionChallengePreReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionChallengePreReq ms=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).ExpeditionChallengePre(msg.ExpeditionType)
	})
	//客户端上报hp，sp，并获取奖励(buff)
	serverproto.Handle_GAME_CSExpeditionChallengeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionChallengeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionChallengeReq ms=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).ExpeditionChallenge(msg.ExpeditionType, msg.BattleLevel,
			msg.HeroInfoList, msg.BossChangeHpList, msg.BattleTime, msg.BattleIdx, msg.Flag)
	})
	//战斗结束后选择buff id
	serverproto.Handle_GAME_CSExpeditionSelectBuffReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionSelectBuffReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionSelectBuffReq ms=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).ExpeditionBuffSelect(msg.SelectBuffId)
	})
	//领取区域地图宝箱奖励(未领取在隔天重置时统一发送邮件)
	serverproto.Handle_GAME_CSExpeditionRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).ExpeditionReward(msg.ExpeditionType, msg.BossIdx)
	})
	//设置上阵玩家
	serverproto.Handle_GAME_CSExpeditionBattleHeroReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionBattleHeroReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionBattleHeroReq ms=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).ExpeditionBattleHero(msg.BattleHeroList)
	})
	//求助其他玩家(自己英雄死亡发送求助操作)
	serverproto.Handle_GAME_CSExpeditionCallForHelpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionCallForHelpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionCallForHelpReq ms=%v", role.GetUUid(), msg)

		//为0表示公会求助，如果不存在公会返回错误
		role.(model2.BattleLogicOuter).ExpeditionCallForHelp(msg.AssistHelpUid)
	})
	//救助 求助的玩家
	serverproto.Handle_GAME_CSExpeditionHelpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionHelpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionHelpReq ms=%v", role.GetUUid(), msg)

		//为0表示公会求助，如果不存在公会返回错误
		role.(model2.BattleLogicOuter).ExpeditionHelp(msg.BeHelpedUid, msg.MsgType, msg.HelpMsgSendTime)
	})
	//from social
	serverproto.Handle_GAME_SSExpeditionHelpAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSExpeditionHelpAck)
		util.DebugF("uid=%v receive SSExpeditionHelpAck msg=%v", msg.FromUid, msg)
		role := model2.RoleMag.GetRoleFromUUid(msg.FromUid.Uid)
		if role == nil {
			return
		}

		role.(*model2.Role).GetRoleBattle().OnExpeditionHelp(msg.BeHelpedUid, msg.Error)
	})
	//from db
	serverproto.Handle_GAME_SSExpeditionDBHelpAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSExpeditionDBHelpAck)
		util.DebugF("uid=%v receive SSExpeditionDBHelpAck msg=%v", msg.FromUid, msg)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		//成功救助
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(*model2.Role).GetRoleBattle().OnExpeditionHelp(msg.BeHelpedUid, msg.Error)
		} else {
			ackMsg := &serverproto.SCExpeditionHelpAck{
				Error: msg.Error,
			}
			role.ReplayGate(ackMsg, true)
		}
	})
	//from social
	//来自其他game的救助消息 game -> social -> other game
	serverproto.Handle_GAME_SSExpeditionHelpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSExpeditionHelpReq)
		util.DebugF("receive SSExpeditionHelpReq form other game server msg=%v", msg)

		beHelpedRole := model2.RoleMag.GetRoleFromUUid(msg.BeHelpedUid)
		if beHelpedRole == nil {
			beHelpedRole = model2.RoleMag.GetRoleFromOffline(msg.BeHelpedUid)
		}

		ssAckMsg := &serverproto.SSExpeditionHelpAck{
			FromUid:     msg.FromUid,
			BeHelpedUid: msg.BeHelpedUid,
		}
		if beHelpedRole == nil {
			ssAckMsg.Error = int32(serverproto.ErrorCode_ERROR_EXPEDITION_NOT_FIND_SERVICE_ID)
		} else {
			ret := beHelpedRole.(*model2.Role).GetRoleBattle().OnExpeditionBeHelp(msg.FromUid.Uid, msg.BeHelpedUid, msg.HelpMsgSendTime)
			if ret == serverproto.ErrorCode_ERROR_OK {
				//发送给被救助玩家
				ntfMsg := &serverproto.SCExpeditionCallForHelpNtf{
					AssistState: 1,
					Brief:       msg.FromUid,
				}
				beHelpedRole.ReplayGate(ntfMsg, true)
			}
			ssAckMsg.Error = int32(ret)
		}

		//回复消息给发起确认救助的玩家
		model.ServiceReplay(ev, ssAckMsg)
	})
	//勇士积分排行
	serverproto.Handle_GAME_CSExpeditionScoreRankListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionScoreRankListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionScoreRankListReq ms=%v", role.GetUUid(), msg)

		role.(model2.BattleLogicOuter).ExpeditionScoreRankList(msg.StartIdx)
	})
	//from rank
	serverproto.Handle_GAME_SSExpeditionScoreRankListAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSExpeditionScoreRankListAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSExpeditionScoreRankListAck ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleBattle().OnExpeditionRankList(msg)
	})
	//远征之门通关地图奖励获取
	serverproto.Handle_GAME_CSExpeditionPassRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExpeditionPassRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSExpeditionPassRewardReq ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).ExpeditionPassReward(msg.ExpeditionType)
	})
	//////精彩活动 Activities
	serverproto.Handle_GAME_CSActivitiesRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitiesRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitiesRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitiesReward(msg.ActivityId, msg.Param, msg.RewardNum)
	})
	//精彩活动，宠物兑换
	serverproto.Handle_GAME_CSActivitiesExchangeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitiesExchangeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitiesExchangePetReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitiesExchange(msg)
		return
	})

	//精彩活动，集字提醒设置
	serverproto.Handle_GAME_CSActivitiesWordNoticeSetReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitiesWordNoticeSetReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitiesWordNoticeSetReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).SetCollectionNotice(msg.ActivityId, msg.CollectId, msg.NoNotice)
	})

	//14日阶段目标积分奖励获取
	serverproto.Handle_GAME_CSActivitiesScoreRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitiesScoreRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitiesScoreRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitiesScoreReward(msg.ActivityId, msg.BoxIdx)
	})
	//获取首充奖励
	serverproto.Handle_GAME_CSActivitiesFirstChargeRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitiesFirstChargeRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitiesFirstChargeRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitiesFirstChargeReward()
	})
	//获取全局服务器数据
	serverproto.Handle_GAME_CSActivitiesCollectionServerDataReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitiesCollectionServerDataReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitiesCollectionServerDataReq ms=%v", role.GetUUid(), msg)

		ssMsg := &serverproto.SSActivitiesCollectionServerDataReq{
			ActivityId: msg.ActivityId,
		}
		role.(*model2.Role).SendRank(ssMsg)
	})
	serverproto.Handle_GAME_SSActivitiesCollectionServerDataNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSActivitiesCollectionServerDataNtf)
		util.DebugF("receive SSActivitiesCollectionServerDataNtf ms=%v", msg)

		ackMsg := &serverproto.SCActivitiesCollectionServerDataAck{
			ActivityId: msg.ActivityId,
		}
		ackMsg.DataList = append(ackMsg.DataList,
			&serverproto.KeyValueType{Key: msg.RewardIdx, Value: msg.ServerCurNum})
		model2.RoleMag.SendMsg2OnlinePlayer(ackMsg, 0)
	})

	//from db
	serverproto.Handle_GAME_SSActivitiesCollectionServerDataAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSActivitiesCollectionServerDataAck)
		util.DebugF("uid=%v receive SSActivitiesCollectionServerDataAck msg=%v", cliId.SessID, msg)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		//获取数据
		if msg.RewardIdx <= 0 {
			ackMsg := &serverproto.SCActivitiesCollectionServerDataAck{
				ActivityId: msg.ActivityId,
				Error:      msg.Error,
				DataList:   msg.DataList,
			}
			role.ReplayGate(ackMsg, true)
		} else {
			//全局数据方式兑换奖励
			role.(*model2.Role).GetRoleActivity().OnRewardByServer(msg)
			//role.(*model2.Role).GetRoleActivity().OnCollectionRewardByServer(msg)
		}
	})
	//消耗道具获得好感度(3.8活动)
	serverproto.Handle_GAME_CSActivitiesLikabilityRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitiesLikabilityRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitiesLikabilityRewardReq ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).ActivitiesLikability(msg.ActivityId, msg.ItemCfgId, msg.LikabilityLevel)
	})
	//刷新转盘道具(未开启本轮时操作)
	serverproto.Handle_GAME_CSActivityWheelRefreshReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivityWheelRefreshReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivityWheelRefreshReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivityWheelRefresh(msg.ActivityId)
	})
	//开启本轮转盘(开始获取奖励)
	serverproto.Handle_GAME_CSActivityWheelOpenRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivityWheelOpenRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivityWheelOpenRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivityWheelOpenReward(msg.ActivityId)
	})
	//转一次/转本轮(获取所有奖励)
	serverproto.Handle_GAME_CSActivityWheelRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivityWheelRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivityWheelRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivityWheelReward(msg.ActivityId, msg.RewardAll)
	})
	//关闭本轮转盘
	serverproto.Handle_GAME_CSActivityWheelCloseRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivityWheelCloseRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivityWheelCloseRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivityWheelClose(msg.ActivityId)
	})
	//活动召唤
	serverproto.Handle_GAME_CSActivitySummonReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitySummonReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitySummonReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitySummon(msg.ActivityId, msg.SummonCount)
	})

	//活动签到
	serverproto.Handle_GAME_CSActivitySignInReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitySignInReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitySignInReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitySignIn(msg.ActivityId)
	})

	// bt 砸蛋活动(金蛋，彩蛋)
	serverproto.Handle_GAME_CSActivitySmashEggsReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitySmashEggsReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitySmashEggsReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitySmashEggs(msg.ActivityId, msg.DrawType, msg.DrawCount)
	})
	// 砸蛋活动(金蛋，彩蛋) 获得奖励消息记录获取
	serverproto.Handle_GAME_CSActivitySmashEggsMsgReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActivitySmashEggsMsgReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSActivitySmashEggsMsgReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).ActivitySmashEggsMsg(msg.ActivityId, msg.DrawType)
	})

	//////拉新 invitation
	//获取邀请码
	serverproto.Handle_GAME_CSInvitationNumberReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSInvitationNumberReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSInvitationReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).InvitationNumberGet()
	})
	//from db
	serverproto.Handle_GAME_SSInvitationGenNumberAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationGenNumberAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSInvitationGenNumberAck ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleInvitation().OnInvitationNumberGet(msg.InvitationNumber, msg.MasterUid)
	})
	//根据邀请码获取玩家简介信息
	serverproto.Handle_GAME_CSInvitationNumberUserInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSInvitationNumberUserInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSInvitationNumberUserInfoReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).InvitationNumberUserInfoGet(msg.InvitationNumber)
	})
	//from db
	serverproto.Handle_GAME_SSInvitationNumberUserInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationNumberUserInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSInvitationNumberUserInfoAck ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleInvitation().OnInvitationNumberUserInfoGet(msg)
	})
	//填写其他玩家邀请码成为学员
	serverproto.Handle_GAME_CSInvitationBeToMemberReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSInvitationBeToMemberReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSInvitationBeToMemberReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).InvitationBeToMember(msg.MasterInvitationNumber, msg.MasterUid)
	})

	//填写其他玩家邀请码成为学员
	serverproto.Handle_GAME_CSDrawCardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSDrawCardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSDrawCardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnDrawReq(msg.DrawType, msg.DrawCount)
	})

	//from game -> social->other game
	//from social 来自其他game服务器的成为导师成员请求
	//selfUid 发起请求成为masteruid的成员
	serverproto.Handle_GAME_SSInvitationBeToMemberReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationBeToMemberReq)
		util.DebugF("uid=%v receive SSInvitationBeToMemberReq ms=%v", msg.MasterUid, msg)
		masterRole := model2.RoleMag.GetRoleFromUUid(msg.MasterUid)
		if masterRole == nil {
			masterRole = model2.RoleMag.GetRoleFromOffline(msg.MasterUid)
		}

		ssAckMsg := &serverproto.SSInvitationBeToMemberAck{
			MasterNumber: msg.MasterNumber,
			MasterUid:    msg.MasterUid,
			SelfUid:      msg.SelfUid,
		}
		if masterRole == nil {
			ssAckMsg.Error = int32(serverproto.ErrorCode_ERROR_EXPEDITION_NOT_FIND_SERVICE_ID)
			return
		} else {
			ret := masterRole.(*model2.Role).GetRoleInvitation().InvitationBeToMemberSSReq(msg.MasterNumber, msg.MasterUid, msg.SelfUid)
			ssAckMsg.Error = int32(ret)
		}
		model.ServiceReplay(ev, ssAckMsg)
	})
	//from self game->social->other game->social->self game SSInvitationBeToMemberAck
	serverproto.Handle_GAME_SSInvitationBeToMemberAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationBeToMemberAck)
		util.DebugF("uid=%v receive SSInvitationBeToMemberAck ms=%v", msg.SelfUid, msg)
		masterRole := model2.RoleMag.GetRoleFromUUid(msg.SelfUid.Uid)
		if masterRole == nil {
			masterRole = model2.RoleMag.GetRoleFromOffline(msg.SelfUid.Uid)
		}

		masterRole.(*model2.Role).GetRoleInvitation().OnInvitationBeToMember(msg.MasterNumber, msg.MasterUid, msg.SelfUid, msg.Error)
	})
	//from db master玩家最近未上线，selfUid进行db操作
	serverproto.Handle_GAME_SSInvitationBeToMemberDBAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationBeToMemberDBAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSInvitationBeToMemberDBAck ms=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleInvitation().OnInvitationBeToMember(msg.MasterNumber, msg.MasterUid, msg.SelfUid, msg.Error)
	})
	//拍一拍
	serverproto.Handle_GAME_CSInvitationClickReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSInvitationClickReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSInvitationClickReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).InvitationClick(msg.MemberUidList)
	})
	//拍一拍回应
	serverproto.Handle_GAME_CSInvitationClickReplayReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSInvitationClickReplayReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSInvitationClickReplayReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).InvitationClickReplay(msg.MasterUid)
	})
	//导师删除学员
	serverproto.Handle_GAME_CSInvitationDelMemberReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSInvitationDelMemberReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSInvitationDelMemberReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).InvitationDelMember(msg.DelMemberUidList)
	})
	//from other game
	//通知学员解除关系
	serverproto.Handle_GAME_SSInvitationDelMemberNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationDelMemberNtf)
		memberRole := model2.RoleMag.GetRole(cliId)
		if memberRole == nil {
			return
		}
		util.DebugF("uid=%v receive SSInvitationDelMemberNtf ms=%v", memberRole.GetUUid(), msg)

		memberRole.(*model2.Role).GetRoleInvitation().OnInvitationDelFromMaster(msg.MasterUid)
	})
	//获取任务奖励
	serverproto.Handle_GAME_CSInvitationTaskRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSInvitationTaskRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSInvitationTaskRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).InvitationReward(msg.TaskIdList)
	})
	//from other game
	serverproto.Handle_GAME_SSInvitationMemberNoticeMasterReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationMemberNoticeMasterReq)
		masterRole := model2.RoleMag.GetRoleFromUUid(msg.MasterUid)
		if masterRole == nil {
			masterRole = model2.RoleMag.GetRoleFromOffline(msg.MasterUid)
		}
		if masterRole == nil {
			ssAckMsg := &serverproto.SSInvitationMemberNoticeMasterAck{
				Error:     int32(serverproto.ErrorCode_ERROR_EXPEDITION_NOT_FIND_SERVICE_ID),
				MasterUid: msg.MasterUid,
				SelfUid:   msg.SelfUid,
				Param:     msg.Param,
			}
			model.ServiceReplay(ev, ssAckMsg)
			return
		}

		util.DebugF("uid=%v receive SSInvitationMemberNoticeMasterReq ms=%v", msg.MasterUid, msg)

		masterRole.(*model2.Role).GetRoleInvitation().OnInvitationNoticeMaster(msg)
	})
	//from other game or from social
	serverproto.Handle_GAME_SSInvitationMemberNoticeMasterAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationMemberNoticeMasterAck)
		//todo...
		ssDBNtfMsg := &serverproto.SSInvitationMemberNoticeMasterNtf{
			MasterUid: msg.MasterUid,
			SelfUid:   msg.SelfUid,
			Param:     msg.Param,
		}
		model2.SendDb(ssDBNtfMsg)
	})

	//////支付处理
	//获取充值信息(订单信息，商品信息)
	serverproto.Handle_GAME_CSPayInfoGetReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPayInfoGetReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSPayInfoGetReq ms=%v", role.GetUUid(), msg)

		bRet := role.(model2.RoleLogicOuter).CheckRushShopInfoGet(msg.GoodsType, msg.GoodsId, msg.Count)
		if bRet {
			return
		}
		role.(model2.RoleLogicOuter).PayInfoGet(msg.GoodsType, msg.GoodsId, msg.Count, 0, 0, 0, "")
	})

	serverproto.Handle_GAME_CSPayOrderCompleteReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPayOrderCompleteReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSPayOrderCompleteReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnPayCallback2(msg.CpOrderId)
	})

	serverproto.Handle_GAME_SSPayOrderDbAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPayOrderDbAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		//util.InfoF("uid=%v receive CSPayOrderCompleteReq ms=%v", role.GetUUid(), msg)
		b := role.(model2.RoleLogicOuter).CheckOrderInfo(msg.PayOrderInfo)
		if !b {
			ackMsg := &serverproto.SCPayOrderCompleteAck{
				Error: 1,
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		role.(model2.RoleLogicOuter).OnPayCallback(msg.PayOrderInfo, true, false)
	})

	serverproto.Handle_GAME_SSPayOrderCreateReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPayOrderCreateReq)
		uid, _ := strconv.ParseUint(msg.Uid, 10, 64)
		role := model2.RoleMag.GetRoleFromUUid(uid)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSPayInfoGetReq ms=%v", role.GetUUid(), msg)

		bRet := role.(model2.RoleLogicOuter).CheckRushShopInfoGet(msg.GoodsType, msg.GoodsId, msg.Count)
		if bRet {
			return
		}
		role.(model2.RoleLogicOuter).PayInfoGet(msg.GoodsType, msg.GoodsId, msg.Count, 0, 0, msg.OrderCode, msg.OrderId)
	})

	//获取充值信息(订单信息，商品信息)
	serverproto.Handle_GAME_SSGetRushShopBuyAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushShopBuyAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGetRushShopBuyAck ms=%v", role.GetUUid(), msg)
		role.(model2.RoleLogicOuter).PayInfoGet(msg.ShopType, msg.GoodsId, msg.GoodsNum, msg.RushStage, msg.RushRound, 0, "")
	})

	//from db(pay order info)
	serverproto.Handle_GAME_SSPayInfoSaveAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPayInfoSaveAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSPayInfoSaveAck ms=%v", role.GetUUid(), msg)

		ackMsg := &serverproto.SCPayInfoGetAck{}
		if msg.Error != int32(serverproto.ErrorCode_ERROR_OK) {
			ackMsg.Error = msg.Error
		} else {
			ackMsg.GoodsType = msg.PayOrderInfo.GoodsType
			ackMsg.GoodsId = msg.PayOrderInfo.GoodsId
			ackMsg.GoodsName = msg.PayOrderInfo.GoodsName
			ackMsg.CpOrderId = msg.PayOrderInfo.CpOrderId
			ackMsg.Amount = msg.PayOrderInfo.Amount
			ackMsg.Count = msg.PayOrderInfo.Count
			ackMsg.SId = msg.PayOrderInfo.SId
		}
		role.ReplayGate(ackMsg, true)
	})
	//上线获取成功成但是没有获取奖励的订单数据
	serverproto.Handle_GAME_CSPayInfoOrderOKListGetReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPayInfoOrderOKListGetReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSPayInfoOrderOKListGetReq ms=%v", role.GetUUid(), msg)

		//获取充值成功但是没有到账的订单id列表
		ssPayMsg := &serverproto.SSPayInfoOrderOKListGetReq{}
		role.(*model2.Role).SendDb(ssPayMsg)
	})
	//from db 上线获取成功成但是没有获取奖励的订单数据ack
	serverproto.Handle_GAME_SSPayInfoOrderOkListGetAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPayInfoOrderOkListGetAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSPayInfoOrderGetAck ms=%v", role.GetUUid(), msg)

		for idx := 0; idx < len(msg.PayOrderOkList); idx++ {
			role.(model2.RoleLogicOuter).OnPayCallback(msg.PayOrderOkList[idx], true, true)
		}
	})
	//from gmweb->social 充值成功后gmweb通知给game服务器
	serverproto.Handle_GAME_SSPayInfoOrderNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPayInfoOrderNtf)

		util.InfoF("uid=%v receive SSPayInfoOrderNtf ms=%v", msg.PayOrderInfo.Uid, msg)

		payRole := model2.RoleMag.GetRoleFromUUid(msg.PayOrderInfo.Uid)
		if payRole == nil {
			payRole = model2.RoleMag.GetRoleFromOffline(msg.PayOrderInfo.Uid)
		}
		if payRole != nil {
			payRole.(model2.RoleLogicOuter).OnPayCallback(msg.PayOrderInfo, true, false)
		}
	})

	// bt服务器版本使用
	// 充值钱包商店购买(假钱购买)
	serverproto.Handle_GAME_CSCreditRechargeShopItemBuyReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCreditRechargeShopItemBuyReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSCreditRechargeShopItemBuyReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).PayInfoGetForCreditRecharge(msg.GoodsId, msg.Count)
	})
	// 特权卡商店每日礼包领取
	serverproto.Handle_GAME_CSRuneSpecialPrivilegeRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRuneSpecialPrivilegeRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSCreditRechargeShopItemBuyReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).SpecialPrivilegeReward()
	})

	serverproto.Handle_GAME_CSRuneShopInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRuneShopInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSRuneShopInfoReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetRuneShopInfo(msg.ShopType, msg.SubShop)
	})

	serverproto.Handle_GAME_CSExploreInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExploreInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSExploreInfoReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnRuneExploreInfo()
	})

	serverproto.Handle_GAME_CSExploreExtraRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExploreExtraRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSExploreExtraRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnRuneMaxLvlAward()
	})

	// 等级奖励领取
	serverproto.Handle_GAME_CSExploreRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSExploreRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSExploreRewardReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnRuneReward(msg)
	})

	//Cheat 作弊加速
	serverproto.Handle_GAME_CSAntiCheatReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSAntiCheatReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive CSAntiCheatReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnAntiCheatReq(msg.CheatType)
	})

	//礼包码获取奖励
	serverproto.Handle_GAME_CSGiftRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGiftRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive CSGiftRewardReq ms=%v", role.GetUUid(), msg)
		msg.Uuid = role.GetUUid()
		role.(*model2.Role).SendSocial(msg)
	})
	//from social
	serverproto.Handle_GAME_SCGiftRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGiftRewardAck)

		role := model2.RoleMag.GetRoleFromUUid(msg.Uuid)
		if role == nil {
			role = model2.RoleMag.GetRoleFromOffline(msg.Uuid)
			if role == nil {
				util.ErrorF("uid=%v receive SCGiftRewardAck role not find msg=%v", msg.Uuid, msg)
				return
			}
		}
		util.DebugF("uid=%v receive SCGiftRewardAck msg=%v", role.GetUUid(), msg)

		//处理发货逻辑
		role.(model2.RoleLogicOuter).GiftReward(msg)
		role.ReplayGate(msg, true)
	})
	//问卷奖励获取
	serverproto.Handle_GAME_CSQuestionRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		//msg := ev.Msg().(*serverproto.CSQuestionRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive CSQuestionRewardReq", role.GetUUid())
		role.(model2.RoleLogicOuter).QuestionReward()
	})

	//上线获取信物数据
	serverproto.Handle_GAME_CSOnlineGetKeepSakeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		//	msg := ev.Msg().(*serverproto.CSOnlineGetKeepSakeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive CSOnlineGetKeepSakeReq", role.GetUUid())
		role.(model2.RoleLogicOuter).GetKeepSake()
	})
	serverproto.Handle_GAME_CSKeepSakeRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSKeepSakeRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive CSKeepSakeRankReq", role.GetUUid())
		//转发到排行榜服务器
		role.(*model2.Role).SendRank(msg)
	})
	serverproto.Handle_GAME_SCKeepSakeRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCKeepSakeRankAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive SCKeepSakeRankAck", role.GetUUid())
		//转发到排行榜服务器
		role.(*model2.Role).ReplayGate(msg, true)
	})

	serverproto.Handle_GAME_CSKeepSakeLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSKeepSakeLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive CSKeepSakeLevelUpReq", role.GetUUid())
		role.(model2.RoleLogicOuter).KeepSakeLevelUp(msg.KeepSakeId)
	})

	//获取英雄属性，宠物属性
	serverproto.Handle_GAME_CSActorAttrGetReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSActorAttrGetReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.DebugF("uid=%v receive CSActorAttrGetReq", role.GetUUid())
		role.(model2.BattleLogicOuter).GetActorAttr(msg)
	})

	serverproto.Handle_GAME_CSHeadOperateReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeadOperateReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSHeadOperateReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnHeadOperate(msg)
	})

	serverproto.Handle_GAME_CSHeadDataReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSHeadDataReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSHeadOperateReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnHeadData(msg)
	})

	// 使用许愿箱
	serverproto.Handle_GAME_CSWishBoxUseReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSWishBoxUseReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSWishBoxUseReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnWishUse(msg)
	})

	// 解锁许愿箱
	serverproto.Handle_GAME_CSWishUnlockSlotReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSWishUnlockSlotReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSWishUnlockSlotReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnWishSlotUnlock(msg)
	})

	// 加速领奖许愿想
	serverproto.Handle_GAME_CSWishSlotReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSWishSlotReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSWishSlotReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).OnWishSlotAction(msg)
	})

	//合服公告请求
	serverproto.Handle_GAME_CSCombineServerInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSCombineServerInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSCombineServerInfoReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GetCombineServerInfo()
	})

	////bt
	// bt服务器获取商店信息
	// 充值钱包商店,特权卡商店
	serverproto.Handle_GAME_CSBTShopInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBTShopInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSBTShopInfoReq ms=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).GetBTShopInfo(msg.ShopType, msg.SubShop)
	})
	// bt波利商城
	serverproto.Handle_GAME_CSBoliShopInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBoliShopInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSBoliShopInfoReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).BoliShopInfo()
	})
	serverproto.Handle_GAME_CSBoliShopLevelUpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBoliShopLevelUpReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSBoliShopLevelUpReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).BoliLevelUp(msg.Num)
	})
	serverproto.Handle_GAME_CSBoliShopRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBoliShopRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSBoliShopRewardReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).BoliReward(msg.RewardLevel, msg.Idx)
	})
	serverproto.Handle_GAME_CSBoliShopBuyReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBoliShopBuyReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSBoliShopBuyReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).BoliShopBuy(msg.GoodsId, msg.GoodsNum)
	})
	//RO币礼包购买
	serverproto.Handle_GAME_CSBTRoCoinShopItemBuyReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBTRoCoinShopItemBuyReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSBTRoCoinShopItemBuyReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).PayInfoGetForRoCoin(msg.GoodsId, msg.GoodsNum)
	})
	//超值首充 & 百元大礼包
	serverproto.Handle_GAME_CSBTFirstRechargeRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBTFirstRechargeRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSBTFirstRechargeRewardReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).FirstRechargeReward(msg.RewardIdx)
	})
	serverproto.Handle_GAME_CSBTRecharge100RewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBTRecharge100RewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.DebugF("uid=%v CSBTRecharge100RewardReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleBTRouter).Recharge100Reward()
	})
}