RoServer/RO_Server_Trunk-branch_0.1.39/roserver/db/model/orm_helper.go

package model

import (
	"encoding/base64"
	"errors"
	"math/rand"
	"rocommon"
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/baseserver/set"
	"roserver/serverproto"
	"runtime/debug"
	"strconv"
	"strings"
)

const (
	//角色列表信息前缀
	AccountPrefix = "account_" //[key-value]
	//玩家基础信息数据库前缀
	RoleBasePrefix = "role_" //[key-value]
	//玩家伙伴信息数据库前缀
	RoleHeroDataPrefix = "role_hero_" //field为hero的动态id [hmap]
	//装备前缀
	RoleEquipDataPrefix = "role_equip_" //暂时作为一个整体存放

	//神器前缀
	RoleSkillEquipDataPrefix      = "role_skill_equip_" //暂时作为一个整体存放
	RoleSkillEquipDataPrefix_base = "base"
	RoleSkillEquipDataPrefix_list = "skill_equip"

	//背包前缀
	RoleBagDataPrefix = "role_bag_"
	//伙伴碎片前缀
	RoleChipDataPrefix = "role_chip_"
	//角色AOI地图前缀
	RoleMapDataPrefix = "role_map_"
	//卡片数据
	RoleCardDataPrefix = "role_card_"
	//时装数据
	RoleFashionDataPrefix = "role_fashion_"
	//战斗数据
	RoleBattleDataPrefix = "role_battle_"
	//任务
	RoleTaskDataPrefix = "role_task_"
	//困难模式任务
	RoleTaskDataHardPrefix = "role_task_hard"
	//困难模式任务
	RoleTaskDataHard2Prefix = "role_task_hard2"
	//竞技场数据
	RoleArenaDataPrefix = "role_arena_"
	//小红点
	RoleRedDataPrefix = "role_red_"
	//邮件
	RoleMailDataPrefix = "role_mail_"
	//competition赛季玩法数据
	RoleCompetitionDataPrefix = "role_comp_"
	//商店数据
	RoleShopDataPrefix = "role_shop_"
	//活动
	RoleActivityDataPrefix = "role_activity_"
	//爬塔
	RoleTowerDataPrefix = "role_tower_"
	//公会
	RoleGuildDataPrefix = "role_guild_"
	//重名处理
	RoleNickNamePrefix = "role_nickname_"
	//玩家简介信息
	RolePlayerBriefPrefix = "role_Brief_"
	//离线缓存消息
	RoleChatOfflineMsgPrefix = "chat:offline" //self_target
	//玩家抽卡信息
	RoleDrawDataPrefix = "role_draw_"
	//卢恩商店信息
	RoleRuneDataPrefix = "role_rune_"
	//统计数据
	RoleStatisticDataPrefix = "role_Statistic_"
	//信物
	RoleKeepSakeDataPrefix = "role_keepsake_"
	//上阵玩家/宠物属性
	RoleBattleAttrPrefix = "role_bttle_attr_"
	//冲榜数据
	RoleRushDataPrefix = "role_rush_"
	//跨服数据
	//远航试炼
	RoleCrossPrefix = "role_cross_"
	//称号数据
	RoleHeadDataPrefix = "role_head_"
	//称号数据
	RoleWishBoxDataPrefix = "role_WishBox_"

	//social
	//用来存储搜索默认名字的列表，提高效率
	RoleNameSearchListPrefix = "namesearch_"
	//关注列表
	RoleSocialFriendSubListPrefix = "role_fsublist_" //list
	//粉丝列表
	RoleSocialFriendFansListPrefix = "role_ffanslist_" //list
	//黑名单列表
	RoleSocialFriendBlackListPrefix = "role_fblacklist_" //list

	//激活码
	RoleActiveCodeUsedListPrefix = "role_activecode_"

	//获取全局邮件(后台发送邮件时玩家不在线， 通过上线后进行获取)
	RoleGlobalMailListPrefix = "gmail_list_"
	RoleGlobalMailPrefix     = "gmail_"

	PlatformOpenIdConnectInfoPrefix = "pp_conn_" //openid对应的连接信息

	//pet
	RolePetDataPrefix              = "role_pet_"
	RolePetDataFieldPrefix_base    = "base"
	RolePetDataFieldPrefix_petlist = "pet"
	RolePetDataFieldPrefix_bond    = "bond"
	RolePetAssistDataPrefix        = "role_pet_ass_"
	//最早收集到宠物最高进阶等级获取
	RolePetAchievementPrefix = "gpet_achive" //

	//invitation
	RoleInvitationNumberPrefix = "role_invi_num_" //邀请码对应的玩家，用于快速查询
	InvitationNumberPrefix     = "invi_num_"      //生成邀请码的key
	RoleInvitationPrefix       = "role_invi_"     //个人数据
	RoleInvitationLogPrefix    = "role_invi_log_"

	//bt
	RoleBTDataPrefix     = "role_bt_"
	RoleBTBoliDataPrefix = "btboli"
	RoleBTBaseDataPrefix = "base"
	CdkNormal            = "cdk_normal" //非通码cdk
)

func ConfigInit() {
	defer func() {
		if err := recover(); err != nil {
			util.InfoF("Stack---::%v\n%s\n", err, string(debug.Stack()))
			panic(nil)
		}
	}()

	sConfig := service.GetServiceConfig()
	model.BaseConfigInit(sConfig)
}

func DelUserConnInfo(connInfo *serverproto.UserConnectInfo, openId, platform string) {
	// 区分不同平台
	openId = model.ConvertPlatform(openId, platform)
	err := model.SetMessageToRedis(PlatformOpenIdConnectInfoPrefix, openId, connInfo)
	if err != nil {
		util.WarnF("[initUserConnInfo] del userConnectionInfo err=%v", err)
	}
}

// 赛季数据保存
func ServerCompetitionGet(ssAckMsg *serverproto.SSGetServerCompetitionAck) {
	retList, err := service.GetRedis().HGetAll(model.ServerCompetitionPrefix).Result()
	if err != nil {
		return
	}
	for k, v := range retList {
		if k == "roundEndTime" {
			err = model.GetDecodeMessage(ssAckMsg.RounInfo, v)
			if err != nil {
				continue
			}
			continue
		}

		if k == "towerRound" {
			err = model.GetDecodeMessage(ssAckMsg.TowerInfo, v)
			if err != nil {
				continue
			}
			continue
		}
		infoData := &serverproto.ServerCompetitionInfo{}
		err = model.GetDecodeMessage(infoData, v)
		if err != nil {
			continue
		}
		ssAckMsg.CompetitionDataList = append(ssAckMsg.CompetitionDataList, infoData)
	}

}
func ServerCompetitionSave(ntfMsg *serverproto.SSServerCompetitionInfoSaveNtf) {
	if ntfMsg.CompetitionData != nil {
		fieldStr := strconv.Itoa(int(ntfMsg.CompetitionData.CompetitionId))

		err, msgStr := model.GetEncodeMessage(ntfMsg.CompetitionData)
		if err != nil {
			return
		}
		_, err = service.GetRedis().HSet(model.ServerCompetitionPrefix, fieldStr, msgStr).Result()
		if err != nil {
			util.WarnF("ServerCompetitionSave err=%v msg=%v", err, *ntfMsg)
		}
	}
	if ntfMsg.RoundInfo != nil {
		err, msgStr := model.GetEncodeMessage(ntfMsg.RoundInfo)
		if err != nil {
			return
		}
		_, err = service.GetRedis().HSet(model.ServerCompetitionPrefix, "roundEndTime", msgStr).Result()
		if err != nil {
			util.WarnF("ServerCompetitionSave round end time err=%v msg=%v", err, *ntfMsg)
		}
	}
	if ntfMsg.TowerInfo != nil {
		err, msgStr := model.GetEncodeMessage(ntfMsg.TowerInfo)
		if err != nil {
			return
		}
		_, err = service.GetRedis().HSet(model.ServerCompetitionPrefix, "towerRound", msgStr).Result()
		if err != nil {
			util.WarnF("ServerCompetitionSave round end time err=%v msg=%v", err, *ntfMsg)
		}
	}
}

// 获取角色信息列表
func GetRoleListFromRedis(openId string, zone int32, msg interface{}) error {
	return model.GetMessageFromRedis(AccountPrefix, strconv.Itoa(int(zone))+"_"+openId, msg)
}

// 获取是否关闭注册
func IsServerCloseRegister() bool {
	closeState, err := service.GetRedis().HGet(model.ServerPrefix, "registerclose").Result()
	if err == nil && closeState == "1" {
		return true
	}
	return false
}

func SetRoleListToRedis(openId string, zone int32, msg interface{}) error {
	return model.SetMessageToRedis(AccountPrefix, strconv.Itoa(int(zone))+"_"+openId, msg)
}

func GetRoleFromRedis(uid uint64, ack *serverproto.SSGetRoleAck, RoleRegisterTime uint64) error {
	if uid <= 0 {
		return errors.New("uid invalid")
	}
	value := strconv.FormatUint(uid, 10)
	ack.Role = &serverproto.Role{}
	ack.Role.RoleBase = &serverproto.RoleBase{}
	err := model.GetMessageFromRedis(RoleBasePrefix, value, ack.Role.RoleBase)
	if err != nil && err != service.NIL {
		return err
	}

	//其他各种玩家系统信息获取
	//伙伴数据
	ack.Role.RoleHero = &serverproto.RoleHero{}
	err = GetRoleHeroDataFromRedis(uid, ack.Role.RoleHero)
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleFromRedis RoleHero err=%v uid=%v", err, uid)
		return err
	}
	//msgData, _, _ := rpcc.EncodeMessage(ack)
	//oldLen := len(msgData)
	//util.InfoF("msgDatalen1=%v basehero", oldLen)
	//装备数据
	ack.Role.RoleEquip = &serverproto.RoleEquip{}
	err = GetSystemDataFromRedis(RoleEquipDataPrefix, uid, ack.Role.RoleEquip)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleEquip err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen := len(msgData)
	//util.InfoF("msgDatalen1=%v equip", newLen-oldLen)
	//oldLen = newLen

	//神器数据
	ack.Role.RoleSkillEquip = &serverproto.RoleSkillEquip{}
	GetRoleSkillEquipDataFromRedis(uid, ack.Role.RoleSkillEquip)

	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v skillequip", newLen-oldLen)
	//oldLen = newLen
	//背包数据
	ack.Role.RoleBag = &serverproto.RoleBag{}
	err = GetSystemDataFromRedis(RoleBagDataPrefix, uid, ack.Role.RoleBag)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleBag err:%v", err)
		return err
	}
	if err == service.NIL {
		ack.Role.RoleBag = nil
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v bag", newLen-oldLen)
	//oldLen = newLen
	//伙伴碎片数据
	ack.Role.RoleChip = &serverproto.RoleChip{}
	err = GetSystemDataFromRedis(RoleChipDataPrefix, uid, ack.Role.RoleChip)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleChip err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v chip", newLen-oldLen)
	//oldLen = newLen
	//AOI地图相关
	ack.Role.RoleMap = &serverproto.RoleMap{}
	err = GetSystemDataFromRedis(RoleMapDataPrefix, uid, ack.Role.RoleMap)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleMap err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v map", newLen-oldLen)
	//oldLen = newLen
	//卡片数据
	ack.Role.RoleCard = &serverproto.RoleCard{}
	err = GetSystemDataFromRedis(RoleCardDataPrefix, uid, ack.Role.RoleCard)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleCard err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v card", newLen-oldLen)
	//oldLen = newLen
	//时装数据
	ack.Role.RoleFashion = &serverproto.RoleFashion{}
	err = GetSystemDataFromRedis(RoleFashionDataPrefix, uid, ack.Role.RoleFashion)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleFashion err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v fashion", newLen-oldLen)
	//oldLen = newLen
	//战斗数据
	ack.Role.RoleBattle = &serverproto.RoleBattle{}
	err = GetSystemDataFromRedis(RoleBattleDataPrefix, uid, ack.Role.RoleBattle)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleBattle err:%v", err)
		return err
	}
	ack.Role.RoleBattle.MapChallengeNumList = ack.Role.RoleBattle.MapChallengeNumList[:0]
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//util.InfoF("msgDatalen1=%v", len(msgData))
	//邮件数据(邮件数据预先加载先于需要加载发送邮件的操作)
	ack.Role.RoleMail = &serverproto.RoleMail{}
	GetRoleMailDataFromRedis(uid, ack.Role.RoleMail, RoleRegisterTime)

	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v battle", newLen-oldLen)
	//oldLen = newLen

	//任务数据
	ack.Role.RoleTask = &serverproto.RoleTask{}
	GetRoleTaskFromRedis(uid, ack.Role.RoleTask)
	util.InfoF("get role task:%v", ack.Role.RoleTask)
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v task", newLen-oldLen)
	//oldLen = newLen

	//聊天离线数据(小红点处理)
	ack.Role.RoleChat = &serverproto.RoleChat{}
	err = GetChatOfflinePlayerList(uid, ack.Role.RoleChat)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleChat err:%v", err)
		return err
	}
	//小红点数据
	ack.Role.RoleRed = &serverproto.RoleRed{}
	err = GetSystemDataFromRedis(RoleRedDataPrefix, uid, ack.Role.RoleRed)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleRed err:%v", err)
		return err
	}
	//赛季玩法数据
	ack.Role.RoleCompetition = &serverproto.RoleCompetition{}
	err = GetSystemDataFromRedis(RoleCompetitionDataPrefix, uid, ack.Role.RoleCompetition)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleCompetition err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v chat read comp", newLen-oldLen)
	//oldLen = newLen
	//商店
	ack.Role.RoleShop = &serverproto.RoleShop{}
	err = GetSystemDataFromRedis(RoleShopDataPrefix, uid, ack.Role.RoleShop)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleShop err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v shop", newLen-oldLen)
	//oldLen = newLen
	//活动
	ack.Role.RoleActivity = &serverproto.RoleActivity{}
	GetRoleActivityDataFromRedis(uid, ack.Role.RoleActivity)

	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v activity", newLen-oldLen)
	//oldLen = newLen

	//爬塔
	ack.Role.RoleTower = &serverproto.RoleTower{}
	err = GetSystemDataFromRedis(RoleTowerDataPrefix, uid, ack.Role.RoleTower)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleTower err:%v", err)
		return err
	}
	//公会
	ack.Role.RoleGuild = &serverproto.RoleGuild{}
	err = GetSystemDataFromRedis(RoleGuildDataPrefix, uid, ack.Role.RoleGuild)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleGuild err:%v", err)
		return err
	}
	//抽卡
	ack.Role.RoleDraw = &serverproto.RoleDraw{}
	err = GetSystemDataFromRedis(RoleDrawDataPrefix, uid, ack.Role.RoleDraw)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleDraw err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v tower guild draw", newLen-oldLen)
	//oldLen = newLen
	//卢恩商会
	ack.Role.RoleRune = &serverproto.RoleRune{}
	err = GetRoleRuneDataFromRedis(uid, ack.Role.RoleRune)
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleFromRedis RoleRune err=%v uid=%v", err, uid)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v rune", newLen-oldLen)
	//oldLen = newLen
	//百人道场玩家基础数据
	ack.Role.RoleDaochang100 = &serverproto.RoleDaoChang100{}
	GetRoleDaoChang100FromRedis(uid, ack.Role.RoleDaochang100)

	//统计数据
	ack.Role.RoleStatistic = &serverproto.RoleStatistic{}
	err = GetSystemDataFromRedis(RoleStatisticDataPrefix, uid, ack.Role.RoleStatistic)
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleFromRedis RoleStatistic err=%v uid=%v", err, uid)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v daochang stat", newLen-oldLen)
	//oldLen = newLen

	//信物
	ack.Role.RoleKeepSake = &serverproto.RoleKeepSake{}
	err = GetSystemDataFromRedis(RoleKeepSakeDataPrefix, uid, ack.Role.RoleKeepSake)
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleFromRedis RoleKeepSake err=%v uid=%v", err, uid)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v sake", newLen-oldLen)
	//oldLen = newLen

	//跨服个人数据
	//ack.Role.RoleCross = &serverproto.RoleCross{}
	//err = GetSystemDataFromRedis(RoleCrossPrefix, uid, ack.Role.RoleCross)
	//if err != nil && err != service.NIL {
	//	util.InfoF("GetRoleFromRedis RoleStatistic err=%v uid=%v", err, uid)
	//	return err
	//}
	//if ack.Role.RoleCross.Yuanhangtrial != nil && len(ack.Role.RoleCross.Yuanhangtrial.LogList) > 50 {
	//	tmpIdx := len(ack.Role.RoleCross.Yuanhangtrial.LogList) - 50
	//	ack.Role.RoleCross.Yuanhangtrial.LogList = ack.Role.RoleCross.Yuanhangtrial.LogList[tmpIdx:]
	//}

	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v cross", newLen-oldLen)
	//oldLen = newLen

	//冲榜
	ack.Role.RoleRush = &serverproto.RoleRush{}
	err = GetSystemDataFromRedis(RoleRushDataPrefix, uid, ack.Role.RoleRush)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleRush err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v rush", newLen-oldLen)
	//oldLen = newLen

	//称号数据
	ack.Role.RoleHead = &serverproto.RoleHead{}
	err = GetSystemDataFromRedis(RoleHeadDataPrefix, uid, ack.Role.RoleHead)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleHead err:%v", err)
		return err
	}

	ack.Role.RoleWish = &serverproto.RoleWish{}
	err = GetSystemDataFromRedis(RoleWishBoxDataPrefix, uid, ack.Role.RoleWish)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleWish err:%v", err)
		return err
	}
	//msgData, _, _ = rpcc.EncodeMessage(ack)
	//newLen = len(msgData)
	//util.InfoF("msgDatalen1=%v head", newLen-oldLen)
	//oldLen = newLen

	//BT 数据
	ack.Role.RoleBt = &serverproto.RoleBT{}
	GetBTDataFromRedis(uid, ack.Role.RoleBt)

	return nil
}

