RoServer/RO_Server_Trunk-branch_bt/roserver/rank/model/rank_helper.go

package model

import (
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	selfmodel "roserver/db/model"
	"roserver/serverproto"
	"strconv"
)

const ArenaTopRankMaxNum = 100

func getRankScore(val uint64, passTime uint64) uint64 {
	//score
	var scoreStr = val
	if scoreStr >= (1 << 20) {
		scoreStr = (1 << 20) - 1
	}
	scoreStr <<= 44
	if 0xfffffffffff > passTime {
		scoreStr |= 0xfffffffffff - passTime
	} else {
		scoreStr |= 0xfffffffffff - passTime/10000
	}
	return scoreStr
}
func getValByRankScore(score float64) (uint32, uint32, uint32) {
	val := uint32(uint64(score) >> 44)
	return val / 10000, val % 10000, val
}

func getIdolRankScore(val uint64, passTime uint64) uint64 {
	//score
	var scoreStr = val
	if scoreStr >= (1 << 24) {
		scoreStr = (1 << 24) - 1
	}
	scoreStr <<= 40
	if 0xffffffffff > passTime {
		scoreStr |= 0xffffffffff - passTime
	} else {
		scoreStr |= 0xffffffffff - passTime/10000
	}
	return scoreStr
}
func getIdolValByRankScore(score float64) (uint32, uint32, uint32) {
	val := uint32(uint64(score) >> 40)
	return val / 10000, val % 10000, val
}

func getArenaScore(val uint64, passTime uint64) uint64 {
	//score
	var scoreStr = val
	if scoreStr >= (1 << 28) {
		scoreStr = (1 << 28) - 1
	}
	scoreStr <<= 36
	scoreStr |= 0xfffffffff - passTime/50
	return scoreStr
}

func getValByArenaScore(score float64) (uint32, uint32, uint32) {
	val := uint32(uint64(score) >> 36)
	return val / 10000, val % 10000, val
}
func getTowerScore(val uint64, passTime uint64) uint64 {
	//score
	var scoreStr = val
	if scoreStr >= (1 << 16) {
		scoreStr = (1 << 16) - 1
	}
	scoreStr <<= 48
	if 0xfffffffffff > passTime {
		scoreStr |= 0xfffffffffff - passTime
	} else {
		scoreStr |= 0xfffffffffff - passTime/10000
	}
	return scoreStr
}
func getValByTowerScore(score float64) (uint32, uint32, uint32) {
	val := uint32(uint64(score) >> 48)
	return val / 10000, val % 10000, val
}

func getScoreTimeByArenaScore(score uint64) (uint32, uint64) {
	nowTime := util.GetTimeMilliseconds()
	tmpScore := score
	tmpScore ^= (tmpScore >> 36) << 36
	outTime := 0xfffffffff - tmpScore
	if outTime*50 > nowTime {
		outScore1 := score >> 48
		tmpScore1 := score
		tmpScore1 ^= (score >> 48) << 48
		outTime1 := 0xfffffffffff - tmpScore1

		var scoreStr = outScore1
		if scoreStr >= (1 << 28) {
			scoreStr = (1 << 28) - 1
		}
		scoreStr <<= 36
		scoreStr |= 0xfffffffff - outTime1/50
		return uint32(outScore1), scoreStr
	}
	return uint32(tmpScore >> 36), score
}

func getScoreTimeByRankScore(score uint64) (uint32, uint64) {
	nowTime := util.GetTimeMilliseconds()
	tmpScore := score
	tmpScore ^= (tmpScore >> 36) << 36
	outTime := 0xfffffffff - tmpScore
	if outTime*50 > nowTime {
		outScore1 := score >> 44
		tmpScore1 := score
		tmpScore1 ^= (score >> 44) << 44
		outTime1 := 0xfffffffffff - tmpScore1

		var scoreStr = outScore1
		if scoreStr >= (1 << 28) {
			scoreStr = (1 << 28) - 1
		}
		scoreStr <<= 36
		scoreStr |= 0xfffffffff - outTime1/50
		return uint32(outScore1), scoreStr
	}
	return uint32(tmpScore >> 36), score
}

//推图冲榜
//40位是：1 099 511 627 776 记录时间到10毫秒精度
//24为记录：16 777 216
func getRushMapScore(val uint64, passTime uint64) uint64 {
	//score
	var scoreStr = val
	if scoreStr >= (1 << 24) {
		scoreStr = (1 << 24) - 1
	}
	scoreStr <<= 40
	if 0xffffffffff > passTime {
		scoreStr |= 0xffffffffff - passTime
	} else {
		scoreStr |= 0xffffffffff - passTime/100
	}
	return scoreStr
}

func getValByRushMapScore(score float64) (uint32, uint32, uint32) {
	val := uint32(uint64(score) >> 40)
	return val / 10000, val % 10000, val
}