// 其他系统数据加载
// 获取Role其他系统信息，不直接走SSGetRoleAck，避免后续数据包过大
func GetRoleOtherInfoFromRedis(uid uint64, ev rocommon.ProcEvent) {
	//获取竞技场数据
	loadNtfMsg := &serverproto.SSLoadArenaNtf{
		RoleArena: &serverproto.RoleArena{},
	}
	err := GetSystemDataFromRedis(RoleArenaDataPrefix, uid, loadNtfMsg.RoleArena)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleArena err:%v", err)
		return
	}
	if err == service.NIL {
		loadNtfMsg.RoleArena.Arena = nil
	}
	model.ServiceReplay(ev, loadNtfMsg)

	//获取好友系统数据
	friendLoadNtfMsg := &serverproto.SSLoadFriendDataNtf{
		Friend: &serverproto.RoleFriend{},
	}
	GetRoleFriendDataFromRedis(uid, friendLoadNtfMsg.Friend)
	model.ServiceReplay(ev, friendLoadNtfMsg)

	//获取宠物数据
	GetRolePetDataFromRedis(uid, ev)

	//获取招募(拉新)数据 invitation
	invitationLoadNtfMsg := &serverproto.SSLoadInvitationDataNtf{
		InvitationInfo: &serverproto.RoleInvitation{},
	}
	GetRoleInvitationFromRedis(uid, invitationLoadNtfMsg.InvitationInfo)
	model.ServiceReplay(ev, invitationLoadNtfMsg)

	//获取跨服数据
	//cross
	GetRoleCrossDataFromRedis(uid, ev)
}

func GetRoleCrossDataFromRedis(uid uint64, ev rocommon.ProcEvent) {
	loadData := &serverproto.RoleCross{}
	err := GetSystemDataFromRedis(RoleCrossPrefix, uid, loadData)
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleCrossDataFromRedis err=%v uid=%v", err, uid)
		return
	}
	if loadData.Yuanhangtrial != nil && len(loadData.Yuanhangtrial.LogList) > 50 {
		tmpIdx := len(loadData.Yuanhangtrial.LogList) - 50
		loadData.Yuanhangtrial.LogList = loadData.Yuanhangtrial.LogList[tmpIdx:]
	}
	if loadData.Crosstoptower != nil {
		for idx := 0; idx < len(loadData.Crosstoptower.FightList); idx++ {
			tmpInfo := loadData.Crosstoptower.FightList[idx].FightInfo
			if tmpInfo == nil {
				continue
			}
			for k := 0; k < len(tmpInfo.HeroDataList); k++ {
				tmpInfo.HeroDataList[k].BattleAttrListOld = tmpInfo.HeroDataList[k].BattleAttrListOld[:0]
			}
			for k := 0; k < len(tmpInfo.BattlePetList); k++ {
				tmpInfo.BattlePetList[k].BattleAttrListOld = tmpInfo.BattlePetList[k].BattleAttrListOld[:0]
			}
		}
	}

	//Yuanhangtrial
	ntfMsg := &serverproto.SSLoadCrossDataNtf{
		LoadData: &serverproto.RoleCross{},
	}
	ntfMsg.LoadData.Yuanhangtrial = loadData.Yuanhangtrial
	model.ServiceReplay(ev, ntfMsg)

	//TopTower
	if loadData.Crosstoptower != nil {
		ntfNum := 0
		for idx := 0; idx < len(loadData.Crosstoptower.FightList); idx++ {
			if ntfNum <= 0 {
				ntfMsg = &serverproto.SSLoadCrossDataNtf{
					LoadData: &serverproto.RoleCross{},
				}
				ntfMsg.LoadData.Crosstoptower = &serverproto.RoleCrossTopTower{}
				ntfMsg.LoadData.Crosstoptower.ValidEndTime = loadData.Crosstoptower.ValidEndTime
			}

			ntfMsg.LoadData.Crosstoptower.FightList = append(ntfMsg.LoadData.Crosstoptower.FightList,
				loadData.Crosstoptower.FightList[idx])
			ntfNum++
			if ntfNum >= 2 {
				ntfNum = 0
				model.ServiceReplay(ev, ntfMsg)
			}
		}
		if ntfNum > 0 {
			model.ServiceReplay(ev, ntfMsg)
		}
	}
}

func SetRoleToRedis(uid uint64, msg *serverproto.RoleBase) error {
	if uid <= 0 {
		return errors.New("uid<=0 invalid")
	}
	value := strconv.FormatUint(uid, 10)

	return model.SetMessageToRedis(RoleBasePrefix, value, msg)
}

func GetRoleBaseFromRedis(uid uint64, msg *serverproto.RoleBase) bool {
	if uid <= 0 {
		return false
	}
	value := strconv.FormatUint(uid, 10)
	err := model.GetMessageFromRedis(RoleBasePrefix, value, msg)
	if err == nil && err != service.NIL {
		return true
	}
	return false
}

func GetRoleHeroDataFromRedis(uid uint64, data *serverproto.RoleHero) error {
	if uid <= 0 {
		return errors.New("uid<=0 invalid")
	}
	value := strconv.FormatUint(uid, 10)

	keyStr := RoleHeroDataPrefix + value
	valueStr, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.InfoF("getRoleHeroDataFromRedis get key=%v err=%v uid=%v", keyStr, err, uid)
		return err
	}
	for heroKey, heroValue := range valueStr {
		msgStr, err := base64.StdEncoding.DecodeString(heroValue)
		if err != nil {
			util.InfoF("getRoleHeroDataFromRedis key=%v err=%v uid=%v", heroKey, err, uid)
			continue
		}
		heroData := &serverproto.HeroData{}
		err = rocommon.GetCodec().Unmarshal(msgStr, heroData)
		if err == nil {
			heroData.BattleAttrListOld = heroData.BattleAttrListOld[:0]
			data.HeroData = append(data.HeroData, heroData)
		} else {
			return err
		}
	}

	return nil
}

func SetRoleHeroDataToRedis(uid uint64, data *serverproto.RoleHero) error {
	if uid <= 0 {
		return errors.New("uid invalid")
	}
	value := strconv.FormatUint(uid, 10)
	keyStr := RoleHeroDataPrefix + value

	for _, heroData := range data.HeroData {
		fieldStr := strconv.Itoa(int(heroData.Id))
		msgData, err := rocommon.GetCodec().Marshal(heroData)
		if err != nil {
			util.InfoF("[SetRoleHeroDataToRedis] Marshal err:%v %v", err, fieldStr)
			continue
		}
		msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
		ret, err := service.GetRedis().HSet(keyStr, fieldStr, msgStr).Result()
		if err != nil {
			util.InfoF("[SetRoleHeroDataToRedis] err:%v %v", err, ret)
			continue
		}
	}
	return nil
}

// 卢恩商店
func GetRoleRuneDataFromRedis(uid uint64, data *serverproto.RoleRune) error {
	if uid <= 0 {
		return errors.New("uid invalid")
	}
	value := strconv.FormatUint(uid, 10)

	keyStr := RoleRuneDataPrefix + value
	valueStr, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.InfoF("GetRoleRuneDataFromRedis get key=%v err=%v uid=%v", keyStr, err, uid)
		return err
	}
	for shopKey, shopValue := range valueStr {
		msgStr, err := base64.StdEncoding.DecodeString(shopValue)
		if err != nil {
			util.InfoF("GetRoleRuneDataFromRedis key=%v err=%v uid=%v", shopKey, err, uid)
			continue
		}
		if shopKey == "runeExplore" {
			data.RuneExplore = &serverproto.RuneExplore{}
			err = rocommon.GetCodec().Unmarshal(msgStr, data.RuneExplore)
			if err != nil {
				return err
			}
		} else if shopKey == "runeBase" {
			data.RuneBase = &serverproto.RuneBaseData{}
			err = rocommon.GetCodec().Unmarshal(msgStr, data.RuneBase)
			if err != nil {
				return err
			}
		} else {
			shopData := &serverproto.RuneShop{}
			err = rocommon.GetCodec().Unmarshal(msgStr, shopData)
			if err == nil {
				data.ShopList = append(data.ShopList, shopData)
			} else {
				return err
			}
		}
	}

	return nil
}

func SetRoleRuneDataToRedis(uid uint64, data *serverproto.RoleRune) error {
	if uid <= 0 {
		return errors.New("uid invalid")
	}
	value := strconv.FormatUint(uid, 10)
	keyStr := RoleRuneDataPrefix + value

	for _, shop := range data.ShopList {
		fieldStr := strconv.Itoa(int(shop.ShopId*100 + shop.SubShopId))
		msgData, err := rocommon.GetCodec().Marshal(shop)
		if err != nil {
			util.InfoF("[SetRoleRuneDataToRedis] Marshal err:%v %v", err, fieldStr)
			continue
		}
		msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
		ret, err := service.GetRedis().HSet(keyStr, fieldStr, msgStr).Result()
		if err != nil {
			util.InfoF("[SetRoleRuneDataToRedis] err:%v %v", err, ret)
			continue
		}
	}
	runeBase, err := rocommon.GetCodec().Marshal(data.RuneBase)
	if err == nil {
		msgStr := base64.StdEncoding.EncodeToString(runeBase.([]byte))
		ret, err := service.GetRedis().HSet(keyStr, "runeBase", msgStr).Result()
		if err != nil {
			util.InfoF("[SetRoleRuneDataToRedis] err:%v %v", err, ret)
		}
	} else {
		util.InfoF("[SetRoleRuneDataToRedis] Marshal err:%v %v", err, "runeData")
	}

	runeData, err := rocommon.GetCodec().Marshal(data.RuneExplore)
	if err != nil {
		util.InfoF("[SetRoleRuneDataToRedis] Marshal err:%v %v", err, "runeData")
		return err
	}
	msgStr := base64.StdEncoding.EncodeToString(runeData.([]byte))
	ret, err := service.GetRedis().HSet(keyStr, "runeExplore", msgStr).Result()
	if err != nil {
		util.InfoF("[SetRoleRuneDataToRedis] err:%v %v", err, ret)
		return err
	}
	return nil
}

func SetSystemDataToRedis(prefix string, uid uint64, msg interface{}) error {
	if uid <= 0 {
		return errors.New("uid invalid")
	}

	value := strconv.FormatUint(uid, 10)
	return model.SetMessageToRedis(prefix, value, msg)
}

func GetSystemDataFromRedis(prefix string, uid uint64, msg interface{}) error {
	if uid <= 0 {
		return errors.New("uid invalid")
	}
	value := strconv.FormatUint(uid, 10)
	return model.GetMessageFromRedis(prefix, value, msg)
}

const MaxChatOffLineMsgCount int64 = 50

func AddChatOfflineMsg(fromId *serverproto.ChatPlayerBriefInfo, target uint64, msg *serverproto.ChatMessageInfo) {
	formIdStr := strconv.FormatUint(fromId.Uid, 10)
	targetIdStr := strconv.FormatUint(target, 10)
	keyStr := RoleChatOfflineMsgPrefix + targetIdStr + ":" + formIdStr + "_"

	err, msgStr := model.GetEncodeMessage(msg)
	if err == nil {
		ret, err1 := service.GetRedis().LPush(keyStr, msgStr).Result()
		if err1 == nil && ret > MaxChatOffLineMsgCount {
			service.GetRedis().LTrim(keyStr, 0, MaxChatOffLineMsgCount-1)
		}

		err1, msgStr1 := model.GetEncodeMessage(fromId)
		mapKeyStr := RoleChatOfflineMsgPrefix + targetIdStr + "_"
		service.GetRedis().HSet(mapKeyStr, formIdStr, msgStr1)
	}
}

// 获取离线私聊消息人员列表
func GetChatOfflinePlayerList(uid uint64, chatData *serverproto.RoleChat) error {
	if uid <= 0 {
		return errors.New("uid invalid")
	}
	uidStr := strconv.FormatUint(uid, 10)

	mapKeyStr := RoleChatOfflineMsgPrefix + uidStr + "_"
	//注意效率问题 数据量大需要用HScan
	ret, err := service.GetRedis().HGetAll(mapKeyStr).Result()
	//ret,err := service.GetRedis().HKeys(mapKeyStr).Result()
	if err != nil {
		return err
	}
	for _, data := range ret {
		tempInfo := &serverproto.ChatPlayerBriefInfo{}
		model.GetDecodeMessage(tempInfo, data)
		chatData.OfflineMsgPlayerList = append(chatData.OfflineMsgPlayerList, tempInfo)
	}

	return nil
}

// 获取离线私聊消息
func GetChatOfflineMsgFromRedis(selfId, targetId uint64, ackMsg *serverproto.SCChatOfflineMsgAck) error {
	if selfId <= 0 || targetId <= 0 {
		return errors.New("uid invalid")
	}

	selfIdStr := strconv.FormatUint(selfId, 10)
	targetIdStr := strconv.FormatUint(targetId, 10)

	mapKeyStr := RoleChatOfflineMsgPrefix + selfIdStr + "_"
	ret, err := service.GetRedis().HGet(mapKeyStr, targetIdStr).Result()
	if err == nil {
		ackMsg.TargetPlayer = &serverproto.ChatPlayerBriefInfo{}
		model.GetDecodeMessage(ackMsg.TargetPlayer, ret)
		service.GetRedis().HDel(mapKeyStr, targetIdStr)

		keyStr := RoleChatOfflineMsgPrefix + selfIdStr + ":" + targetIdStr + "_"
		msgList, err1 := service.GetRedis().LRange(keyStr, 0, MaxChatOffLineMsgCount-1).Result()
		if err1 == nil && len(msgList) > 0 {
			for idx := range msgList {
				chatMsg := &serverproto.ChatMessageInfo{}
				model.GetDecodeMessage(chatMsg, msgList[idx])
				ackMsg.MsgList = append(ackMsg.MsgList, chatMsg)
			}
			service.GetRedis().LTrim(keyStr, 0, -1)
		}
	} else {
		return err
	}

	return nil
}

// 设置玩家简介信息
const NameSearchListLimitNum = 20

func UpdatePlayerBriefInfo(uid uint64, briefInfo *serverproto.CommonPlayerBriefInfo, bCreate bool, activeCode, openId, subPlatform string) {
	err := SetSystemDataToRedis(RolePlayerBriefPrefix, uid, briefInfo)
	if err != nil {
		util.InfoF("[SSRoleBriefInfoSaveReq] save err:%v", err)
	} else {
		//更新到mysql数据库中
		UpdatePlayerBriefInfo2Mysql(uid, briefInfo, bCreate, activeCode, openId, subPlatform)

		//缓存简介信息
		info, ok := PlayerInfoCacheList[uid]
		if !ok {
			info = &PlayerInfoCache{
				fightInfo: &serverproto.FightRoleInfo{
					BriefInfo: &serverproto.CommonPlayerBriefInfo{},
				},
			}
		}
		info.fightInfo.BriefInfo = briefInfo
		info.refreshTime = util.GetTimeMilliseconds()

		//创建时使用的是默认名字则加入到，默认名字的搜索列表中，提高搜索的效率(不用去遍历数据库)
		if briefInfo.NickName == "" {
			service.GetRedis().LRem(RoleNameSearchListPrefix, 1, briefInfo.Uid)
			ret, err1 := service.GetRedis().LPush(RoleNameSearchListPrefix, briefInfo.Uid).Result()
			if err1 != nil {
				util.InfoF("[SSRoleBriefInfoSaveReq] searchList Push err:%v", err1)
				return
			}
			if ret > NameSearchListLimitNum {
				service.GetRedis().LTrim(RoleNameSearchListPrefix, 0, NameSearchListLimitNum-1)
			}
		} else {
			service.GetRedis().LRem(RoleNameSearchListPrefix, 1, briefInfo.Uid)
		}
	}
}

func GetPlayerBriefInfo(uid uint64) (error, *serverproto.CommonPlayerBriefInfo) {
	nowTime := util.GetTimeMilliseconds()
	cacheInfo, ok := PlayerInfoCacheList[uid]
	if !ok {
		cacheInfo = &PlayerInfoCache{
			fightInfo: &serverproto.FightRoleInfo{
				BriefInfo: &serverproto.CommonPlayerBriefInfo{
					Uid: uid},
			},
		}
		cacheInfo.refreshTime = nowTime + uint64(BriefInfoRefreshTime+rand.Int31n(BriefInfoRefreshTime))
		err := GetSystemDataFromRedis(RolePlayerBriefPrefix, uid, cacheInfo.fightInfo.BriefInfo)
		if err != nil && err != service.NIL {
			return err, nil
		}
	} else {
		if cacheInfo.refreshTime < nowTime {
			rand.Seed(int64(util.GetTimeMilliseconds()))
			cacheInfo.refreshTime = nowTime + uint64(BriefInfoRefreshTime+rand.Int31n(BriefInfoRefreshTime))
			//BriefInfo
			GetSystemDataFromRedis(RolePlayerBriefPrefix, uid, cacheInfo.fightInfo.BriefInfo)
		}
	}
	return nil, cacheInfo.fightInfo.BriefInfo
}

func GetPlayerBriefInfoWithoutCache(uid uint64) *serverproto.CommonPlayerBriefInfo {
	info := &serverproto.CommonPlayerBriefInfo{Uid: uid}
	err := GetSystemDataFromRedis(RolePlayerBriefPrefix, uid, info)
	if err != nil {
		return nil
	}

	//获取道场口号
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := model.RoleDaoChang100Prefix + uidStr
	baseStr, err := service.GetRedis().HGet(keyStr, "base").Result()
	if err == nil {
		daochang100Info := &serverproto.RoleDaoChang100{}
		err = model.GetDecodeMessage(daochang100Info, baseStr)
		if err == nil {
			info.Daochang100Tips = daochang100Info.TipsDesc
		}
	}
	return info
}

// 获取默认名字Uid列表，值获得前10个
func GetNameSearchList(searchName string, exceptUid uint64, zone int32, msg *serverproto.SSGetUidByRoleNameAck) {
	//默认名字查找
	if searchName == "" {
		retList, err := service.GetRedis().LRange(RoleNameSearchListPrefix, 0, 9).Result()
		if err != nil {
			util.InfoF("[GetNameSearchList] searchList err:%v", err, searchName)
			return
		}
		if len(retList) > 0 {
			for idx := 0; idx < len(retList); idx++ {
				tmpUid, _ := model.Str2NumU64(retList[idx])
				if tmpUid == exceptUid || tmpUid == 0 {
					continue
				}
				err, bInfo := GetPlayerBriefInfo(tmpUid)
				if err == nil {
					msg.BriefInfoList = append(msg.BriefInfoList, bInfo)
				}
			}
		}
	} else {
		//名字匹配查找
		msgStr := base64.StdEncoding.EncodeToString([]byte(searchName))
		//keyStr := RoleNickNamePrefix + strconv.Itoa(int(zone)) + "_" + msgStr
		keyMatchStr := RoleNickNamePrefix + "*_" + msgStr
		matchStrList, err := service.GetRedis().Keys(keyMatchStr).Result()
		if err != nil {
			util.InfoF("[GetNameSearchList] searchList err:%v %v", err, searchName)
			return
		}
		for idx := 0; idx < len(matchStrList); idx++ {
			uidStr, err := service.GetRedis().Get(matchStrList[idx]).Result()
			if err != nil {
				util.InfoF("[GetNameSearchList] searchList err:%v %v", err, searchName)
				continue
			}
			searchUid, _ := model.Str2NumU64(uidStr)
			if searchUid == 0 {
				continue
			}
			err, bInfo := GetPlayerBriefInfo(searchUid)
			if err == nil {
				msg.BriefInfoList = append(msg.BriefInfoList, bInfo)
			}
		}
	}
}

func GetRoleMailDataFromRedis(uid uint64, roleMail *serverproto.RoleMail, RoleRegisterTime uint64) bool {
	if RoleRegisterTime <= 0 {
		return false
	}
	bRet := false
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleMailDataPrefix + uidStr

	//0位置表示目前邮件最大id
	valueStrList, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil && err != service.NIL {
		util.InfoF("uid=%v GetRoleMailDataFromRedis err=%v", uid, err)
		return bRet
	}
	bRet = true

	var delFieldList []string // 过期已删除的邮件
	cutMs := util.GetTimeMilliseconds()
	for key, value := range valueStrList {
		if key == "maxId" {
			val, _ := model.Str2Num(value)
			roleMail.MaxMailId = int32(val)
			continue
		} else if key == "gMaxId" {
			val, _ := model.Str2Num(value)
			roleMail.CurrGlobalMailId = int32(val)
			continue
		}
		mailData := &serverproto.MailContent{}
		err = model.GetDecodeMessage(mailData, value)
		if err != nil {
			util.InfoF("uid=%v GetRoleMailDataFromRedis key=%v err=%v", uid, key, err)
			continue
		} else {
			if mailData.State&4 > 0 { // 删除邮件 不返回, 并删除超过30天的邮件
				if util.GetDurationDay1(mailData.BeginTime, cutMs) > 30 {
					delFieldList = append(delFieldList, key)
				}
				continue
			}
			roleMail.MailList = append(roleMail.MailList, mailData)
			if roleMail.MaxMailId < mailData.Id {
				roleMail.MaxMailId = mailData.Id
			}
		}
	}

	if len(delFieldList) > 0 {
		ret, err := service.GetRedis().HDel(keyStr, delFieldList...).Result()
		if err != nil {
			util.InfoF("[SetMailDataChangToRedis][%v] del past mail err5:%v %v", uid, err, ret)
		}
	}

	//查看全局邮件里是否有可领取邮件
	//全局邮件多了后需要做优化，暂时进行整体获取
	globalMaiList, err := service.GetRedis().LRange(RoleGlobalMailListPrefix, 0, -1).Result()
	if err != nil {
		return bRet
	}
	//修正玩家生成全局邮件不正常数据
	var gMailMaxId int32 = 0
	for idx := 0; idx < len(globalMaiList); idx++ {
		gmId, _ := model.Str2Num(globalMaiList[idx])
		if gmId <= 0 {
			service.GetRedis().LRem(RoleGlobalMailListPrefix, 0, gmId)
			continue
		}
		if gMailMaxId < int32(gmId) {
			gMailMaxId = int32(gmId)
		}
	}
	if roleMail.CurrGlobalMailId > gMailMaxId {
		//出错时确保最后一封邮件能收到
		roleMail.CurrGlobalMailId = gMailMaxId - 1
	}

	var expireDayTimeMs uint64 = 24 * 3600 * 1000 * 14 //2周=14天
	for idx := 0; idx < len(globalMaiList); idx++ {
		gmId, _ := model.Str2Num(globalMaiList[idx])
		if gmId <= 0 {
			service.GetRedis().LRem(RoleGlobalMailListPrefix, 0, gmId)
			continue
		}
		if int32(gmId) <= roleMail.CurrGlobalMailId {
			continue
		}

		gmIdKey := RoleGlobalMailPrefix + globalMaiList[idx]
		//过期后需要把邮件对应的id从列表中移除
		gMailInfoStr, err := service.GetRedis().Get(gmIdKey).Result()
		if err != nil {
			service.GetRedis().LRem(RoleGlobalMailListPrefix, 0, gmId)
			continue
		}

		gMailInfo := &serverproto.WebUpdateMailItem{}
		err = model.GetDecodeMessage(gMailInfo, gMailInfoStr)
		if err != nil {
			util.InfoF("uid=%v GetRoleMailDataFromRedis global mail decode err=%v", uid, err)
		}

		if gMailInfo.SendDate < RoleRegisterTime {
			//roleMail.CurrGlobalMailId = int32(gmId)
			util.InfoF("uid=%v GetRoleMailDataFromRedis global mail create after sendData gmId=%v", uid, gmId)
			continue
		}
		//超过2周的补偿没后获取到直接失效，反之上线时获取到太多的未领取邮件
		if gMailInfo.SendDate+expireDayTimeMs <= cutMs {
			util.InfoF("uid=%v GetRoleMailDataFromRedis global mail expired 2 weeks[time=%v] gmId=%v", uid, gMailInfo.SendDate, gmId)
			continue
		}

		mailData := &serverproto.MailContent{
			Id:         gMailInfo.Id,
			Type:       int32(serverproto.MailType_MailType_GM),
			RewardList: gMailInfo.RewardList,
			Title:      gMailInfo.Title,
			Content:    gMailInfo.Content,
		}
		roleMail.MailList = append(roleMail.MailList, mailData)
	}
	roleMail.CurrGlobalMailId = gMailMaxId

	return bRet
}