func AddMaxFightPowerRank(uid uint64, maxFightPower uint64) {
	if uid <= 0 {
		return
	}
	//uid
	keyStr := strconv.FormatUint(uid, 10)
	_, err := service.GetRedis().ZAdd(model.MaxFightPowerRankPrefix, service.BaseZ{Score: float64(maxFightPower), Member: keyStr}).Result()
	if err != nil {
		util.ErrorF("[AddMaxFightPowerRank] err:%v uid:%v", err, uid)
		return
	}
}

//uid -> rank
func GetMaxFightPowerRank(uid uint64) int32 {
	//uid
	keyStr := strconv.FormatUint(uid, 10)

	selfRank, err := service.GetRedis().ZRevRank(model.MaxFightPowerRankPrefix, keyStr).Result()
	if err != nil {
		util.DebugF("[GetMaxFightPowerRank] selfRank err:%v", err)
		return 0
	}
	util.DebugF("[GetMaxFightPowerRank] selfRank:%v", selfRank+1)
	return int32(selfRank + 1)
}

//rank -> uid
func GetMaxFightPowerByRank(rank int64) uint64 {
	uidStrList, err := service.GetRedis().ZRevRange(model.MaxFightPowerRankPrefix, rank-1, rank-1).Result()
	if err != nil {
		util.DebugF("[GetMaxFightPowerByRank] get uid err:%v", err)
		return 0
	}

	if len(uidStrList) > 0 {
		uid, _ := model.Str2NumU64(uidStrList[0])
		return uid
	}
	return 0
}