// 邮件数据变更保存
func SetMailDataChangToRedis(uid uint64, mailStateList []*serverproto.MailContent, delMailList []int32,
	addMailList []*serverproto.MailContent, maxMailId int32, curGlobalMailId int32) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleMailDataPrefix + uidStr

	maxIdFieldStr := strconv.Itoa(int(maxMailId))
	service.GetRedis().HSet(keyStr, "maxId", maxIdFieldStr)

	curGlobalMailIdStr := strconv.Itoa(int(curGlobalMailId))
	service.GetRedis().HSet(keyStr, "gMaxId", curGlobalMailIdStr)

	//mailStateList
	if len(mailStateList) > 0 {
		var stateFieldList = map[string]interface{}{}
		for _, mail := range mailStateList {
			fieldStr := strconv.Itoa(int(mail.Id))
			msgData, err := rocommon.GetCodec().Marshal(mail)
			if err != nil {
				util.InfoF("[SetMailDataChangToRedis][%v] Marshal err1:%v %v", uid, err, fieldStr)
				continue
			}
			msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
			stateFieldList[fieldStr] = msgStr
		}
		ret, err := service.GetRedis().HMSet(keyStr, stateFieldList).Result()
		if err != nil {
			util.InfoF("[SetMailDataChangToRedis][%v] err2:%v %v", uid, err, ret)
		}
	}

	//addMailList
	if len(addMailList) > 0 {
		var addFieldList = map[string]interface{}{}
		for _, mail := range addMailList {
			fieldStr := strconv.Itoa(int(mail.Id))
			msgData, err := rocommon.GetCodec().Marshal(mail)
			if err != nil {
				util.InfoF("[SetMailDataChangToRedis][%v] Marshal err3:%v %v", uid, err, fieldStr)
				continue
			}
			msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
			addFieldList[fieldStr] = msgStr
		}
		ret, err := service.GetRedis().HMSet(keyStr, addFieldList).Result()
		if err != nil {
			util.InfoF("[SetMailDataChangToRedis][%v] err4:%v %v", uid, err, ret)
		}
	}

	//delMailList
	if len(delMailList) > 0 {
		var stateMail = map[string]interface{}{}
		for idx := range delMailList {
			fieldStr := strconv.Itoa(int(delMailList[idx]))
			if mailData, err := service.GetRedis().HGet(keyStr, fieldStr).Result(); err == nil {
				mail := &serverproto.MailContent{}
				err = model.GetDecodeMessage(mail, mailData)
				if err != nil {
					continue
				}
				mail.State |= 4 // 标识邮件已删除
				msgData, err := rocommon.GetCodec().Marshal(mail)
				if err != nil {
					util.InfoF("[SetMailDataChangToRedis][%v] del mail Marshal err3:%v %v", uid, err, fieldStr)
					continue
				}
				msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
				stateMail[fieldStr] = msgStr
			}
		}
		ret, err := service.GetRedis().HMSet(keyStr, stateMail).Result()
		if err != nil {
			util.InfoF("[SetMailDataChangToRedis] del Mail state Save [%v] err4:%v %v", uid, err, ret)
		}
		//// ----------------------------------存儲三天内刪除的邮件-----------------------------
		//delMail := &serverproto.DelMail{}
		//delRet, err := service.GetRedis().HGet(keyStr, "DelMail").Result()
		//if err == nil{
		//	model.GetDecodeMessage(delMail, delRet)
		//}
		//curMs := util.GetTimeMilliseconds()
		//var delFieldList []string
		//for idx := range delMailList {
		//	fieldStr := strconv.Itoa(int(delMailList[idx]))
		//	delFieldList = append(delFieldList, fieldStr)
		//	if mailData, err := service.GetRedis().HGet(keyStr, fieldStr).Result(); err == nil{
		//		mail := &serverproto.MailContent{}
		//		err = model.GetDecodeMessage(mail, mailData)
		//		if err != nil {
		//			continue
		//		}
		//		mail.State |= 4		// 标识邮件已删除
		//		mail.ExpireTime = curMs // 删除的邮件结束时间改为删除时间
		//		delMail.DelMail = append(delMail.DelMail, mail)
		//	}
		//}
		//curTime := util.GetCurrentTimeNow()
		//endT := uint64(curTime.AddDate(0,0,-3).Unix() * 1000)
		//for i := 0; i < len(delMail.DelMail); {
		//	if endT > delMail.DelMail[i].ExpireTime{delMail.DelMail = append(delMail.DelMail[:i], delMail.DelMail[i+1:]...); continue}
		//	i++
		//}
		//msgData, err := rocommon.GetCodec().Marshal(delMail)
		//if err != nil {
		//	util.InfoF("[SetMailDataChangToRedis][%v] Marshal err3:%v %v", uid, err, msgData)
		//}
		//msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
		//setDelret, err := service.GetRedis().HSet(keyStr, "DelMail", msgStr).Result()
		//if err != nil {
		//	util.InfoF("[SetMailDataChangToRedis][%v] %v err4:%v %v", uid, "DelMail", err, setDelret)
		//}
		/////----------------------------------end--------------------------------------------------
		//ret, err := service.GetRedis().HDel(keyStr, delFieldList...).Result()
		//if err != nil {
		//	util.InfoF("[SetMailDataChangToRedis][%v] err5:%v %v", uid, err, ret)
		//}
	}

}

// 添加邮件(离线方式添加到db中，在线添加在SSMailSaveNtf中)
func AddMailToRedis(uid uint64, mail *serverproto.MailContent) bool {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleMailDataPrefix + uidStr

	//mail.BeginTime <= 0表示离线方式添加，后续在玩家上线时做处理
	maxMailIdStr, err := service.GetRedis().HGet(keyStr, "maxId").Result()
	if err != nil && err != service.NIL {
		util.InfoF("uid=%v AddMailToRedis maxMailId err=%v maxId=%v", uid, err, "maxId")
		return false
	}
	maxMailId, _ := model.Str2Num(maxMailIdStr)
	maxMailId++
	mail.Id = int32(maxMailId)
	//设置最大邮件ID
	service.GetRedis().HSet(keyStr, "maxId", strconv.Itoa(int(maxMailId)))

	//添加邮件
	fieldStr := strconv.Itoa(int(mail.Id))
	msgData, err := rocommon.GetCodec().Marshal(mail)
	if err != nil {
		util.InfoF("uid=%v addMailToRedis Marshal err=%v mailId=%v", uid, err, fieldStr)
		return false
	}
	msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
	ret, err := service.GetRedis().HSet(keyStr, fieldStr, msgStr).Result()
	if err != nil {
		util.InfoF("uid=%v addMailToRedis err=%v ret=%v", uid, err, ret)
		return false
	}

	//小红点处理
	roleRed := &serverproto.RoleRed{}
	err = GetSystemDataFromRedis(RoleRedDataPrefix, uid, roleRed)
	if err != nil && err != service.NIL {
		util.InfoF("[AddMailToRedis][%v] RoleRed err:%v", uid, err)
		return false
	}
	if !roleRed.IsUnreadMail {
		roleRed.IsUnreadMail = true

		err := SetSystemDataToRedis(RoleRedDataPrefix, uid, roleRed)
		if err != nil {
			util.InfoF("[AddMailToRedis][%v] save rolRed err:%v", uid, err)
			return false
		}
	}

	return true
}

func SetUserRankScore(uid uint64) {
	//uidStr := strconv.FormatUint(uid, 10)
	loadData := &serverproto.RoleCross{}
	err := GetSystemDataFromRedis(RoleCrossPrefix, uid, loadData)
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleCrossDataFromRedis err=%v uid=%v", err, uid)
		return
	}
	loadData.Yuanhangtrial.TrialScore = 0
	err = SetSystemDataToRedis(RoleCrossPrefix, uid, loadData)
	if err != nil {
		util.InfoF("uid=%v SetRoleCrossYuanHangLogToRedis save err=%v", uid, err)
	}
}

func GetOtherViewInfo(uid uint64, info *serverproto.ViewRoleInfo) int32 {
	value := strconv.FormatUint(uid, 10)
	roleBase := &serverproto.RoleBase{}
	errBase := model.GetMessageFromRedis(RoleBasePrefix, value, roleBase)
	if errBase != nil {
		return int32(serverproto.ErrorCode_ERROR_ROLE_NOT_FOUND)
	}
	roleHero := &serverproto.RoleHero{}
	errHero := GetRoleHeroDataFromRedis(uid, roleHero)
	if errHero != nil && errHero != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleHero err=%v uid=%v", errHero, uid)
		return int32(serverproto.ErrorCode_ERROR_ROLE_NOT_FOUND)
	}
	roleFashion := &serverproto.RoleFashion{}
	errFashion := GetSystemDataFromRedis(RoleFashionDataPrefix, uid, roleFashion)
	if errFashion != nil && errFashion != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleFashion err=%v uid=%v", errFashion, uid)
		return int32(serverproto.ErrorCode_ERROR_ROLE_NOT_FOUND)
	}
	roleArena := &serverproto.RoleArena{}
	err := GetSystemDataFromRedis(RoleArenaDataPrefix, uid, roleArena)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleArena err:%v", err)
		return int32(serverproto.ErrorCode_ERROR_ROLE_NOT_FOUND)
	}

	headData := &serverproto.RoleHead{}
	err = GetSystemDataFromRedis(RoleHeadDataPrefix, uid, headData)
	if err != nil && err != service.NIL {
		util.InfoF("[GetRoleFromRedis] RoleHead err:%v", err)
		return int32(serverproto.ErrorCode_ERROR_ROLE_NOT_FOUND)
	}

	var headId int32 = 0
	for _, data := range headData.Heads {
		if data.State != int32(2) {
			continue
		}
		headId = data.HeadId
		break
	}

	info.Id = uid
	info.Brief = &serverproto.CommonPlayerBriefInfo{
		Uid:         uid,
		NickName:    roleBase.NickName,
		Gender:      roleBase.Sex,
		ImgId:       roleBase.RoleData.HeadId,
		HeadFrameId: roleBase.RoleData.HeadFrameId,
		ConfigId:    roleBase.RoleData.HeroData.ConfigId,
		FightPower:  int32(roleBase.RoleData.FightPower),
		VipLevel:    roleBase.VipLevel,
		HeadId:      headId,
	}
	//	info.JobLevel = this.GetJobLevel()
	//	info.AttrList = append(roleBase.RoleData.AttrList)
	info.FashionData = roleBase.FashionData

	if roleArena.Arena != nil {
		info.DanScore = roleArena.Arena.Score
	}
	info.Fashion = &serverproto.RoleFashion{}
	for _, data := range roleFashion.FashionList {
		info.Fashion.FashionList = append(info.Fashion.FashionList, data)
	}

	//世界boss，只上阵主角
	info.RoleHero = roleBase.RoleData.HeroData
	info.Hero = &serverproto.RoleHero{}
	for _, data := range roleHero.HeroData {
		info.Hero.HeroData = append(info.Hero.HeroData, data)
	}

	baseStr := model.GuildRoleToGuildPrefix
	fieldStr := strconv.FormatUint(uint64(uid), 10)
	guildStr, guildErr := service.GetRedis().HGet(baseStr, fieldStr).Result()
	if guildErr == nil {
		guildIndex := &serverproto.GuildIdex{}
		err := model.GetDecodeMessage(guildIndex, guildStr)
		//找到公会索引//公会ID 不为零的话
		if err == nil {
			if guildIndex.GuildId != 0 {
				fieldStr := strconv.FormatUint(uint64(guildIndex.GuildId), 10)
				baseStr, baseErr := service.GetRedis().HGet(model.GuildBasePrefix, fieldStr).Result()
				if baseErr == nil {
					recordBase := &serverproto.GuildBase{}
					deErr := model.GetDecodeMessage(recordBase, baseStr)
					if deErr == nil {
						info.GuildName = recordBase.GuildBrief.GuildName
					}
				}
			}
		} else {
			util.InfoF("[GetRoleToGuild] get guild index not found")
		}
	}

	GetViewRolePetData(uid, info)

	return int32(serverproto.ErrorCode_ERROR_OK)
}

func GetViewRolePetData(uid uint64, info *serverproto.ViewRoleInfo) {
	if info == nil {
		return
	}
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RolePetDataPrefix + uidStr
	if !model.ExistKey(keyStr) {
		return
	}

	if info.RoleHero.BattlePetId != 0 {
		fieldStr := RolePetDataFieldPrefix_petlist + strconv.Itoa(int(info.RoleHero.BattlePetId))
		petStr, petErr := service.GetRedis().HGet(keyStr, fieldStr).Result()
		if petErr == nil && petErr != service.NIL {
			petData := &serverproto.PetData{}
			err := model.GetDecodeMessage(petData, petStr)
			if err == nil {
				info.PetList = append(info.PetList, petData)
			}
		}
	}
	for _, hero := range info.Hero.HeroData {
		if hero.BattlePetId != 0 {
			fieldStr := RolePetDataFieldPrefix_petlist + strconv.Itoa(int(hero.BattlePetId))
			petStr, petErr := service.GetRedis().HGet(keyStr, fieldStr).Result()
			if petErr == nil && petErr != service.NIL {
				petData := &serverproto.PetData{}
				err := model.GetDecodeMessage(petData, petStr)
				if err == nil {
					info.PetList = append(info.PetList, petData)
				}
			}
		}
	}
}

func GetPlayerGuildName(uid uint64) string {
	retStr := ""
	baseStr := model.GuildRoleToGuildPrefix
	fieldStr := strconv.FormatUint(uint64(uid), 10)
	guildStr, guildErr := service.GetRedis().HGet(baseStr, fieldStr).Result()
	if guildErr == nil {
		guildIndex := &serverproto.GuildIdex{}
		err := model.GetDecodeMessage(guildIndex, guildStr)
		//找到公会索引//公会ID 不为零的话
		if err == nil {
			if guildIndex.GuildId != 0 {
				fieldStr := strconv.FormatUint(uint64(guildIndex.GuildId), 10)
				baseStr, baseErr := service.GetRedis().HGet(model.GuildBasePrefix, fieldStr).Result()
				if baseErr == nil {
					recordBase := &serverproto.GuildBase{}
					deErr := model.GetDecodeMessage(recordBase, baseStr)
					if deErr == nil {
						retStr = recordBase.GuildBrief.GuildName
					}
				}
			}
		} else {
			util.InfoF("[GetRoleToGuild] get guild index not found")
		}
	}
	return retStr
}

func GetPlayerGuildIdAndName(uid uint64) (uint64, string) {
	retStr := ""
	baseStr := model.GuildRoleToGuildPrefix
	fieldStr := strconv.FormatUint(uint64(uid), 10)
	guildStr, guildErr := service.GetRedis().HGet(baseStr, fieldStr).Result()
	if guildErr == nil {
		guildIndex := &serverproto.GuildIdex{}
		err := model.GetDecodeMessage(guildIndex, guildStr)
		//找到公会索引//公会ID 不为零的话
		if err == nil {
			if guildIndex.GuildId != 0 {
				fieldStr := strconv.FormatUint(uint64(guildIndex.GuildId), 10)
				baseStr, baseErr := service.GetRedis().HGet(model.GuildBasePrefix, fieldStr).Result()
				if baseErr == nil {
					recordBase := &serverproto.GuildBase{}
					deErr := model.GetDecodeMessage(recordBase, baseStr)
					if deErr == nil {
						return uint64(guildIndex.GuildId), recordBase.GuildBrief.GuildName
					}
				}
			}
		} else {
			util.InfoF("[GetRoleToGuild] get guild index not found")
		}
	}
	return 0, retStr
}

func ExistActiveCode(activeCode string) serverproto.ErrorCode {
	keyStr := RoleActiveCodeUsedListPrefix
	valueStr, err := service.GetRedis().HGet(keyStr, activeCode).Result()
	if err != nil && err != service.NIL {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if err == service.NIL || len(valueStr) <= 0 {
		return serverproto.ErrorCode_ERROR_OK
	}
	return serverproto.ErrorCode_ERROR_ROLE_ACTIVECODE_USED
}

func SetActiveCode(activeCode string, uid uint64) bool {
	keyStr := RoleActiveCodeUsedListPrefix
	_, err := service.GetRedis().HSet(keyStr, activeCode, uid).Result()
	if err != nil {
		return false
	}
	return true
}

// task
const TASK_REWARD_STATE_REWARD_DB = 2
const TASK_REWARD_STATE_DELETE = 3

func SetRoleTaskToRedis(uid uint64, roleTask *serverproto.RoleTask) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleTaskDataPrefix + uidStr
	KeyHardStr := RoleTaskDataHardPrefix + uidStr
	KeyHard2Str := RoleTaskDataHard2Prefix + uidStr

	for idx := range roleTask.TaskList {
		taskInfo := roleTask.TaskList[idx]
		fieldStr := strconv.Itoa(int(taskInfo.TaskId))
		if taskInfo.TaskType == model.TASK_TYPE_HARD || taskInfo.TaskType == model.TASK_TYPE_HARD_GROUP {
			//困难模式任务删除
			if taskInfo.HardState == TASK_REWARD_STATE_DELETE {
				service.GetRedis().HDel(KeyHardStr, fieldStr)
				continue
			}
			msgData, err := rocommon.GetCodec().Marshal(taskInfo)
			if err != nil {
				util.ErrorF("SetRoleTaskToRedis uid=%v Marshal err=%v field=%v", uid, err, fieldStr)
				continue
			}
			msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))

			_, err = service.GetRedis().HSet(KeyHardStr, fieldStr, msgStr).Result()
			if err != nil {
				util.ErrorF("SetRoleTaskToRedis uid=%v err=%v %v", uid, err)
			}
		} else if taskInfo.TaskType == model.TASK_TYPE_HARD2 || taskInfo.TaskType == model.TASK_TYPE_HARD2_GROUP {
			//困难模式任务删除
			if taskInfo.HardState == TASK_REWARD_STATE_DELETE {
				service.GetRedis().HDel(KeyHard2Str, fieldStr)
				continue
			}
			msgData, err := rocommon.GetCodec().Marshal(taskInfo)
			if err != nil {
				util.ErrorF("SetRoleTaskToRedis uid=%v Marshal err=%v field=%v", uid, err, fieldStr)
				continue
			}
			msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))

			_, err = service.GetRedis().HSet(KeyHard2Str, fieldStr, msgStr).Result()
			if err != nil {
				util.ErrorF("SetRoleTaskToRedis uid=%v err=%v %v", uid, err)
			}
		} else {
			//主线完成的任务直接删除
			if taskInfo.State == TASK_REWARD_STATE_REWARD_DB && len(taskInfo.Progress) <= 0 {
				service.GetRedis().HDel(keyStr, fieldStr)
				continue
			}
			msgData, err := rocommon.GetCodec().Marshal(taskInfo)
			if err != nil {
				util.ErrorF("SetRoleTaskToRedis uid=%v Marshal err=%v field=%v", uid, err, fieldStr)
				continue
			}
			msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))

			_, err = service.GetRedis().HSet(keyStr, fieldStr, msgStr).Result()
			if err != nil {
				util.ErrorF("SetRoleTaskToRedis uid=%v err=%v %v", uid, err)
			}
		}
	}

	//base
	roleTask.TaskList = roleTask.TaskList[:0]
	msgData, err := rocommon.GetCodec().Marshal(roleTask)
	if err != nil {
		util.ErrorF("SetRoleTaskToRedis uid=%v Marshal roleTask err=%v", uid, err)
		return
	}
	msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
	_, err = service.GetRedis().HSet(keyStr, "base", msgStr).Result()
	if err != nil {
		util.ErrorF("SetRoleTaskToRedis base uid=%v err=%v", uid, err)
	}
}

func GetRoleTaskFromRedis(uid uint64, roleTask *serverproto.RoleTask) bool {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleTaskDataPrefix + uidStr
	KeyHardStr := RoleTaskDataHardPrefix + uidStr
	KeyHard2Str := RoleTaskDataHard2Prefix + uidStr
	msgStrList, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.ErrorF("GetRoleTaskFromRedis uid=%v err=%v", uid, err)
		return false
	}
	msgStrHardList, er := service.GetRedis().HGetAll(KeyHardStr).Result()
	if er != nil {
		util.ErrorF("GetRoleTaskFromRedis uid=%v err=%v", uid, err)
		return false
	}

	msgStrHard2List, er := service.GetRedis().HGetAll(KeyHard2Str).Result()
	if er != nil {
		util.ErrorF("GetRoleTaskFromRedis uid=%v err=%v", uid, err)
		return false
	}

	var tmpTaskList []*serverproto.TaskData
	for key, val := range msgStrList {
		if key == "base" {
			msgData, err1 := base64.StdEncoding.DecodeString(val)
			if err1 != nil {
				util.ErrorF("GetRoleTaskFromRedis Base DecodeString uid=%v err=%v", uid, err1)
				continue
			}
			err = rocommon.GetCodec().Unmarshal(msgData, roleTask)
			if err != nil {
				util.ErrorF("GetRoleTaskFromRedis Base Unmarshal uid=%v err=%v", uid, err)
				continue
			}
		} else { // task
			msgData, err1 := base64.StdEncoding.DecodeString(val)
			if err1 != nil {
				util.ErrorF("GetRoleTaskFromRedis Task DecodeString uid=%v err=%v", uid, err1)
				continue
			}
			taskInfo := &serverproto.TaskData{}
			err = rocommon.GetCodec().Unmarshal(msgData, taskInfo)
			if err != nil {
				util.ErrorF("GetRoleTaskFromRedis Task Unmarshal uid=%v err=%v", uid, err)
				continue
			}
			tmpTaskList = append(tmpTaskList, taskInfo)
		}
	}
	for _, val := range msgStrHardList {
		msgData, err1 := base64.StdEncoding.DecodeString(val)
		if err1 != nil {
			util.ErrorF("GetRoleTaskFromRedis Task DecodeString uid=%v err=%v", uid, err1)
			continue
		}
		taskInfo := &serverproto.TaskData{}
		err = rocommon.GetCodec().Unmarshal(msgData, taskInfo)
		if err != nil {
			util.ErrorF("GetRoleTaskFromRedis Task Unmarshal uid=%v err=%v", uid, err)
			continue
		}
		tmpTaskList = append(tmpTaskList, taskInfo)

	}
	for _, val := range msgStrHard2List {
		msgData, err1 := base64.StdEncoding.DecodeString(val)
		if err1 != nil {
			util.ErrorF("GetRoleTaskFromRedis Task DecodeString uid=%v err=%v", uid, err1)
			continue
		}
		taskInfo := &serverproto.TaskData{}
		err = rocommon.GetCodec().Unmarshal(msgData, taskInfo)
		if err != nil {
			util.ErrorF("GetRoleTaskFromRedis Task Unmarshal uid=%v err=%v", uid, err)
			continue
		}
		tmpTaskList = append(tmpTaskList, taskInfo)

	}
	roleTask.TaskList = append(roleTask.TaskList, tmpTaskList...)
	return true
}

// //pet
func GetRolePetDataFromRedis(uid uint64, ev rocommon.ProcEvent) bool {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RolePetDataPrefix + uidStr
	if !model.ExistKey(keyStr) {
		return false
	}

	//base
	baseStr, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.ErrorF("GetRolePetDataFromRedis uid=%v err=%v", uid, err)
		return false
	}
	util.InfoF("uid=%v GetRolePetDataFromRedis len=%v", uid, len(baseStr))

	var tmpPetList []*serverproto.PetData
	var tmpPetBondList []*serverproto.PetBondData
	dataCount := 0
	for key, val := range baseStr {
		if key == RolePetDataFieldPrefix_base {
			msg := &serverproto.SSLoadPetNtf{}
			msg.Pet = &serverproto.RolePet{}
			err = model.GetDecodeMessage(msg.Pet, val)
			if err != nil {
				util.ErrorF("GetRolePetDataFromRedis Base Unmarshal uid=%v err=%v", uid, err)
				continue
			}
			model.ServiceReplay(ev, msg)
		} else if strings.Contains(key, RolePetDataFieldPrefix_petlist) {
			tmpPetData := &serverproto.PetData{}
			err = model.GetDecodeMessage(tmpPetData, val)
			if err != nil {
				util.ErrorF("GetRolePetDataFromRedis PetData Unmarshal uid=%v err=%v", uid, err)
				continue
			}
			tmpPetData.BattleAttrListOld = tmpPetData.BattleAttrListOld[:0]
			tmpPetList = append(tmpPetList, tmpPetData)
			dataCount++
		} else if strings.Contains(key, RolePetDataFieldPrefix_bond) {
			tmpBondData := &serverproto.PetBondData{}
			err = model.GetDecodeMessage(tmpBondData, val)
			if err != nil {
				util.ErrorF("GetRolePetDataFromRedis BondData Unmarshal uid=%v err=%v", uid, err)
				continue
			}
			tmpPetBondList = append(tmpPetBondList, tmpBondData)
			dataCount++
		}

		if dataCount >= 100 {
			msg := &serverproto.SSLoadPetNtf{}
			msg.Pet = &serverproto.RolePet{}
			msg.Pet.PetList = append(msg.Pet.PetList, tmpPetList...)
			msg.Pet.BondList = append(msg.Pet.BondList, tmpPetBondList...)
			model.ServiceReplay(ev, msg)

			tmpPetList = tmpPetList[:0]
			tmpPetBondList = tmpPetBondList[:0]
			dataCount = 0
		}
	}

	if dataCount > 0 {
		msg := &serverproto.SSLoadPetNtf{}
		msg.Pet = &serverproto.RolePet{}
		msg.Pet.PetList = append(msg.Pet.PetList, tmpPetList...)
		msg.Pet.BondList = append(msg.Pet.BondList, tmpPetBondList...)
		model.ServiceReplay(ev, msg)

		tmpPetList = tmpPetList[:0]
		tmpPetBondList = tmpPetBondList[:0]
		dataCount = 0
	}
	return true
}