func SetArenaScoreRank(uid uint64, score int32, passTime uint64, oldScore, minTopScore, topRankNum int32) {
	if uid <= 0 {
		return
	}
	//score
	scoreStr := getArenaScore(uint64(score), passTime)
	//uid
	keyStr := strconv.FormatUint(uid, 10)

	_, err := service.GetRedis().ZAdd(model.ArenaRankPrefix, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	if err != nil {
		util.ErrorF("[AddArenaScoreRank] err:%v uid:%v", err, uid)
		return
	}
	_, err1 := service.GetRedis().ZAdd(model.ArenaRankMatchPrefix, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	if err1 != nil {
		util.ErrorF("[AddArenaScoreRank] matchRank err:%v uid:%v", err, uid)
		return
	}

	////判断是否需要加入top排行榜
	//if oldScore <= minTopScore {
	//	if score > minTopScore {
	//		//获得自身排行
	//		selfRank, err2 := service.GetRedis().ZRevRank(model.ArenaRankPrefix, keyStr).Result()
	//		if err2 != nil {
	//			util.DebugF("[AddArenaScoreRank] selfRank err:%v", err2)
	//			return
	//		}
	//		util.DebugF("[AddArenaScoreRank] selfRank:%v", selfRank+1)
	//
	//		if int32(selfRank) <= topRankNum {
	//			_, err := service.GetRedis().ZAdd(model.ArenaTopRankPrefix, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	//			if err != nil {
	//				util.ErrorF("[AddArenaScoreRank] add top rank err:%v uid:%v", err, uid)
	//				return
	//			}
	//		}
	//	}
	//} else {
	//	if score <= minTopScore && score != 0 {
	//		//移除top
	//		_, err := service.GetRedis().ZRem(model.ArenaTopRankPrefix, keyStr).Result()
	//		if err != nil {
	//			util.ErrorF("[AddArenaScoreRank] remove top rank err:%v uid:%v", err, uid)
	//			return
	//		}
	//	} else {
	//		//更新当前玩家的top排行
	//		_, err := service.GetRedis().ZAdd(model.ArenaTopRankPrefix, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	//		if err != nil {
	//			util.ErrorF("[AddArenaScoreRank] update top rank err:%v uid:%v", err, uid)
	//			return
	//		}
	//	}
	//}

	//更新当前玩家的top排行
	_, err = service.GetRedis().ZAdd(model.ArenaTopRankPrefix, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	if err != nil {
		util.ErrorF("[AddArenaScoreRank] update top rank err:%v uid:%v", err, uid)
		return
	}
}

func SetCompetitionScoreRank(prefixStr, keyStr string, score, competitionId int32) (int32, int32, int32, int32) {
	//特殊处理放到最后一档奖励中
	if competitionId != int32(model.CompetitionType_Idol) {
		if score <= 0 {
			prefixStr += ":sp"
		} else {
			//移除特殊排行榜中的数据
			service.GetRedis().ZRem(prefixStr+":sp", keyStr)
		}
	}

	//Score
	passTime := util.GetTimeMilliseconds()
	scoreStr := getRankScore(uint64(score), passTime)
	if competitionId == int32(model.CompetitionType_Idol) {
		scoreStr = getIdolRankScore(uint64(score), passTime)
	}
	_, err := service.GetRedis().ZAdd(prefixStr, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	if err != nil {
		util.ErrorF("SetCompetitionScoreRank err=%v uid=%v", err, keyStr)
		return 0, 0, 0, 0
	}

	tempCount, err := service.GetRedis().ZCard(prefixStr).Result()
	if err != nil {
		util.ErrorF("SetCompetitionScoreRank rankListCount err:%v", err)
		return 0, 0, 0, 0
	}
	//uid
	tempSelfRank, err2 := service.GetRedis().ZRevRank(prefixStr, keyStr).Result()
	if err2 != nil {
		util.ErrorF("SetCompetitionScoreRank selfRank err:%v %v", err2, keyStr)
		return 0, 0, 0, 0
	}

	if score <= 0 {
		return 0, 0, int32(tempCount), 0
	} else {
		convertData, ok := model.ConvertCompTypeList[competitionId]
		if !ok {
			util.ErrorF("SetCompetitionScoreRank comp data invalid err compId=%v", competitionId)
			return 0, 0, 0, 0
		}
		var nextRankScore int32 = 0
		var lastRankScore int32 = 0
		sectionId, topRank, _ := convertData.GetRankSection(tempSelfRank+1, tempCount)
		if !topRank {
			nextRankScore = getCompetitionScoreNextRank(prefixStr, tempCount, sectionId, convertData)
		} else {
			//获取第一档的第一名
			lastRankScore = getCompetitionScoreLastRank(prefixStr, tempCount, sectionId, convertData)
		}

		return nextRankScore, int32(tempSelfRank + 1), int32(tempCount), lastRankScore
	}
}

//获得下一档宝箱玩家积分对应的排名
func getCompetitionScoreNextRank(prefixStr string, totalRank int64, sectionId int32, convertData *model.CompetitionTypeData) int32 {
	for _, data := range convertData.ConditionList {
		if data.Id == sectionId-1 {
			if len(data.ConditionList) > 0 &&
				(convertData.CompetitionType == int32(model.CompetitionType_ZhaoMu) ||
					convertData.CompetitionType == int32(model.CompetitionType_XuanBa) ||
					convertData.CompetitionType == int32(model.CompetitionType_DuoBao) ||
					convertData.CompetitionType == int32(model.CompetitionType_ZhanBu)) {
				nextRankPercent := data.ConditionList[0].ValList[0]
				if totalRank < model.GlobalCompetitionSectionTotal {
					totalRank = model.GlobalCompetitionSectionTotal
				}

				nextRank := (1 - nextRankPercent/100) * float32(totalRank) / model.GlobalCompetitionSectionFactor

				rankListWithScore, err := service.GetRedis().ZRevRangeWithScores(prefixStr, int64(nextRank-1), int64(nextRank-1)).Result()
				if err != nil || len(rankListWithScore) <= 0 {
					return 0
				}
				//rankUid, _ := strconv.ParseUint(rankListWithScore[0].Member.(string), 10, 64)
				_, _, score := getValByRankScore(rankListWithScore[0].Score)
				return int32(score)
			}
			break
		}
	}
	return 0
}

//获得第二名的分数
func getCompetitionScoreLastRank(prefixStr string, totalRank int64, sectionId int32, convertData *model.CompetitionTypeData) int32 {
	for _, data := range convertData.ConditionList {
		if data.Id == sectionId+1 {
			if len(data.ConditionList) > 0 &&
				(convertData.CompetitionType == int32(model.CompetitionType_ZhaoMu) ||
					convertData.CompetitionType == int32(model.CompetitionType_XuanBa) ||
					convertData.CompetitionType == int32(model.CompetitionType_DuoBao) ||
					convertData.CompetitionType == int32(model.CompetitionType_ZhanBu)) {

				rankListWithScore2, err := service.GetRedis().ZRevRangeWithScores(prefixStr, int64(0), int64(4)).Result()
				for i := 0; i < len(rankListWithScore2); i++ {
					if err != nil || len(rankListWithScore2) <= 0 {
						return 0
					}
					_, _, score := getValByRankScore(rankListWithScore2[i].Score)
					util.InfoF("getCompetitionScoreLastRank level=%v score=%v", i, score)
				}

				//获取第二名的数据
				rankListWithScore, err := service.GetRedis().ZRevRangeWithScores(prefixStr, int64(2), int64(2)).Result()
				if err != nil || len(rankListWithScore) <= 0 {
					return 0
				}
				_, _, score := getValByRankScore(rankListWithScore[0].Score)
				util.InfoF("getCompetitionScoreLastRank third score=%v", score)
				return int32(score)
			}
			break
		}
	}
	return 0
}

type ArenaRankList struct {
	startIdx int32
	rankList []*serverproto.ArenaRankInfo
}

var arenaRankTopList = map[int32]*ArenaRankList{}
var arenaRankTopOldList = map[int32]*ArenaRankList{}

var playerBriefInfoCache = map[uint64]*BriefInfoCache{}

type BriefInfoCache struct {
	refreshTime uint64
	briefInfo   *serverproto.CommonPlayerBriefInfo
}

const BriefInfoRefreshTime uint64 = 60 * 1000

func GetArenaRankList(uid uint64, rankType, startIdx, lastSeasonId int32, ssAckMsg *serverproto.SSArenaRankListAck) int32 {
	if uid <= 0 {
		return 0
	}
	//uid
	keyStr := strconv.FormatUint(uid, 10)

	//1上赛季，0本赛季
	if rankType == 0 {
		//获取当前赛季数据
		listData := getArenaRankList(startIdx, model.ArenaTopRankPrefix, true)
		if listData != nil {
			ssAckMsg.RankList = append(listData.rankList)
		}

		//获取自身排名
		selfRank, err := service.GetRedis().ZRevRank(model.ArenaTopRankPrefix, keyStr).Result()
		if err != nil {
			util.DebugF("[GetArenaRankList] selfRank err:%v", err)
			return 0
		}
		util.DebugF("[GetArenaRankList] selfRank:%v", selfRank+1)
		//只获取自身排名
		if startIdx == 0 {
			return int32(selfRank + 1)
		}

		return int32(selfRank + 1)
	} else if rankType == 1 {
		//获取上赛季数据
		//if data, ok := arenaRankTopOldList[startIdx]; ok {
		//	*rankList = append(data.rankList)
		//	var arenaTopRewardPrefix = model.ArenaTopRankPrefix + strconv.Itoa(int(lastSeasonId))
		//	selfRank, err := service.GetRedis().ZRevRank(arenaTopRewardPrefix, keyStr).Result()
		//	if err != nil {
		//		util.DebugF("[GetArenaRankList] selfRankPre err:%v", err)
		//		return 0
		//	}
		//	return int32(selfRank + 1)
		//} else {
		//	var arenaTopRewardPrefix = model.ArenaTopRankPrefix + strconv.Itoa(int(lastSeasonId))
		//	listData := getArenaRankList(startIdx, arenaTopRewardPrefix, false)
		//	if listData != nil {
		//		*rankList = append(listData.rankList)
		//	}
		//
		//	//获取上赛季自身排名
		//	selfRank, err := service.GetRedis().ZRevRank(arenaTopRewardPrefix, keyStr).Result()
		//	if err != nil {
		//		util.DebugF("[GetArenaRankList] selfRankPre err:%v", err)
		//		return 0
		//	}
		//	util.DebugF("[GetArenaRankList] selfRankPre:%v", selfRank+1)
		//	return int32(selfRank + 1)
		//}

		var arenaTopRewardPrefix = model.ArenaTopRankPrefix + strconv.Itoa(int(lastSeasonId))
		listData := getArenaRankList(startIdx, arenaTopRewardPrefix, false)
		if listData != nil {
			ssAckMsg.RankList = append(listData.rankList)
		}

		//获取上赛季自身排名对应的积分
		selfRank, err := service.GetRedis().ZRevRank(arenaTopRewardPrefix, keyStr).Result()
		if err != nil {
			util.DebugF("[GetArenaRankList] selfRankPre err:%v", err)
			return 0
		}
		bFind := false
		for idx := 0; idx < len(listData.rankList); idx++ {
			if listData.rankList[idx].Rank == int32(selfRank)+1 {
				bFind = true
				ssAckMsg.SelfRankScore = listData.rankList[idx].Score
				break
			}
		}
		if !bFind {
			selfRankInfo := getArenaRankInfoByRank(arenaTopRewardPrefix, selfRank)
			if selfRankInfo != nil {
				ssAckMsg.SelfRankScore = selfRankInfo.Score
			}
		}

		util.DebugF("[GetArenaRankList] selfRankPre:%v", selfRank+1)
		return int32(selfRank + 1)

		////获取上赛季自身排名
		//selfRank,err := service.GetRedis().ZRevRank(model2.ArenaPreRankPrefix, keyStr).Result()
		//if err != nil {
		//	util.DebugF("[GetArenaRankList] selfRankPre err:%v", err)
		//	return 0
		//}
		//util.DebugF("[GetArenaRankList] selfRankPre:%v", selfRank + 1)
		//return int32(selfRank+1)
	}

	return 0
}

//获取对应排名的玩家信息
func getArenaRankInfoByRank(topRankPrefix string, rankIdx int64) *serverproto.ArenaRankInfo {
	topListWithScore, err := service.GetRedis().ZRevRangeWithScores(topRankPrefix, rankIdx, rankIdx).Result()
	if err == nil {
		for idx := range topListWithScore {
			rankUid, _ := strconv.ParseUint(topListWithScore[idx].Member.(string), 10, 64)
			_, _, score := getValByArenaScore(topListWithScore[idx].Score)
			rankInfo := &serverproto.ArenaRankInfo{
				Rank:  int32(rankIdx + 1),
				Score: int32(score),
			}

			nowTime := util.GetTimeMilliseconds()
			bf, ok := playerBriefInfoCache[rankUid]
			if !ok {
				bf = &BriefInfoCache{
					refreshTime: 0,
					briefInfo:   &serverproto.CommonPlayerBriefInfo{},
				}
			}
			if bf.refreshTime+BriefInfoRefreshTime < nowTime {
				bf.refreshTime = nowTime
				//获取top rank player nickName
				selfmodel.GetSystemDataFromRedis(selfmodel.RolePlayerBriefPrefix, rankUid, bf.briefInfo)
			}
			rankInfo.BriefInfo = bf.briefInfo
			playerBriefInfoCache[rankUid] = bf
			return rankInfo
		}
	}
	return nil
}

func getArenaRankList(startIdx int32, topRankPrefix string, isNow bool) *ArenaRankList {
	rankListCount, err1 := service.GetRedis().ZCard(topRankPrefix).Result()
	if err1 != nil {
		util.DebugF("[getArenaRankList] totalRanks err:%v", err1)
	}

	if rankListCount > 0 {
		//获取top排行
		begin := int64(startIdx*10 - 10)
		end := int64(startIdx*10 - 1)

		topListWithScore, err2 := service.GetRedis().ZRevRangeWithScores(topRankPrefix, begin, end).Result()
		if err2 == nil {
			//var arenaRankList *ArenaRankList = nil
			//if isNow {
			//	//当前赛季
			//	tempList, ok := arenaRankTopList[startIdx]
			//	if !ok {
			//		arenaRankList = &ArenaRankList{}
			//		arenaRankTopList[startIdx] = arenaRankList
			//	} else {
			//		arenaRankList = tempList
			//		arenaRankList.rankList = arenaRankList.rankList[:0]
			//	}
			//} else {
			//	//上个赛季
			//	tempList, ok := arenaRankTopOldList[startIdx]
			//	if !ok {
			//		arenaRankList = &ArenaRankList{}
			//		arenaRankTopOldList[startIdx] = arenaRankList
			//	} else {
			//		arenaRankList = tempList
			//		return arenaRankList
			//	}
			//}

			arenaRankList := &ArenaRankList{}
			for idx := range topListWithScore {
				rankUid, _ := strconv.ParseUint(topListWithScore[idx].Member.(string), 10, 64)
				_, _, score := getValByArenaScore(topListWithScore[idx].Score)
				rankInfo := &serverproto.ArenaRankInfo{
					Rank:  int32(idx+1) + int32(begin),
					Score: int32(score),
				}

				nowTime := util.GetTimeMilliseconds()
				bf, ok := playerBriefInfoCache[rankUid]
				if !ok {
					bf = &BriefInfoCache{
						refreshTime: 0,
						briefInfo:   &serverproto.CommonPlayerBriefInfo{},
					}
				}
				if bf.refreshTime+BriefInfoRefreshTime < nowTime {
					bf.refreshTime = nowTime
					//获取top rank player nickName
					selfmodel.GetSystemDataFromRedis(selfmodel.RolePlayerBriefPrefix, rankUid, bf.briefInfo)
				}
				rankInfo.BriefInfo = bf.briefInfo
				playerBriefInfoCache[rankUid] = bf

				arenaRankList.rankList = append(arenaRankList.rankList, rankInfo)
			}
			return arenaRankList
		}
	}

	return nil
}

func GetArenaRankReward(uid uint64, score int32, seasonId int32) (int32, int32) {
	var arenaRewardPrefix = model.ArenaTopRankPrefix
	rewardSeasonId := seasonId + 1
	arenaRewardPrefix += strconv.Itoa(int(rewardSeasonId))

	//uid
	keyStr := strconv.FormatUint(uid, 10)
	//获取自身排名
	selfRank, err := service.GetRedis().ZRevRank(arenaRewardPrefix, keyStr).Result()
	if err != nil {
		util.DebugF("[GetArenaRankReward][%v] selfRank err:%v %v", uid, err, arenaRewardPrefix)
		return 0, 0
	}
	util.DebugF("[GetArenaRankReward][%v] selfRank:%v %v", uid, selfRank+1, arenaRewardPrefix)

	return int32(selfRank + 1), rewardSeasonId
}

var arenaTopRankReward = map[uint64]int{}

//赛季结算，并生成赛季排行数据
func UpdateArenaRank(lastSeasonId int32, rewardPlayerList *[]uint64, outList *[]*serverproto.KeyValueType64) serverproto.ErrorCode {
	rankReward := model.ArenaTopRankPrefix + strconv.Itoa(int(lastSeasonId))

	//判断记录数据是否存在
	if !model.ExistKey(rankReward) {
		//_,err := service.GetRedis().Rename(model2.ArenaTopRankPrefix, rankReward).Result()
		_, err := service.GetRedis().ZUnionStore(rankReward, service.BaseStore{}, model.ArenaTopRankPrefix).Result()
		if err != nil {
			util.ErrorF("[UpdateArenaRank] store rank record err1:%v %v", err, rankReward)
			return serverproto.ErrorCode_ERROR_FAIL
		}

		//_, err1 := service.GetRedis().Rename(model.ArenaRankPrefix, model.ArenaPreRankPrefix).Result()
		_, err1 := service.GetRedis().ZUnionStore(model.ArenaPreRankPrefix, service.BaseStore{}, model.ArenaRankPrefix).Result()
		if err1 != nil {
			util.ErrorF("[UpdateArenaRank] store rank record err1:%v %v", err, model.ArenaPreRankPrefix)
			return serverproto.ErrorCode_ERROR_FAIL
		}
		//清空当前榜单数据
		service.GetRedis().Del(model.ArenaTopRankPrefix)
		service.GetRedis().Del(model.ArenaRankPrefix)
	}

	if len(arenaTopRankReward) <= 0 {
		//获得前100排行玩家数据
		for idx := 0; idx < 5; idx++ {
			startIdx := int64(idx * 20)
			rankNumList, err2 := service.GetRedis().ZRevRange(rankReward, startIdx, startIdx+19).Result()
			if err2 != nil {
				break
			}
			if len(rankNumList) <= 0 {
				break
			}
			for i := 0; i < len(rankNumList); i++ {
				rankUid, _ := model.Str2NumU64(rankNumList[i])
				arenaTopRankReward[rankUid] = int(startIdx) + i + 1
			}
		}
	}

	for i := 0; i < len(*rewardPlayerList); i++ {
		uid := (*rewardPlayerList)[i]
		*outList = append(*outList, &serverproto.KeyValueType64{
			Key:   uid,
			Value: int32(arenaTopRankReward[uid]),
		})
	}

	return serverproto.ErrorCode_ERROR_OK
}

///competition
//赛季结算时保存地图推进排名列表，并返回在线玩家奖励排名信息
func RecordCompMapRankByCompId(competitionId, competitionIdSubId int32, uidList []*serverproto.KeyValueType64, rewardUidList *[]*serverproto.KeyValueType64) (bool, int32) {
	convertData, ok := model.ConvertCompTypeList[competitionId]
	if !ok {
		util.ErrorF("RecordCompArenaRankByCompId comp data invalid err=%v", competitionId)
		return false, 0
	}

	//competitionId
	compIdStr := strconv.Itoa(int(competitionId*100 + competitionIdSubId))
	prefixStr := model.CompetitionMapRankPrefix + compIdStr

	if !model.ExistKey(prefixStr) {
		_, err := service.GetRedis().ZUnionStore(prefixStr, service.BaseStore{}, model.MapRankPrefix).Result()
		if err != nil {
			util.ErrorF("RecordCompMapRankByCompId store rank record err=%v prefixStr=%v", err, prefixStr)
			return false, 0
		}
	}

	//当前服务器没有在线玩家，不做奖励处理
	if uidList == nil || len(uidList) <= 0 {
		return true, 0
	}
	rankListCount, err := service.GetRedis().ZCard(prefixStr).Result()
	if err != nil {
		util.ErrorF("RecordCompMapRankByCompId totalRanks err=%v", err)
		return false, 0
	}
	for _, data := range uidList {
		//uid
		keyStr := strconv.FormatUint(data.Key, 10)
		selfRank, err2 := service.GetRedis().ZRevRank(prefixStr, keyStr).Result()
		if err2 != nil {
			util.ErrorF("RecordCompMapRankByCompId selfRank err=%v key=%v", err2, data.Key)
			continue
		}
		//util.DebugF("[GetMapRank] selfRank:%v", selfRank + 1)

		//获取宝箱档位
		_, _, sectionId := convertData.GetRankSection(selfRank+1, rankListCount)
		if sectionId <= 0 {
			util.ErrorF("RecordCompMapRankByCompId sectionId err=%v key=%v", err2, data.Key)
			continue
		}
		*rewardUidList = append(*rewardUidList, &serverproto.KeyValueType64{
			Key:   data.Key,
			Value: sectionId,
		})
	}

	return true, int32(rankListCount)
}

//赛季结算时根据当前赛季累计积分获取排行，并返回在线玩家奖励排名信息
func RecordCompScoreRankByCompId(prefixKeyStr string, competitionId, competitionIdSubId int32, endCompId bool, uidList []*serverproto.KeyValueType64, rewardUidList *[]*serverproto.KeyValueType64) (bool, int32) {
	convertData, ok := model.ConvertCompTypeList[competitionId]
	if !ok {
		util.ErrorF("RecordCompScoreRankByCompId comp data invalid err=%v prefixKeyStr=%v", competitionId, prefixKeyStr)
		return false, 0
	}

	//competitionId
	compIdStr := strconv.Itoa(int(competitionId*100 + competitionIdSubId))
	prefixStr := prefixKeyStr + compIdStr
	if endCompId {
		if !model.ExistKey(prefixStr) {
			//_, err := service.GetRedis().Rename(model.CompetitionScoreRankPrefix, prefixStr).Result()
			_, err := service.GetRedis().Rename(prefixKeyStr, prefixStr).Result()

			//special
			//specialPrefixStr := model.CompetitionScoreRankPrefix + ":sp"
			specialPrefixStr := prefixKeyStr + ":sp"
			_, err1 := service.GetRedis().Rename(specialPrefixStr, specialPrefixStr+compIdStr).Result()

			if err1 != nil && err != nil {
				util.ErrorF("RecordCompScoreRankByCompId store rank record err=%v prefixStr=%v", err1, specialPrefixStr)
				return false, 0
			}
		}
	} else {
		if !model.ExistKey(prefixStr) {
			//_, err := service.GetRedis().ZUnionStore(prefixStr, service.BaseStore{}, model.CompetitionScoreRankPrefix).Result()
			_, err := service.GetRedis().ZUnionStore(prefixStr, service.BaseStore{}, prefixKeyStr).Result()
			if err != nil {
				util.ErrorF("RecordCompScoreRankByCompId store rank record err=%v prefixStr=%v", err, prefixStr)
				return false, 0
			}
			//special
			//specialPrefixStr := model.CompetitionScoreRankPrefix + ":sp"
			specialPrefixStr := prefixKeyStr + ":sp"
			_, err1 := service.GetRedis().ZUnionStore(specialPrefixStr+compIdStr, service.BaseStore{}, specialPrefixStr).Result()
			if err1 != nil {
				util.ErrorF("RecordCompScoreRankByCompId store rank record err=%v prefixStr=%v", err1, specialPrefixStr)
				return false, 0
			}
		}
	}

	//当前服务器没有在线玩家，不做奖励处理
	if uidList == nil || len(uidList) <= 0 {
		return true, 0
	}

	rankListCount, err := service.GetRedis().ZCard(prefixStr).Result()
	if err != nil {
		util.ErrorF("RecordCompScoreRankByCompId totalRanks err=%v", err)
		return false, 0
	}
	for _, data := range uidList {
		//uid
		keyStr := strconv.FormatUint(data.Key, 10)
		//特殊队列中查找是否存在该玩家,存在数据说明直接属于最后一档
		//spStr := model.CompetitionScoreRankPrefix + ":sp" + compIdStr
		spStr := prefixKeyStr + ":sp" + compIdStr
		selfRank, err2 := service.GetRedis().ZRevRank(spStr, keyStr).Result()
		if err2 == nil && err2 != service.NIL {
			*rewardUidList = append(*rewardUidList, &serverproto.KeyValueType64{
				Key:   data.Key,
				Value: convertData.LastConditionId,
			})
			continue
		}

		selfRank, err2 = service.GetRedis().ZRevRank(prefixStr, keyStr).Result()
		if err2 != nil {
			continue
		}

		//获取宝箱档位
		_, _, sectionId := convertData.GetRankSection(selfRank+1, rankListCount)
		if sectionId <= 0 {
			util.ErrorF("RecordCompScoreRankByCompId sectionId err=%v key=%v", err2, data.Key)
			continue
		}
		*rewardUidList = append(*rewardUidList, &serverproto.KeyValueType64{
			Key:   data.Key,
			Value: sectionId,
		})
	}
	return true, int32(rankListCount)
}

func GetActivitiesCollectionData(activityId, rewardIdx, serverLimitNum int32, ackMsg *serverproto.SSActivitiesCollectionServerDataAck) bool {
	keyStr := strconv.Itoa(int(activityId))
	saveData := &serverproto.CollectionSaveData{}
	err := model.GetMessageFromRedis(model.ActivitiesCollectionDataPrefix, keyStr, saveData)
	if err != nil && err != service.NIL {
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
		util.ErrorF("GetActivitiesCollectionData key=%v err=%v", model.ActivitiesCollectionDataPrefix, err)
		return true
	}

	if rewardIdx > 0 {
		//清空全局数据
		if serverLimitNum <= 0 {
			bFind := false
			for idx := 0; idx < len(saveData.DataList); idx++ {
				if saveData.DataList[idx].Key == rewardIdx {
					saveData.DataList[idx].Value = 0
					bFind = true
					break
				}
			}
			if bFind {
				err = model.SetMessageToRedis(model.ActivitiesCollectionDataPrefix, keyStr, saveData)
				if err != nil {
					util.ErrorF("GetActivitiesCollectionData key=%v err=%v", model.ActivitiesCollectionDataPrefix, err)
				}
			}
			return false
		}

		saveData.ActivityId = activityId
		var itemData *serverproto.KeyValueType = nil
		for idx := 0; idx < len(saveData.DataList); idx++ {
			if saveData.DataList[idx].Key == rewardIdx {
				itemData = saveData.DataList[idx]
				break
			}
		}

		//增加次数并获得奖励
		if itemData != nil {
			if itemData.Value >= serverLimitNum {
				ackMsg.Error = int32(serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_NUM_LIMIT)
				return true
			}
			itemData.Value++
		} else {
			itemData = &serverproto.KeyValueType{Key: rewardIdx, Value: 1}
			saveData.DataList = append(saveData.DataList, itemData)
		}

		err = model.SetMessageToRedis(model.ActivitiesCollectionDataPrefix, keyStr, saveData)
		if err != nil {
			util.ErrorF("GetActivitiesCollectionData key=%v err=%v", model.ActivitiesCollectionDataPrefix, err)
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
			return true
		}
		ackMsg.ActivityId = activityId
		ackMsg.DataList = append(ackMsg.DataList, itemData)
	} else {
		ackMsg.ActivityId = activityId
		if len(saveData.DataList) > 0 {
			ackMsg.DataList = append(ackMsg.DataList, saveData.DataList...)
		}
	}
	return true
}

func UpdateExpeditionScoreRank(score uint32, uid uint64) {
	if uid <= 0 {
		return
	}
	passTime := util.GetTimeMilliseconds()
	//score
	scoreStr := model.GetRankScoreCommon(uint64(score), passTime)
	//scoreStr := getRankScore(uint64(score), passTime)
	//uid
	keyStr := strconv.FormatUint(uid, 10)

	_, err := service.GetRedis().ZAdd(model.ExpeditionScoreRankPrefix, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	if err != nil {
		util.ErrorF("UpdateExpeditionScoreRank err=%v uid=%v", err, uid)
		return
	}
}

func ExpeditionScoreRank(startIdx int32, ackMsg *serverproto.SSExpeditionScoreRankListAck, selfUid uint64) {
	if startIdx <= 0 {
		startIdx = 1
	}
	//获取top排行
	begin := int64(startIdx - 1)
	end := int64(begin + 19)

	////获取top排行
	//begin := int64(startIdx*10 - 10)
	//end := int64(startIdx*10 - 1)
	rankListWithScore, err := service.GetRedis().ZRevRangeWithScores(model.ExpeditionScoreRankPrefix, begin, end).Result()
	if err != nil {
		return
	}

	//rank list
	for idx := 0; idx < len(rankListWithScore); idx++ {
		rankUid, err := strconv.ParseUint(rankListWithScore[idx].Member.(string), 10, 64)
		if err != nil {
			continue
		}
		//getScoreTimeByRankScore(rankListWithScore[idx].Score)
		score := model.GetValByRankScoreCommon(rankListWithScore[idx].Score)
		rankInfo := &serverproto.ExpeditionRankInfo{
			Rank:  int32(idx+1) + int32(begin),
			Score: uint32(score),
		}
		nowTime := util.GetTimeMilliseconds()
		bf, ok := playerBriefInfoCache[rankUid]
		if !ok {
			bf = &BriefInfoCache{
				refreshTime: 0,
				briefInfo:   &serverproto.CommonPlayerBriefInfo{},
			}
		}
		if bf.refreshTime+BriefInfoRefreshTime < nowTime {
			bf.refreshTime = nowTime
			//获取top rank player nickName
			err = selfmodel.GetSystemDataFromRedis(selfmodel.RolePlayerBriefPrefix, rankUid, bf.briefInfo)
		}
		rankInfo.BriefInfo = bf.briefInfo
		playerBriefInfoCache[rankUid] = bf

		ackMsg.RankList = append(ackMsg.RankList, rankInfo)

		if rankUid == selfUid {
			ackMsg.SelfRankInfo = rankInfo
		}
	}

	//self rank
	if ackMsg.SelfRankInfo == nil {
		//uid
		keyStr := strconv.FormatUint(selfUid, 10)
		selfRank, err := service.GetRedis().ZRevRank(model.ExpeditionScoreRankPrefix, keyStr).Result()
		if err == nil && err != service.NIL {
			ackMsg.SelfRankInfo = &serverproto.ExpeditionRankInfo{
				Rank: int32(selfRank + 1),
			}
		}
	}
}