// //skill equip
func GetRoleSkillEquipDataFromRedis(uid uint64, roleSkillEquip *serverproto.RoleSkillEquip) bool {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleSkillEquipDataPrefix + uidStr

	if !model.ExistKey(keyStr) {
		return false
	}
	if roleSkillEquip == nil {
		return false
	}

	//base
	baseStr, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.ErrorF("GetRoleSkillEquipDataFromRedis uid=%v err=%v", uid, err)
		return false
	}
	util.InfoF("uid=%v GetRoleSkillEquipDataFromRedis len=%v", uid, len(baseStr))

	//var tmpSkillEquipList []*serverproto.SkillEquipData
	//dataCount := 0
	for key, val := range baseStr {
		if key == RoleSkillEquipDataPrefix_base {
			//msg := &serverproto.SSLoadSkillEquipNtf{}
			//msg.SkillEquip = &serverproto.RoleSkillEquip{}

			tempSkillEquip := &serverproto.RoleSkillEquip{}
			err = model.GetDecodeMessage(tempSkillEquip, val)
			if err != nil {
				util.ErrorF("GetRoleSkillEquipDataFromRedis Base Unmarshal uid=%v err=%v", uid, err)
				continue
			}
			//model.ServiceReplay(ev, msg)
			roleSkillEquip.MaxSkillEquipId = tempSkillEquip.MaxSkillEquipId

		} else if strings.Contains(key, RoleSkillEquipDataPrefix_list) {
			tmpEquipData := &serverproto.SkillEquipData{}
			err = model.GetDecodeMessage(tmpEquipData, val)
			if err != nil {
				util.ErrorF("GetRoleSkillEquipDataFromRedis PetData Unmarshal uid=%v err=%v", uid, err)
				continue
			}
			roleSkillEquip.SkillEquipList = append(roleSkillEquip.SkillEquipList, tmpEquipData)
			//dataCount++
		}

		//if dataCount >= 100 {
		//	msg := &serverproto.SSLoadSkillEquipNtf{}
		//	msg.SkillEquip = &serverproto.RoleSkillEquip{}
		//	msg.SkillEquip.SkillEquipList = append(msg.SkillEquip.SkillEquipList, tmpSkillEquipList...)
		//	model.ServiceReplay(ev, msg)
		//
		//	tmpSkillEquipList = tmpSkillEquipList[:0]
		//	dataCount = 0
		//}
	}

	//if dataCount > 0 {
	//	msg := &serverproto.SSLoadSkillEquipNtf{}
	//	msg.SkillEquip = &serverproto.RoleSkillEquip{}
	//	msg.SkillEquip.SkillEquipList = append(msg.SkillEquip.SkillEquipList, tmpSkillEquipList...)
	//	model.ServiceReplay(ev, msg)
	//	tmpSkillEquipList = tmpSkillEquipList[:0]
	//	dataCount = 0
	//}

	return true
}

func SetSkillEquipDataToRedis(uid uint64, msg *serverproto.SSSkillEquipDataSaveReq) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleSkillEquipDataPrefix + uidStr

	// base info
	baseStr, err := service.GetRedis().HGet(keyStr, RoleSkillEquipDataPrefix_base).Result()
	if err != nil && err != service.NIL {
		util.ErrorF("SetSkillEquipDataToRedis Base uid=%v err=%v", uid, err)
		return
	}
	roleSkillEquip := &serverproto.RoleSkillEquip{}
	if err == service.NIL {
		msg.SkillEquipDelList = []uint32{}
	} else {
		err = model.GetDecodeMessage(roleSkillEquip, baseStr)
		if err != nil {
			util.ErrorF("SetSkillEquipDataToRedis base Unmarshal uid=%v err=%v", uid, err)
			return
		}
	}
	if msg.SkillEquip.MaxSkillEquipId > roleSkillEquip.MaxSkillEquipId {
		roleSkillEquip.MaxSkillEquipId = msg.SkillEquip.MaxSkillEquipId
		err, msgData := model.GetEncodeMessage(roleSkillEquip)
		if err != nil {
			util.ErrorF("SetSkillEquipDataToRedis uid=%v Marshal err=%v field=base", uid, err)
			return
		}
		service.GetRedis().HSet(keyStr, RoleSkillEquipDataPrefix_base, msgData)
	}

	//skill equip add
	for idx := 0; idx < len(msg.SkillEquip.SkillEquipList); idx++ {
		skillEquip := msg.SkillEquip.SkillEquipList[idx]
		if skillEquip == nil {
			continue
		}
		err, msgData := model.GetEncodeMessage(skillEquip)
		if err != nil {
			continue
		}
		fieldStr := RoleSkillEquipDataPrefix_list + strconv.Itoa(int(skillEquip.Id))
		service.GetRedis().HSet(keyStr, fieldStr, msgData)
	}

	//skill equip remove
	for idx := 0; idx < len(msg.SkillEquipDelList); idx++ {
		if msg.SkillEquipDelList[idx] <= 0 {
			continue
		}
		fieldStr := RoleSkillEquipDataPrefix_list + strconv.Itoa(int(msg.SkillEquipDelList[idx]))
		service.GetRedis().HDel(keyStr, fieldStr)
	}
}

func SetRolePetDataToRedis(uid uint64, msg *serverproto.SSPetDataSaveReq) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RolePetDataPrefix + uidStr

	baseStr, err := service.GetRedis().HGet(keyStr, RolePetDataFieldPrefix_base).Result()
	if err != nil && err != service.NIL {
		util.ErrorF("SetRolePetDataToRedis Base uid=%v err=%v", uid, err)
		return
	}
	//base
	rolePet := &serverproto.RolePet{}
	if err == service.NIL {
		rolePet.PetManualRewardList = msg.RolePet.PetManualRewardList

		msg.PetDelList = []uint32{}
		msg.BondDelList = []int32{}
	} else {
		err = model.GetDecodeMessage(rolePet, baseStr)
		if err != nil {
			util.ErrorF("SetRolePetDataToRedis base Unmarshal uid=%v err=%v", uid, err)
			return
		}
		if msg.RolePet.PetManualRewardList != nil {
			rolePet.PetManualRewardList = msg.RolePet.PetManualRewardList
		}
	}
	if msg.RolePet.MaxPetId > rolePet.MaxPetId {
		rolePet.MaxPetId = msg.RolePet.MaxPetId
	}
	rolePet.PetManualList = rolePet.PetManualList[:0]
	rolePet.AssistList = msg.RolePet.AssistList
	rolePet.RushPet = msg.RolePet.RushPet
	rolePet.PetEquipList = msg.RolePet.PetEquipList

	err, msgData := model.GetEncodeMessage(rolePet)
	if err != nil {
		util.ErrorF("SetRolePetDataToRedis uid=%v Marshal err=%v field=base", uid, err)
		return
	}
	service.GetRedis().HSet(keyStr, RolePetDataFieldPrefix_base, msgData)

	//pet
	for idx := 0; idx < len(msg.RolePet.PetList); idx++ {
		petData := msg.RolePet.PetList[idx]
		if petData == nil {
			continue
		}
		err, msgData := model.GetEncodeMessage(petData)
		if err != nil {
			continue
		}
		fieldStr := RolePetDataFieldPrefix_petlist + strconv.Itoa(int(petData.Id))
		service.GetRedis().HSet(keyStr, fieldStr, msgData)
	}
	for idx := 0; idx < len(msg.PetDelList); idx++ {
		if msg.PetDelList[idx] <= 0 {
			continue
		}
		fieldStr := RolePetDataFieldPrefix_petlist + strconv.Itoa(int(msg.PetDelList[idx]))
		service.GetRedis().HDel(keyStr, fieldStr)
	}
	//bond
	for idx := 0; idx < len(msg.RolePet.BondList); idx++ {
		bondData := msg.RolePet.BondList[idx]
		if bondData == nil {
			continue
		}
		err, msgData := model.GetEncodeMessage(bondData)
		if err != nil {
			continue
		}
		fieldStr := RolePetDataFieldPrefix_bond + strconv.Itoa(int(bondData.BondCfgId))
		service.GetRedis().HSet(keyStr, fieldStr, msgData)
	}
	for idx := 0; idx < len(msg.BondDelList); idx++ {
		if msg.BondDelList[idx] <= 0 {
			continue
		}
		fieldStr := RolePetDataFieldPrefix_bond + strconv.Itoa(int(msg.BondDelList[idx]))
		service.GetRedis().HDel(keyStr, fieldStr)
	}
}

func SetRolePetAssistDataToRedis(uid uint64, msg *serverproto.SSPetSetAssistNtf) {
	uidStr := strconv.FormatUint(uid, 10)

	err, msgData := model.GetEncodeMessage(msg)
	if err != nil {
		return
	}
	service.GetRedis().HSet(RolePetAssistDataPrefix, uidStr, msgData)
}

func getBattlePetInfo(uid uint64, petId uint32) *serverproto.PetData {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RolePetDataPrefix + uidStr

	fieldStr := RolePetDataFieldPrefix_petlist + strconv.Itoa(int(petId))
	//base
	petStr, err := service.GetRedis().HGet(keyStr, fieldStr).Result()
	if err != nil {
		util.ErrorF("getBattlePetInfo uid=%v err=%v", uid, err)
		return nil
	}

	tmpPetData := &serverproto.PetData{}
	err = model.GetDecodeMessage(tmpPetData, petStr)
	if err != nil {
		util.ErrorF("GetRolePetDataFromRedis PetData Unmarshal uid=%v err=%v", uid, err)
		return nil
	}

	return tmpPetData
}

func getRolePetAssistDataFromRedis(uid uint64, roleAssistList map[uint32]*serverproto.AssistSaveData) {
	uidStr := strconv.FormatUint(uid, 10)

	msgStr, err := service.GetRedis().HGet(RolePetAssistDataPrefix, uidStr).Result()
	if err != nil {
		return
	}
	tmpMsg := &serverproto.SSPetSetAssistNtf{}
	err = model.GetDecodeMessage(tmpMsg, msgStr)
	if err != nil {
		return
	}
	for idx := 0; idx < len(tmpMsg.AssistList); idx++ {
		roleAssistList[tmpMsg.AssistList[idx].PetId] = tmpMsg.AssistList[idx]
	}
}

// 获取其他援助玩家的宠物信息(羁绊信息，已经设置在玩家的羁绊列表中，检查合法性)
func RolePetQueryAssistInfo(uid uint64, msg *serverproto.SSPetQueryAssistInfoReq, ackMsg *serverproto.SSPetQueryAssistInfoAck) {
	tmpList := set.New(set.NonThreadSafe)
	for idx := 0; idx < len(msg.UidList); idx++ {
		tmpList.Add(msg.UidList[idx])
	}
	//获取公会成员列表
	var guildUidList []uint64
	getGuildMemberLis(msg.GuildId, &guildUidList)
	for idx := 0; idx < len(guildUidList); idx++ {
		if !tmpList.Has(guildUidList[idx]) && guildUidList[idx] != uid {
			tmpList.Add(guildUidList[idx])
		}
	}

	for idx := 0; idx < len(msg.QueryAssistList); idx++ {
		assistData := msg.QueryAssistList[idx]
		//判断是否是好友，或者公会成员
		if !tmpList.Has(assistData.OwnerUid) {
			ackMsg.QueryAssistList = append(ackMsg.QueryAssistList, assistData)
			continue
		}

		AssistCache := getAssistCache(assistData.OwnerUid)
		if AssistCache == nil {
			ackMsg.QueryAssistList = append(ackMsg.QueryAssistList, assistData)
			continue
		}
		roleAssistList := getAssistCache(assistData.OwnerUid).assistData
		bFind := false
		for i := 0; i < len(assistData.PetInfoList); i++ {
			tmpData := assistData.PetInfoList[i]
			if val, ok := roleAssistList[tmpData.Id]; ok {
				tmpData.AdvanceLevel = val.AdvLevel
				tmpData.ConfigId = val.PetCfgId
				tmpData.Id = val.PetId
				tmpData.Param = 1 //表示当前找到对应ID的宠物
				bFind = true
			}
		}

		//目前uid对应玩家，羁绊列表中用到了援助玩家宠物
		if bFind {
			assistData.OwnerNickName = AssistCache.nickName
		}
		ackMsg.QueryAssistList = append(ackMsg.QueryAssistList, assistData)
	}
}

// 获取激活羁绊所需的宠物列表(援助列表)
type AssistCacheDetailInfo struct {
	quality int32
	nature  int32
}
type RolePetAssistCacheInfo struct {
	uid           uint64
	assistData    map[uint32]*serverproto.AssistSaveData
	assistCfgData map[uint32]*AssistCacheDetailInfo

	nickName       string
	refreshTime    uint64
	tempAssistData map[uint32]*serverproto.AssistSaveData
}

func (this *RolePetAssistCacheInfo) getAssistInfoByType(assistType serverproto.EPetAssistType,
	assistTypeVal int32) []*serverproto.AssistSaveData {
	//if assistType == serverproto.EPetAssistType_EPetAssistType_Num {
	//	return nil
	//}
	//
	//var retList []*serverproto.AssistSaveData
	//for key, val := range this.tempAssistData {
	//	if assistType == serverproto.EPetAssistType_EPetAssistType_Quality {
	//		if this.assistCfgData[key].quality >= assistTypeVal {
	//			retList = append(retList, val)
	//			delete(this.tempAssistData, key)
	//		}
	//	} else if assistType == serverproto.EPetAssistType_EPetAssistType_AdvLevel {
	//		if val.AdvLevel >= uint32(assistTypeVal) {
	//			retList = append(retList, val)
	//			delete(this.tempAssistData, key)
	//		}
	//	} else if assistType == serverproto.EPetAssistType_EPetAssistType_Nature {
	//		if this.assistCfgData[key].nature == assistTypeVal {
	//			retList = append(retList, val)
	//			delete(this.tempAssistData, key)
	//		}
	//	}
	//}
	//return retList

	//相同宠物配置ID，进阶等级>=assistTypeVal
	var retList []*serverproto.AssistSaveData
	for key, val := range this.tempAssistData {
		if val.PetCfgId == int32(assistType) && val.AdvLevel >= uint32(assistTypeVal) {
			retList = append(retList, val)
			delete(this.tempAssistData, key)
		}
	}

	return retList
}
func (this *RolePetAssistCacheInfo) CopyAssistData() {
	this.tempAssistData = map[uint32]*serverproto.AssistSaveData{}
	for key, val := range this.assistData {
		this.tempAssistData[key] = val
	}
}

var RolePetAssistListCache = map[uint64]*RolePetAssistCacheInfo{}

const AssistInfoInvalidTime = 7 * 24 * 60 * 60 * 1000

func getAssistCache(uid uint64) *RolePetAssistCacheInfo {
	nowTime := util.GetTimeMilliseconds()
	cacheInfo, ok := RolePetAssistListCache[uid]
	if !ok {
		_, bfInfo := GetPlayerBriefInfo(uid)
		if bfInfo == nil {
			return nil
		}
		if bfInfo.OnlineTime > 0 && bfInfo.OnlineTime+uint64(AssistInfoInvalidTime) <= nowTime {
			return nil
		}

		cacheInfo = &RolePetAssistCacheInfo{
			uid:           uid,
			assistData:    map[uint32]*serverproto.AssistSaveData{},
			assistCfgData: map[uint32]*AssistCacheDetailInfo{},
			nickName:      bfInfo.NickName,
		}
		cacheInfo.refreshTime = nowTime + uint64(BriefInfoRefreshTime+rand.Int31n(BriefInfoRefreshTime))

		getRolePetAssistDataFromRedis(uid, cacheInfo.assistData)
		for key, val := range cacheInfo.assistData {
			petCfgData, ok1 := serverproto.PetCfgLoader[val.PetCfgId]
			if !ok1 {
				continue
			}
			cacheInfo.assistCfgData[key] = &AssistCacheDetailInfo{
				quality: petCfgData.Quality,
				nature:  petCfgData.NatureType,
			}
		}
	} else {
		_, bfInfo := GetPlayerBriefInfo(uid)
		if bfInfo == nil {
			delete(RolePetAssistListCache, uid)
			return nil
		}
		if bfInfo.OnlineTime > 0 && bfInfo.OnlineTime+uint64(AssistInfoInvalidTime) <= nowTime {
			delete(RolePetAssistListCache, uid)
			return nil
		}

		if cacheInfo.refreshTime < nowTime {
			cacheInfo.refreshTime = nowTime + uint64(BriefInfoRefreshTime+rand.Int31n(BriefInfoRefreshTime))
			//assistDataInfo
			cacheInfo.assistData = map[uint32]*serverproto.AssistSaveData{}
			cacheInfo.assistCfgData = map[uint32]*AssistCacheDetailInfo{}
			cacheInfo.nickName = bfInfo.NickName

			getRolePetAssistDataFromRedis(uid, cacheInfo.assistData)

			for key, val := range cacheInfo.assistData {
				petCfgData, ok1 := serverproto.PetCfgLoader[val.PetCfgId]
				if !ok1 {
					continue
				}
				cacheInfo.assistCfgData[key] = &AssistCacheDetailInfo{
					quality: petCfgData.Quality,
					nature:  petCfgData.NatureType,
				}
			}
		}
	}

	return cacheInfo
}

// 获取公会成员列表
func getGuildMemberLis(guildId uint64, guildMemberList *[]uint64) {
	if guildId <= 0 {
		return
	}
	keyStr := model.GuildMemberPrefix
	filedStr := strconv.FormatUint(guildId, 10)

	retStr, err := service.GetRedis().HGet(keyStr, filedStr).Result()
	if err != nil {
		return
	}
	guildMember := &serverproto.MemberData{}
	err = model.GetDecodeMessage(guildMember, retStr)
	if err != nil {
		return
	}

	for idx := 0; idx < len(guildMember.MemberInfo); idx++ {
		*guildMemberList = append(*guildMemberList, guildMember.MemberInfo[idx].MemberId)
	}
}

func RolePetBondAssistListGet(uid uint64, msg *serverproto.SSPetBondAssistListReq, ack *serverproto.SSPetBondAssistListAck) {
	//每个位置最多放置N个宠物，总数不够时再进行填充
	tmpList := set.New(set.NonThreadSafe)
	for idx := 0; idx < len(msg.UidList); idx++ {
		tmpList.Add(msg.UidList[idx])
	}

	//获取公会成员列表
	var guildUidList []uint64
	getGuildMemberLis(msg.GuildId, &guildUidList)
	for idx := 0; idx < len(guildUidList); idx++ {
		if !tmpList.Has(guildUidList[idx]) && guildUidList[idx] != uid {
			tmpList.Add(guildUidList[idx])
		}
	}

	var conditionSelectPetOtherList = map[uint64][]*serverproto.AssistSaveData{}
	var conditionSelectPetList = map[uint64][]*serverproto.AssistSaveData{}
	//var conditionSelectPetNeedList = map[int32]int32{} //位置对应的数量
	var uidNameList = map[uint64]string{}
	var retNumList = map[int]int32{}

	totalNum := 0
	uidList := tmpList.List()
	for idx := 0; idx < len(uidList); idx++ {
		findUid := uidList[idx].(uint64)
		cacheInfo := getAssistCache(findUid)
		if cacheInfo == nil {
			continue
		}
		uidNameList[findUid] = cacheInfo.nickName
		cacheInfo.CopyAssistData()

		//key类型，v1类型数值 v2类型数量
		//1品质 2进阶等级 3特殊属性 4数量个数
		//Condition3List
		totalNum += BondAssistListGetByCondition(findUid, 3, msg.Condition3List, cacheInfo,
			conditionSelectPetOtherList, conditionSelectPetList, retNumList)
		//Condition2List
		totalNum += BondAssistListGetByCondition(findUid, 3, msg.Condition2List, cacheInfo,
			conditionSelectPetOtherList, conditionSelectPetList, retNumList)
		//Condition1List
		totalNum += BondAssistListGetByCondition(findUid, 3, msg.Condition1List, cacheInfo,
			conditionSelectPetOtherList, conditionSelectPetList, retNumList)

		if totalNum >= 45 {
			break
		}
	}

	//todo...
	// 总数不够需要进行填充
	totalNum = 0
	var ackAssistList []*serverproto.AssistData
	for key, valList := range conditionSelectPetList {
		assistData := &serverproto.AssistData{
			OwnerNickName: uidNameList[key],
			OwnerUid:      key,
		}
		for idx := 0; idx < len(valList); idx++ {
			petData := &serverproto.PetData{
				Id:           valList[idx].PetId,
				ConfigId:     valList[idx].PetCfgId,
				AdvanceLevel: valList[idx].AdvLevel,
				Param:        1,
			}
			assistData.PetInfoList = append(assistData.PetInfoList, petData)
			totalNum++
		}
		ackAssistList = append(ackAssistList, assistData)
	}

	for key, valList := range conditionSelectPetOtherList {
		var assistData *serverproto.AssistData = nil
		for idx := 0; idx < len(ackAssistList); idx++ {
			if ackAssistList[idx].OwnerUid == key {
				assistData = ackAssistList[idx]
				break
			}
		}
		if assistData == nil {
			assistData = &serverproto.AssistData{
				OwnerNickName: uidNameList[key],
				OwnerUid:      key,
			}
			ackAssistList = append(ackAssistList, assistData)
		}
		for idx := 0; idx < len(valList); idx++ {
			petData := &serverproto.PetData{
				Id:           valList[idx].PetId,
				ConfigId:     valList[idx].PetCfgId,
				AdvanceLevel: valList[idx].AdvLevel,
				Param:        1,
			}
			assistData.PetInfoList = append(assistData.PetInfoList, petData)
			totalNum++
			if totalNum >= 45 {
				break
			}
		}
		if totalNum >= 45 {
			break
		}
	}

	ack.AssistList = append(ack.AssistList, ackAssistList...)
}

func BondAssistListGetByCondition(findUid uint64, conditionIdx int, conList []*serverproto.KeyValueType, cacheInfo *RolePetAssistCacheInfo,
	otherList map[uint64][]*serverproto.AssistSaveData, needList map[uint64][]*serverproto.AssistSaveData, retNumList map[int]int32) int {
	totalNum := 0
	//key类型，v1类型数值 v2类型数量
	//1品质 2进阶等级 3特殊属性 4数量个数
	for k := 0; k < len(conList); k++ {
		retList := cacheInfo.getAssistInfoByType((serverproto.EPetAssistType)(conList[k].Key), conList[k].Value)
		if len(retList) <= 0 {
			continue
		}

		retNumIdx := conditionIdx*10 + (k + 1)
		if retNumList[retNumIdx] >= 5 {
			otherList[findUid] = append(otherList[findUid], retList...)
		} else {
			i := retNumList[retNumIdx]
			j := 0
			for ; i < 5; i++ {
				needList[findUid] = append(needList[findUid], retList[j])
				j++
				totalNum++
				retNumList[retNumIdx]++
				if j >= len(retList) {
					break
				}
			}
			//剩余的放到other列表中，当总数不足时进行填充
			if j < len(retList) {
				for ii := j; ii < len(retList); ii++ {
					otherList[findUid] = append(otherList[findUid], retList[ii])
				}
			}
		}
	}
	return totalNum
}

func PetAdvAchievementGet(petCfgId int32, ackMsg *serverproto.SSPetAdvAchievementAck) {
	fieldStr := strconv.Itoa(int(petCfgId))
	msgData, err := service.GetRedis().HGet(RolePetAchievementPrefix, fieldStr).Result()
	if err != nil {
		return
	}

	advData := &serverproto.PetAdvAchievementData{}
	err = model.GetDecodeMessage(advData, msgData)
	if err != nil {
		return
	}

	_, bf := GetPlayerBriefInfo(advData.Uid)
	if bf != nil {
		ackMsg.Brief = bf
		ackMsg.PetCfgId = petCfgId
		ackMsg.AchievementTime = advData.AchievementTime
	}
}

func PetAdvAchievementSet(uid uint64, petCfgId int32, advLevel int32) {
	fieldStr := strconv.Itoa(int(petCfgId))
	msgData, err := service.GetRedis().HGet(RolePetAchievementPrefix, fieldStr).Result()
	if err != nil && err != service.NIL {
		return
	}

	advData := &serverproto.PetAdvAchievementData{}
	err = model.GetDecodeMessage(advData, msgData)
	if err != nil && err != service.NIL {
		return
	}

	if advData.Uid != 0 {
		//update
		if advData.AdvLevel < advLevel {
			advData.AdvLevel = advLevel
			advData.Uid = uid
			advData.AchievementTime = util.GetTimeMilliseconds()
			err, msgData = model.GetEncodeMessage(advData)
			if err != nil {
				return
			}
			service.GetRedis().HSet(RolePetAchievementPrefix, fieldStr, msgData)
		}
	} else {
		advData.AdvLevel = advLevel
		advData.Uid = uid
		advData.AchievementTime = util.GetTimeMilliseconds()
		err, msgData = model.GetEncodeMessage(advData)
		if err != nil {
			return
		}
		service.GetRedis().HSet(RolePetAchievementPrefix, fieldStr, msgData)
	}
}

// //expedition
// 救助发起求助的玩家 FromUid发起救助操作的玩家  BeHelpedUid发起求助的放玩家
func ExpeditionHelp(fromUid, beHelpedUid uint64) serverproto.ErrorCode {
	//uidStr := strconv.FormatUint(beHelpedUid, 10)
	//战斗数据
	beHelpedRoleBattle := &serverproto.RoleBattle{}
	err := GetSystemDataFromRedis(RoleBattleDataPrefix, beHelpedUid, beHelpedRoleBattle)
	if err != nil {
		util.InfoF("uid=%v ExpeditionHelp beHelpedUid=%v err=%v", fromUid, beHelpedUid, err)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	tmpExpeditionInfo := beHelpedRoleBattle.ExpeditionInfo
	if tmpExpeditionInfo.BeAssistNum != nil {
		//该玩家被救助的次数达到上限，无法救助
		if tmpExpeditionInfo.BeAssistNum.Key <= tmpExpeditionInfo.BeAssistNum.Value {
			return serverproto.ErrorCode_ERROR_EXPEDITION_HELP_CALLFORHELP_LIMIT
		}
	}

	//之前过期的救助消息
	if tmpExpeditionInfo.AssistTimeStamp == 0 {
		return serverproto.ErrorCode_ERROR_EXPEDITION_HELP_MSG_EXPIRED
	}

	//已经救助过该玩家，无法再次救助
	bFind := false
	idx := 0
	for idx = 0; idx < len(tmpExpeditionInfo.BeAssistUidList); idx++ {
		tmpUidData := tmpExpeditionInfo.BeAssistUidList[idx]
		//判断是否是同一天救助
		bNotSameDay := model.IsDailyResetHour5(uint64(tmpUidData.Value) * 1000)
		if tmpUidData.Key == fromUid {
			if !bNotSameDay {
				return serverproto.ErrorCode_ERROR_EXPEDITION_HELP_CALLFORHELP_HAS
			}
			bFind = true
			break
		}
	}

	//判断是否需要救助(英雄是否有死亡)
	canBeHelp := false
	for idx := 0; idx < len(tmpExpeditionInfo.BattleHeroHpList); idx++ {
		if tmpExpeditionInfo.BattleHeroHpList[idx].Hp <= 0 {
			canBeHelp = true
			break
		}
	}
	if !canBeHelp {
		return serverproto.ErrorCode_ERROR_EXPEDITION_BE_HELPED
	}

	//增加beHelpedUid玩家被救助次数
	if tmpExpeditionInfo.BeAssistNum == nil {
		tmpExpeditionInfo.BeAssistNum = &serverproto.KeyValueType{
			Key: model.GlobalExpeditionGuildBeHelpedNum,
		}
	}
	//增加被救助次数
	tmpExpeditionInfo.BeAssistNum.Value += 1
	tmpExpeditionInfo.AssistState = false
	tmpExpeditionInfo.AssistTimeStamp = 0
	//回复所有英雄hp,sp
	tmpExpeditionInfo.BattleHeroHpList = tmpExpeditionInfo.BattleHeroHpList[:0]
	//加入救助列表
	if bFind {
		tmpExpeditionInfo.BeAssistUidList[idx].Value = int32(util.GetTimeSeconds())
	} else {
		tmpExpeditionInfo.BeAssistUidList = append(tmpExpeditionInfo.BeAssistUidList,
			&serverproto.KeyValueType64{Key: fromUid, Value: int32(util.GetTimeSeconds())})
	}
	err = SetSystemDataToRedis(RoleBattleDataPrefix, beHelpedUid, beHelpedRoleBattle)
	if err != nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	return serverproto.ErrorCode_ERROR_OK
}

// //pay支付
func SetPayOrderInfoToRedis(uid uint64, payOrderInfo *serverproto.PayOrderSaveInfo) serverproto.ErrorCode {
	uidStr := strconv.FormatUint(uid, 10)

	switch payOrderInfo.OrderState {
	case int32(serverproto.PayOrderState_EPayOrderState_Gen): //订单生成并保持
		fallthrough
	case int32(serverproto.PayOrderState_EPayOrderState_PayFailed):
		orderStr := strconv.FormatUint(payOrderInfo.CpOrderId, 10)
		err, msgData := model.GetEncodeMessage(payOrderInfo)
		if err != nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		err = service.GetRedis().HSet(model.PayOrderPrefix, orderStr, msgData).Err()
		if err != nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}

	case int32(serverproto.PayOrderState_EPayOrderState_PayOk): //添加到成功但是没有获取奖励的订单id
		okListKeyStr := model.PayOrderOKIdListPrefix + uidStr
		orderStr := strconv.FormatUint(payOrderInfo.CpOrderId, 10)
		//是否已经在完成订单id列表中
		if service.GetRedis().SIsMember(okListKeyStr, payOrderInfo.CpOrderId).Val() {
			util.InfoF("uid=%v SetPayOrderInfoToRedis order has been set ok for reward orderid=%v", uid, payOrderInfo.CpOrderId)
			return serverproto.ErrorCode_ERROR_FAIL
		}

		msgStr, err := service.GetRedis().HGet(model.PayOrderPrefix, orderStr).Result()
		if err != nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		oldPayOrderInfo := &serverproto.PayOrderSaveInfo{}
		err = model.GetDecodeMessage(oldPayOrderInfo, msgStr)
		if err != nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		if oldPayOrderInfo.OrderState == int32(serverproto.PayOrderState_EPayOrderState_Gen) {
			oldPayOrderInfo.OrderState = int32(serverproto.PayOrderState_EPayOrderState_PayOk)
			oldPayOrderInfo.OrderProcessTime = util.GetTimeMilliseconds()

			err, msgData := model.GetEncodeMessage(oldPayOrderInfo)
			if err != nil {
				return serverproto.ErrorCode_ERROR_FAIL
			}
			service.GetRedis().HSet(model.PayOrderPrefix, orderStr, msgData)
			//完成订单id列表
			okListKeyStr := model.PayOrderOKIdListPrefix + uidStr
			service.GetRedis().SAdd(okListKeyStr, payOrderInfo.CpOrderId)
		}
	case int32(serverproto.PayOrderState_EPayOrderState_PayOkReward):
		orderStr := strconv.FormatUint(payOrderInfo.CpOrderId, 10)
		payOrderInfo.OrderProcessTime = util.GetTimeMilliseconds()
		err, msgData := model.GetEncodeMessage(payOrderInfo)
		if err != nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		err = service.GetRedis().HSet(model.PayOrderPrefix, orderStr, msgData).Err()
		if err != nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		//移除成订单id列表
		okListKeyStr := model.PayOrderOKIdListPrefix + uidStr
		service.GetRedis().SRem(okListKeyStr, payOrderInfo.CpOrderId)
	default:
		return serverproto.ErrorCode_ERROR_FAIL
	}

	return serverproto.ErrorCode_ERROR_OK
}
func GetPayOrderOkListFromRedis(uid uint64, ackMsg *serverproto.SSPayInfoOrderOkListGetAck) {
	uidStr := strconv.FormatUint(uid, 10)
	okListKeyStr := model.PayOrderOKIdListPrefix + uidStr

	listStr, err := service.GetRedis().SMembers(okListKeyStr).Result()
	if err != nil {
		return
	}
	for idx := 0; idx < len(listStr); idx++ {
		msgStr, err := service.GetRedis().HGet(model.PayOrderPrefix, listStr[idx]).Result()
		if err != nil {
			service.GetRedis().HDel(model.PayOrderPrefix, listStr[idx])
			util.ErrorF("uid=%v GetPayOrderOkListFromRedis ok order not exist orderId=%v err=%v", uid, listStr[idx], err)
			continue
		}
		payInfo := &serverproto.PayOrderSaveInfo{}
		err = model.GetDecodeMessage(payInfo, msgStr)
		if err != nil {
			util.ErrorF("uid=%v GetPayOrderOkListFromRedis decode order=%v err=%v", uid, listStr[idx], err)
			continue
		}

		if payInfo.OrderState == int32(serverproto.PayOrderState_EPayOrderState_PayOk) {
			ackMsg.PayOrderOkList = append(ackMsg.PayOrderOkList, payInfo)
		} else {
			//pay money not equal with order money
			service.GetRedis().HDel(model.PayOrderPrefix, listStr[idx])
			util.ErrorF("uid=%v GetPayOrderOkListFromRedis order state error", uid, listStr[idx])
		}
	}
}

// //百人道场
func SetRoleDaoChang100ToRedis(uid uint64, info *serverproto.RoleDaoChang100) bool {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := model.RoleDaoChang100Prefix + uidStr

	if info.LogState {
		service.GetRedis().HSet(keyStr, "log", 1)
	} else {
		service.GetRedis().HSet(keyStr, "log", 0)
	}
	service.GetRedis().HSet(keyStr, "lastattackuid", info.LastAttackUid)

	info.LogState = false
	err, msgStr := model.GetEncodeMessage(info)
	if err != nil {
		util.ErrorF("SetRoleDaoChang100ToRedis uid=%v err=%v", uid, err)
		return false
	}
	service.GetRedis().HSet(keyStr, "base", msgStr)

	return true
}

func GetRoleDaoChang100FromRedis(uid uint64, info *serverproto.RoleDaoChang100) bool {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := model.RoleDaoChang100Prefix + uidStr

	baseStr, err := service.GetRedis().HGet(keyStr, "base").Result()
	if err != nil {
		if err != service.NIL {
			util.ErrorF("GetRoleDaoChang100FromRedis uid=%v err=%v", uid, err)
		}
		return false
	}

	err = model.GetDecodeMessage(info, baseStr)
	if err != nil {
		util.ErrorF("GetRoleDaoChang100FromRedis uid=%v err=%v GetDecodeMessage", uid, err)
		return false
	}

	//log state
	logStr, err := service.GetRedis().HGet(keyStr, "log").Result()
	if err != nil {
		util.ErrorF("GetRoleDaoChang100FromRedis uid=%v err=%v", uid, err)
		return false
	}
	logState, err := model.Str2Num(logStr)
	if err != nil {
		util.ErrorF("GetRoleDaoChang100FromRedis uid=%v err=%v", uid, err)
	}
	if logState > 0 {
		info.LogState = true
	}

	//lastattackuid
	lastAttackUidStr, err := service.GetRedis().HGet(keyStr, "lastattackuid").Result()
	if err != nil {
		util.ErrorF("GetRoleDaoChang100FromRedis uid=%v err=%v", uid, err)
		return false
	}
	lastAttackUid, err := model.Str2NumU64(lastAttackUidStr)
	if err != nil {
		util.ErrorF("GetRoleDaoChang100FromRedis uid=%v err=%v", uid, err)
	}
	info.LastAttackUid = lastAttackUid
	return true
}

const MaxDaoChang100WheelLogCount int64 = 20

func GetRoleDaoChang100WheelLogListFromRedis(ssAckMsg *serverproto.SCDaoChang100WheelLogAck) {
	keyStr := model.RoleDaoChang100WheeLogPrefix
	msgList, err := service.GetRedis().LRange(keyStr, 0, MaxDaoChang100WheelLogCount-1).Result()
	if err != nil {
		return
	}
	for idx := 0; idx < len(msgList); idx++ {
		logData := &serverproto.WheelLogData{}
		err := model.GetDecodeMessage(logData, msgList[idx])
		if err != nil {
			continue
		}
		ssAckMsg.LogList = append(ssAckMsg.LogList, logData)
	}
}

func SetRoleDaoChang100WheelLogToRedis(uid uint64, msg *serverproto.SSDaoChang100WheelLogAddNtf) {
	keyStr := model.RoleDaoChang100WheeLogPrefix
	for idx := 0; idx < len(msg.LogList); idx++ {
		err, logMsg := model.GetEncodeMessage(msg.LogList[idx])
		if err != nil {
			continue
		}
		retNum, err := service.GetRedis().LPush(keyStr, logMsg).Result()
		if err == nil && retNum > MaxDaoChang100WheelLogCount {
			service.GetRedis().LTrim(keyStr, 0, MaxDaoChang100WheelLogCount-1)
		}
	}
}

// 远航被挑战日志保存
func SetRoleCrossYuanHangLogToRedis(msg *serverproto.SSCrossYuanHangTrialLogNtf) {
	uid := msg.NtfUid
	roleCross := &serverproto.RoleCross{}
	err := GetSystemDataFromRedis(RoleCrossPrefix, uid, roleCross)
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleFromRedis SetRoleCrossYuanHangLogToRedis err=%v uid=%v", err, uid)
		return
	}

	if roleCross.Yuanhangtrial != nil {
		roleCross.Yuanhangtrial.LogList = append(roleCross.Yuanhangtrial.LogList, msg.LogData)
		err = SetSystemDataToRedis(RoleCrossPrefix, uid, roleCross)
		if err != nil {
			util.InfoF("uid=%v SetRoleCrossYuanHangLogToRedis save err=%v", uid, err)
		}
	}
}

// bt
// bt服务版本数据保存
func SetBTDataToRedis(uid uint64, msg *serverproto.SSBTDataSaveNtf) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleBTDataPrefix + uidStr
	if msg.BtBoliData != nil {
		err, msgData := model.GetEncodeMessage(msg.BtBoliData)
		if err != nil {
			return
		}
		_, err1 := service.GetRedis().HSet(keyStr, RoleBTBoliDataPrefix, msgData).Result()
		if err1 != nil {
			util.WarnF("uid=%v SetBTDataToRedis-BtBoliData fieldStr=%v err=%v", uid, RoleBTBoliDataPrefix, err1)
		}
	}
	if msg.BaseData != nil {
		err, msgData := model.GetEncodeMessage(msg.BaseData)
		if err != nil {
			return
		}
		_, err1 := service.GetRedis().HSet(keyStr, RoleBTBaseDataPrefix, msgData).Result()
		if err1 != nil {
			util.WarnF("uid=%v SetBTDataToRedis-BTBaseData fieldStr=%v err=%v", uid, RoleBTBaseDataPrefix, err1)
		}
	}
}
func GetBTDataFromRedis(uid uint64, msg *serverproto.RoleBT) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleBTDataPrefix + uidStr

	msgStr, err := service.GetRedis().HGet(keyStr, RoleBTBoliDataPrefix).Result()
	if err == nil {
		msg.BoliData = &serverproto.BTBoliData{}
		err = model.GetDecodeMessage(msg.BoliData, msgStr)
		if err != nil {
			util.ErrorF("uid=%v GetBTDataFromRedis error=%v", uid, err)
		}
	}

	msgStr, err = service.GetRedis().HGet(keyStr, RoleBTBaseDataPrefix).Result()
	if err == nil {
		msg.BaseData = &serverproto.BTBaseData{}
		err = model.GetDecodeMessage(msg.BaseData, msgStr)
		if err != nil {
			util.ErrorF("uid=%v GetBTDataFromRedis error=%v", uid, err)
		}
	}
}