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

package model

import (
	"encoding/base64"
	"github.com/go-redis/redis"
	"rocommon"
	"rocommon/service"
	"rocommon/util"
	model2 "roserver/baseserver/model"
	"roserver/db/model"
	"roserver/serverproto"
	"strconv"
	"time"
)

//排名前3玩家uid列表
const (
	MAPRANK_TOP_3 = 3

	MAPSCORE_TOP_3000 = 3000
)

const (
	Rush_Map_Rank_Rush   = 1 //冲榜阶段
	Rush_Map_Rank_Reward = 2 //领奖阶段
	Rush_Map_Rank_End    = 3 //结束
)

var MapRankTopThree []*serverproto.RankPlayerInfo

//zSet rank
//https://www.jianshu.com/p/2cbf358b933b
//https://www.jianshu.com/p/2cbf358b933b
func AddMapRank(uid uint64, newMapLevel uint32, passTime uint64, recordInfo *serverproto.BattleRecordInfo) (uint32, uint32, uint64) {
	if uid <= 0 {
		return 0, 0, 0
	}

	//score
	scoreStr := getRankScore(uint64(newMapLevel), passTime)
	//uid
	keyStr := strconv.FormatUint(uid, 10)

	//todo... 通过多命令方式处理
	_, err := service.GetRedis().ZAdd(model2.MapRankPrefix, redis.Z{Score: float64(scoreStr), Member: keyStr}).Result()
	if err != nil {
		util.ErrorF("AddMapRank err=%v uid=%v", err, uid)
		return 0, 0, 0
	}

	//util.InfoF("[AddMapRank] ret:%v %v %v", ret, scoreStr, keyStr)
	//retRank,err1 := service.GetRedis().ZRevRange(MapRankPrefix, 0, -1).Result()
	//if err1 == nil {
	//	util.DebugF("[AddMapRank] rankList:%v", retRank)
	//}

	selfRank, err2 := service.GetRedis().ZRevRank(model2.MapRankPrefix, keyStr).Result()
	if err2 != nil {
		util.DebugF("AddMapRank selfRank err=%v uid=%v", err2, uid)
		return 0, 0, 0
	}
	util.DebugF("AddMapRank selfRank=%v uid=%v score=%v", selfRank+1, uid, scoreStr)

	rankList, err3 := service.GetRedis().ZCard(model2.MapRankPrefix).Result()
	if err3 != nil {
		util.DebugF("AddMapRank totalRanks err=%v uid=%v", err2, uid)
		return 0, 0, 0
	}
	util.DebugF("AddMapRank totalRanks=%v uid=%v", rankList, uid)

	//记录战斗回复记录数据(不包括战斗过程记录)
	recordId := battleRecord(uid, int32(selfRank), recordInfo)
	if recordId > 0 {
		service.GetRedis().SAdd(model2.BattleRecordDetailCheckPrefix, recordId)
	}

	//如果自己在前3名内，重新获取排名前3的玩家列表
	if selfRank < MAPRANK_TOP_3 {
		getTop3MapRank()
	}

	return uint32(selfRank), uint32(rankList), recordId
}

func GetMapRank(uid uint64) (uint32, uint32) {
	//获取排名前3的玩家列表
	//if len(MapRankTopThree) <= 0 {
	//	getTop3MapRank()
	//}
	//暂时处理成每次重新获取，因为简介信息可能发生变化
	getTop3MapRank()

	//uid
	keyStr := strconv.FormatUint(uid, 10)

	selfRank, err2 := service.GetRedis().ZRevRank(model2.MapRankPrefix, keyStr).Result()
	if err2 != nil {
		util.DebugF("uid=%v GetMapRank selfRank keystr=%v err=%v", uid, model2.MapRankPrefix, err2)
		return 0, 0
	}
	util.DebugF("uid=%v GetMapRank keystr=%v selfRank=%v", uid, model2.MapRankPrefix, selfRank+1)

	rankList, err3 := service.GetRedis().ZCard(model2.MapRankPrefix).Result()
	if err3 != nil {
		util.DebugF("uid=%v GetMapRank keystr=%v totalRanks err=%v", uid, model2.MapRankPrefix, err2)
		return 0, 0
	}
	util.DebugF("uid=%v GetMapRank keystr=%v totalRanks=%v", uid, model2.MapRankPrefix, rankList)

	return uint32(selfRank), uint32(rankList)
}

func GetRankByKeyUid(KeyStr string, uid uint64, compId int32) (uint32, uint32, uint32) {
	//uid
	uidStr := strconv.FormatUint(uid, 10)

	selfRank, err2 := service.GetRedis().ZRevRank(KeyStr, uidStr).Result()
	if err2 != nil {
		//util.DebugF("GetMapRank selfRank uid=%v keystr=%v err=%v", KeyStr, uid, err2)
		return 0, 0, 0
	}
	util.DebugF("GetMapRank uid=%v keystr=%v selfRank:%v", KeyStr, uid, selfRank+1)

	rankList, err3 := service.GetRedis().ZCard(KeyStr).Result()
	if err3 != nil {
		//util.DebugF("GetMapRank uid=%v keystr=%v totalRanks err:%v", KeyStr, uid, err2)
		return 0, 0, 0
	}
	util.DebugF("GetMapRank uid=%v keystr=%v totalRanks:%v", KeyStr, uid, rankList)

	selfScore := uint32(0)
	selfRank, rankErr := service.GetRedis().ZRevRank(KeyStr, uidStr).Result()
	if rankErr == nil && rankErr != service.NIL {
		topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(KeyStr, selfRank, selfRank).Result()
		if err3 == nil {
			for index, _ := range topListWithScore {
				rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)
				if rankUid == uid {
					if compId != int32(model2.CompetitionType_Idol) {
						_, _, oldScore := getValByRankScore(topListWithScore[index].Score)
						selfScore = uint32(oldScore)
					} else {
						_, _, oldScore := getIdolValByRankScore(topListWithScore[index].Score)
						selfScore = uint32(oldScore)
					}
				}
			}
		} else {
			util.DebugF("[GetIdolTotalScore] selfRank err:%v", err3)
		}
	}

	return uint32(selfRank), uint32(rankList), selfScore
}

func GetBattleRecordMap(ackMsg *serverproto.SCPlayerBattleRecordAck, paramList []uint32) {
	if len(paramList) < 2 {
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
		return
	}
	nowTime := util.GetTimeMilliseconds()
	//最近通关
	mapId := paramList[0]
	mapLevel := paramList[1]
	passMapLevel := strconv.Itoa(int(mapId*10000+mapLevel)) + "_pass"
	recordInfoStr, err := service.GetRedis().HGet(model2.BattleRecordMapPrefix, passMapLevel).Result()
	if err == nil {

		recordInfo := &serverproto.BattleRecordInfo{}
		err = model2.GetDecodeMessage(recordInfo, recordInfoStr)
		if err == nil {
			//判断战斗记录是否存在(有可能还没上传，有一定延迟)
			battleKeyStr := model2.BattleRecordDetailPrefix + strconv.FormatUint(recordInfo.BattleRecordId, 10)
			if service.GetRedis().Exists(battleKeyStr).Val() > 0 {
				recordInfo.RecordIdx = 1
				ackMsg.RecordList = append(ackMsg.RecordList, recordInfo)
			} else {
				if recordInfo.RecordTime+10*60 >= nowTime {
					recordInfo.RecordIdx = 1
					ackMsg.RecordList = append(ackMsg.RecordList, recordInfo)
				} else {
					//不存在战斗相信记录，删除通关记录
					service.GetRedis().HDel(model2.BattleRecordMapPrefix, passMapLevel)
				}
			}
		}
	}

	//最低战斗力通关
	passMapMinFPower := strconv.Itoa(int(mapId*10000+mapLevel)) + "_power" //brecord:map:10001_power
	recordInfoStr, err = service.GetRedis().HGet(model2.BattleRecordMapPrefix, passMapMinFPower).Result()
	if err == nil {
		recordInfo := &serverproto.BattleRecordInfo{}
		err = model2.GetDecodeMessage(recordInfo, recordInfoStr)
		if err == nil {
			//判断战斗记录是否存在(有可能还没上传，有一定延迟)
			battleKeyStr := model2.BattleRecordDetailPrefix + strconv.FormatUint(recordInfo.BattleRecordId, 10)
			if service.GetRedis().Exists(battleKeyStr).Val() > 0 {
				recordInfo.RecordIdx = 2
				ackMsg.RecordList = append(ackMsg.RecordList, recordInfo)
			} else {
				if recordInfo.RecordTime+10*60 >= nowTime {
					recordInfo.RecordIdx = 2
					ackMsg.RecordList = append(ackMsg.RecordList, recordInfo)
				} else {
					//不存在战斗相信记录，删除通关记录
					service.GetRedis().HDel(model2.BattleRecordMapPrefix, passMapMinFPower)
				}
			}
		}
	}
}

func getTop3MapRank() {
	//topList,err4 := service.GetRedis().ZRevRange(MapRankPrefix, 0, MAPRANK_TOP_3 -1).Result()
	topListWithScore, err4 := service.GetRedis().ZRevRangeWithScores(model2.MapRankPrefix, 0, MAPRANK_TOP_3-1).Result()
	if err4 == nil {
		MapRankTopThree = MapRankTopThree[:0]
		for index, _ := range topListWithScore {
			rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)
			mapId, mapLevel, _ := getValByRankScore(topListWithScore[index].Score)
			topRankPlayer := &serverproto.RankPlayerInfo{
				Uid:      rankUid,
				MapId:    mapId,
				MapLevel: mapLevel,
				Brief:    &serverproto.CommonPlayerBriefInfo{},
			}

			//获取top rank player nickName
			model.GetSystemDataFromRedis(model.RolePlayerBriefPrefix, rankUid, topRankPlayer.Brief)
			MapRankTopThree = append(MapRankTopThree, topRankPlayer)
		}
	}
}

func battleRecord(uid uint64, selfRank int32, recordInfo *serverproto.BattleRecordInfo) uint64 {
	var retId uint64 = 0
	if recordInfo.RecordTime <= 0 {
		return retId
	}

	err, recordInfoStr := model2.GetEncodeMessage(recordInfo)
	if err != nil {
		return retId
	}

	//最近通关
	var oldRecordId uint64 = 0
	passMapLevel := strconv.Itoa(int(recordInfo.MapLevelId)) + "_pass" //brecord:map:10001_pass
	oldPassStr, err1 := service.GetRedis().HGet(model2.BattleRecordMapPrefix, passMapLevel).Result()
	if err1 == nil {
		oldPassRecordInfo := &serverproto.BattleRecordInfo{}
		err1 = model2.GetDecodeMessage(oldPassRecordInfo, oldPassStr)
		if err1 == nil && oldPassRecordInfo.BattleRecordId > 0 {
			oldRecordId = oldPassRecordInfo.BattleRecordId
		}
	}
	_, err = service.GetRedis().HSet(model2.BattleRecordMapPrefix, passMapLevel, recordInfoStr).Result()
	if err != nil {
		util.DebugF("AddMapRank set pass map record failed[map pass] uid=%v", uid)
	} else {
		retId = recordInfo.BattleRecordId
		//设置之前的战斗记录过期时间，过期时间为10分钟
		oldRecordIdStr := strconv.FormatUint(oldRecordId, 10)
		service.GetRedis().Expire(model2.BattleRecordDetailPrefix+oldRecordIdStr, time.Minute*1)
	}

	//min fight power pass map
	passMapMinFPower := strconv.Itoa(int(recordInfo.MapLevelId)) + "_power" //brecord:map:10001_power
	oldRecordInfoStr, err1 := service.GetRedis().HGet(model2.BattleRecordMapPrefix, passMapMinFPower).Result()
	if err1 != nil && err1 != service.NIL {
		return retId
	}
	oldRecordInfo := &serverproto.BattleRecordInfo{}
	err = model2.GetDecodeMessage(oldRecordInfo, oldRecordInfoStr)
	if err != nil {
		return retId
	}

	if recordInfo.BattleVersion > oldRecordInfo.BattleVersion || oldRecordInfo.FightPower == 0 ||
		(recordInfo.BattleVersion == oldRecordInfo.BattleVersion && oldRecordInfo.FightPower > recordInfo.FightPower) {
		_, err := service.GetRedis().HSet(model2.BattleRecordMapPrefix, passMapMinFPower, recordInfoStr).Result()
		if err != nil {
			util.DebugF("AddMapRank set pass map record failed[min fight power] uid=%v", uid)
			return retId
		}
		if oldRecordInfo.BattleRecordId > 0 {
			oldRecordId = oldRecordInfo.BattleRecordId
			//设置之前的战斗记录过期时间，过期时间为10分钟
			oldRecordIdStr := strconv.FormatUint(oldRecordId, 10)
			service.GetRedis().Expire(model2.BattleRecordDetailPrefix+oldRecordIdStr, time.Minute*10)
		}
		retId = recordInfo.BattleRecordId

		//util.InfoF("AddMapRank battleRecord ")
	}

	return retId
}

//=================================     推图冲榜    ===========================================
//=================================     推图冲榜    ===========================================

type MapScoreManger struct {
	TickTime uint64
	//冲榜数据
	RushId       int32            //冲榜序号（第几次冲榜）
	RushStage    int32            //冲榜阶段
	RewardList   map[uint64]int32 //自己领奖则不再邮件发送
	RoundData    []*serverproto.RushRoundData
	initRushTime bool
}

func newMapScoreManger() *MapScoreManger {
	mag := &MapScoreManger{}
	mag.TickTime = 0
	mag.RushId = 0
	mag.RushStage = 0
	mag.RewardList = make(map[uint64]int32)
	mag.initRushTime = false
	return mag
}

//1秒刷新
func (this *MapScoreManger) Update(ms uint64) {
	if service.GetRedis() == nil {
		return
	}

	if this.TickTime == 0 {
		err1 := this.loadRushMapDataFromRedis()
		if err1 != nil && err1 != service.NIL {
			util.ErrorF("[MapScoreManger] loadRushMapDataFromRedis err:%v", err1)
			return
		}
		this.TickTime = ms
		util.InfoF("[MapScoreManger] init success")

		//上线加载崇拜活动数据
		return
	}

	if this.TickTime != 0 && this.initRushTime == false {
		startUpTime := service.GetServiceStartupTime()
		if startUpTime > 0 {
			this.CheckAddInitRoundData()
			this.initRushTime = true
		}
	}

	//5秒中刷新
	if this.TickTime != 0 && this.TickTime+RefreshTime < ms {
		//写数据库
		this.SwitchRushActivityState()

		this.TickTime = ms
		return
	}
}

//全服爬塔排名逻辑
func (this *MapScoreManger) AddMapScoreRank(uid uint64, score uint32) uint32 {
	//不在冲榜阶段
	if this.RushStage != Rush_Map_Rank_Rush {
		return 0
	}
	//精确到10毫秒
	curTime := util.GetCurrentTime() / 10
	//score
	scoreStr := getRushMapScore(uint64(score), uint64(curTime))
	//uid
	keyStr := strconv.FormatUint(uid, 10)

	_, err := service.GetRedis().ZAdd(model2.RushMapScorePrefix, service.BaseZ{Score: float64(scoreStr), Member: keyStr}).Result()
	if err != nil {
		util.ErrorF("[AddMapScoreRank] err:%v uid:%v", err, uid)
		return 0
	}

	selfRank, err2 := service.GetRedis().ZRevRank(model2.RushMapScorePrefix, keyStr).Result()
	if err2 != nil {
		util.DebugF("[AddMapScoreRank] selfRank err:%v", err2)
		return 0
	}
	util.DebugF("[AddMapScoreRank] selfRank:%v", selfRank+1)

	//超过1000人的情况
	rankListCount, err1 := service.GetRedis().ZCard(model2.RushMapScorePrefix).Result()
	if err1 != nil {
		util.DebugF("[AddMapScoreRank] totalRanks err:%v", err1)
		return uint32(selfRank)
	}
	if rankListCount > MAPSCORE_TOP_3000 {
		count := rankListCount - MAPSCORE_TOP_3000
		for i := 0; i < int(count); i++ {
			_, err := service.GetRedis().ZRemRangeByRank(model2.RushMapScorePrefix, 0, 0).Result()
			if err != nil {
				util.ErrorF("[AddMapScoreRank] remove top rank err:%v uid:%v", err)
				break
			}
		}
	}
	return uint32(selfRank + 1)
}

//加载赛季数据
func (this *MapScoreManger) loadRushMapDataFromRedis() error {
	keyStr := model2.RushMapPrefix
	ret, err := service.GetRedis().Get(keyStr).Result()
	if err != nil {
		util.InfoF("loadRushMap get guildId key=%v err=%v\n", keyStr, err)
		return err
	}
	if ret == "" {
		util.InfoF("key(%v)->val empty", keyStr)
		return err
	}

	str, err := base64.StdEncoding.DecodeString(ret)
	if err != nil {
		util.InfoF("key(%v)->val DecodeString error", keyStr)
		return err
	}
	rushData := &serverproto.RushData{}
	err = rocommon.GetCodec().Unmarshal(str, rushData)
	if err == nil {
		this.RushId = rushData.RushId
		this.RushStage = rushData.RushStage
		this.RewardList = make(map[uint64]int32)
		this.RoundData = rushData.RoundData
		if len(rushData.RewardList) > 0 {
			for _, data := range rushData.RewardList {
				this.RewardList[data] = 1
			}
		}
		util.InfoF("loadRushMap success:%v", rushData)
		return nil
	}
	util.InfoF("loadRushMap failed")
	return err
}

func (this *MapScoreManger) CheckAddInitRoundData() {
	if this.RushId == 0 {
		return
	}
	for _, data := range this.RoundData {
		if data.RushId == this.RushId {
			return
		}
	}

	//初始化一下
	rankData := model2.GetRushActivityByRound(model2.Rush_Type_Map, this.RushId)
	if rankData == nil {
		util.ErrorF("[MapScoreManger] CheckAddInitRoundData config not found error:curRushId", this.RushId)
		return
	}
	//判定开始时间是否已经过了。
	startTime := model2.GetRushActivityTimeStamp(rankData.StartDay, rankData.StartTime)
	closeTime := model2.GetRushActivityTimeStamp(rankData.CloseDay, rankData.CloseTime)
	resetTime := model2.GetRushActivityTimeStamp(rankData.RestDay, rankData.RestTime)

	this.RoundData = append(this.RoundData, &serverproto.RushRoundData{
		RushId:    this.RushId,
		StartTime: startTime,
		CloseTime: closeTime,
		ResetTime: resetTime,
	})
	util.InfoF("[TowerRankManger] init time: %v - %v - %v， this.RoundData :%v", startTime, closeTime, resetTime, this.RoundData)
	this.saveRushMapDataToRedis()
}

func (this *MapScoreManger) saveRushMapDataToRedis() {
	keyStr := model2.RushMapPrefix
	rushData := &serverproto.RushData{
		RushId:    this.RushId,
		RushStage: this.RushStage,
		RoundData: this.RoundData,
	}
	for key, _ := range this.RewardList {
		rushData.RewardList = append(rushData.RewardList, key)
	}

	msgData, err := rocommon.GetCodec().Marshal(rushData)
	if err != nil {
		return
	}
	msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
	ret, err := service.GetRedis().Set(keyStr, msgStr, 0).Result()
	if err != nil {
		util.InfoF("saveRushMapDataToRedis err=%v ret=%v", keyStr, ret)
		return
	}
	util.InfoF("saveRushMapDataToRedis save rushData success : %v", rushData)
}

//当前是否有冲榜活动
func (this *MapScoreManger) CheckInRushActivity() bool {
	if this.RushId == 0 || (this.RushId != 0 && this.RushStage == int32(Rush_Map_Rank_End)) {
		return false
	}
	return true
}

//是否有新的冲榜开启
func (this *MapScoreManger) CheckNewRushActivity() {
	//如果在活动内，不做处理
	if this.RushId != 0 && this.RushStage != int32(Rush_Map_Rank_End) {
		return
	}
	//配置有问题
	rankData := model2.GetRushActivityByRound(model2.Rush_Type_Map, this.RushId+1)
	if rankData == nil {
		return
	}
	curTime := util.GetCurrentTime()

	bFind := false
	for _, data := range this.RoundData {
		if data.RushId == this.RushId+1 {
			bFind = true

			if data.StartTime <= curTime {
				this.RushId = this.RushId + 1
				this.RushStage = Rush_Map_Rank_Rush
				this.RewardList = make(map[uint64]int32)

				this.saveRushMapDataToRedis()
				util.InfoF("start new rushMap  this.RoundData:%v, ", data)
			}
			return
		}
	}

	if bFind == false {
		//判定开始时间是否已经过了。
		startTime := model2.GetRushActivityTimeStamp(rankData.StartDay, rankData.StartTime)
		closeTime := model2.GetRushActivityTimeStamp(rankData.CloseDay, rankData.CloseTime)
		resetTime := model2.GetRushActivityTimeStamp(rankData.RestDay, rankData.RestTime)

		//如果当前时间 >= startTime 则，设定开启时间 return
		newStartTime := startTime
		newCloseTime := closeTime
		newResetTime := resetTime

		//计算今天的开启时间//超过今天的开启时间，则开启时间定为第二天的开启时间
		loc := util.GetLoc()
		todayStartHour := util.GetLatest5Hour() - 24*3600*1000
		startServer := time.Unix(int64(todayStartHour/1000), 0).In(loc).Format(util.DATE_FORMAT1)
		startUpDayStr := util.GetDayByTimeStr1(startServer)
		todayRushBegin := util.GetTimeByStr(startUpDayStr.Format(util.DATE_FORMAT1) + " " + rankData.StartTime)
		todayRushStart := time.Unix(todayRushBegin.Unix(), 0).In(loc)

		todayRushTime := uint64(todayRushStart.UnixNano() / 1e6)
		//已经过了开服时间,才需要顺延。正常不需要顺延
		if startTime < curTime {
			if curTime <= todayRushTime {
				newStartTime = todayRushTime
			} else {
				newStartTime = todayRushTime + 24*3600*1000
			}
			newCloseTime = newStartTime + (closeTime - startTime)
			newResetTime = newStartTime + (resetTime - startTime)
		}

		//重置数据
		this.RoundData = append(this.RoundData, &serverproto.RushRoundData{
			RushId:    this.RushId + 1,
			StartTime: newStartTime,
			CloseTime: newCloseTime,
			ResetTime: newResetTime,
		})

		util.InfoF("init next rushMap  newStartTime:%v, newCloseTime:%v, newResetTime:%v", newStartTime, newCloseTime, newResetTime)
		this.saveRushMapDataToRedis()
	}
}

func (this *MapScoreManger) GetRoundTime(rushId int32) (uint64, uint64, uint64) {
	for _, data := range this.RoundData {
		if data.RushId == rushId {
			return data.StartTime, data.CloseTime, data.ResetTime
		}
	}
	return 0, 0, 0
}

//是否冲榜状态更新
func (this *MapScoreManger) SwitchRushActivityState() {
	if this.CheckInRushActivity() == false {
		this.CheckNewRushActivity()
		return
	}
	//活动结束。且又没有新的赛季直接返回
	if this.RushId == 0 || this.RushStage == int32(Rush_Map_Rank_End) {
		return
	}

	//切换状态
	curTime := util.GetCurrentTime()
	_, closeTime, resetTime := this.GetRoundTime(this.RushId)
	if closeTime == 0 || resetTime == 0 {
		util.ErrorF("TimeError : closeTime:%v, resetTime:%v, curTime:%v, this.RushId:%v", closeTime, resetTime, curTime, this.RushId)
		return
	}
	//找到活动，说明还在活动内
	if closeTime < curTime && curTime <= resetTime {
		if this.RushStage < Rush_Map_Rank_Reward {
			//进入领奖阶段，备份排行榜单
			this.backUpMapRankData()
			this.RushStage = Rush_Map_Rank_Reward
			this.saveRushMapDataToRedis()
		}
	} else if curTime > resetTime {
		//未找到，备份数据。直接结束活动
		if this.RushStage == Rush_Map_Rank_Rush || this.RushStage == Rush_Map_Rank_Reward {
			//活动结束了，则备份榜单。函数本身已经判定Key是否存在
			this.backUpMapRankData()

			//发送未领取的排行版邮件
			this.SendRushMapReward()
			this.RushStage = Rush_Map_Rank_End
			this.saveRushMapDataToRedis()
		}
	}
}

//备份爬塔数据
func (this *MapScoreManger) backUpMapRankData() {
	roundStr := strconv.Itoa(int(this.RushId))
	prefixStr := model2.RushMapRankPrefix + roundStr
	if !model2.ExistKey(prefixStr) {
		//	_, err := service.GetRedis().ZUnionStore(prefixStr, service.BaseStore{}, model2.RushMapScorePrefix).Result()
		_, err := service.GetRedis().Rename(model2.RushMapScorePrefix, prefixStr).Result()
		if err != nil {
			util.ErrorF("backUpMapRankData store rank record err=%v prefixStr=%v", err, prefixStr)
			return
		}
	}
}

func (this *MapScoreManger) GetSelfRushRank(uid uint64, rushId int32) (int32, int32) {
	//从爬塔榜单上取数据
	if this.RushStage == Rush_Map_Rank_Rush {
		keyStr := strconv.FormatUint(uid, 10)
		selfRank, rankErr := service.GetRedis().ZRevRank(model2.RushMapScorePrefix, keyStr).Result()
		if rankErr == nil && rankErr != service.NIL {
			topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(model2.RushMapScorePrefix, selfRank, selfRank).Result()
			if err3 == nil {
				for index, _ := range topListWithScore {
					rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)
					if rankUid == uid {
						_, _, score := getValByRushMapScore(topListWithScore[index].Score)
						return int32(selfRank + 1), int32(score)
					}
				}
			} else {
				util.DebugF("[GetTopMapRank] selfRank err:%v", err3)
			}
		}
	} else {
		rushRound := this.RushId
		if rushId != 0 {
			rushRound = rushId
		}
		roundStr := strconv.Itoa(int(rushRound))
		prefixStr := model2.RushMapRankPrefix + roundStr

		keyStr := strconv.FormatUint(uid, 10)
		selfRank, rankErr := service.GetRedis().ZRevRank(prefixStr, keyStr).Result()
		if rankErr == nil && rankErr != service.NIL {
			topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(prefixStr, selfRank, selfRank).Result()
			if err3 == nil {
				for index, _ := range topListWithScore {
					rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)
					if rankUid == uid {
						_, _, score := getValByRushMapScore(topListWithScore[index].Score)
						return int32(selfRank + 1), int32(score)
					}
				}
			} else {
				util.DebugF("[GetTopMapRank] selfRank err:%v", err3)
			}
		}
	}
	return 0, 0
}

func (this *MapScoreManger) GetCurrentRushActivity() *model2.RankList {
	curRushId := int32(0)
	if Rush_Map_Rank_Rush <= this.RushStage && this.RushStage < Rush_Map_Rank_End {
		curRushId = this.RushId
		if curRushId == 0 {
			return nil
		}
	}
	return model2.GetRushActivityByRound(model2.Rush_Type_Map, curRushId)
}

func (this *MapScoreManger) GetRewardLevel(rank int32) *model2.RewardRank {
	rankData := this.GetCurrentRushActivity()
	if rankData == nil {
		return nil
	}
	for _, data := range rankData.Reward {
		if data.RankBegin <= rank && rank <= data.RankEnd {
			return data
		}
	}
	return nil
}

func (this *MapScoreManger) SendRushMapReward() {
	rankData := model2.GetRushActivityByRound(model2.Rush_Type_Map, this.RushId)
	if rankData == nil {
		return
	}

	//发送邮件奖励
	roundStr := strconv.Itoa(int(this.RushId))
	prefixStr := model2.RushMapRankPrefix + roundStr
	topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(prefixStr, 0, MAPSCORE_TOP_3000-1).Result()
	if err3 == nil {
		ntfMsg := &serverproto.SSRushActivityRankRewardNtf{
			MailCfgId: model2.GlobalMailIdRushMap,
			MailType:  int32(serverproto.MailType_MailType_RushMap),
			RushRound: this.RushId,
		}

		for index, _ := range topListWithScore {
			rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)
			realRank := int32(index + 1)
			Uid := rankUid

			mailData := &serverproto.RushMailData{
				Uid: Uid,
			}
			bFind := false
			for _, data := range rankData.Reward {
				if data.RankBegin <= realRank && realRank <= data.RankEnd {
					mailData.MailParamList = append(mailData.MailParamList, realRank)
					mailData.MailParamList = append(mailData.MailParamList, data.RankLevel)
					mailData.RewardList = data.RewardList
					bFind = true
					break
				}
			}
			if !bFind { //没有排名奖励
				continue
			}
			ntfMsg.MailData = append(ntfMsg.MailData, mailData)

			if len(ntfMsg.MailData) >= MailMaxUids {
				SendToAllGame(ntfMsg)
				ntfMsg.MailData = ntfMsg.MailData[0:0]
			}
		}
		if len(ntfMsg.MailData) >= 1 {
			SendToAllGame(ntfMsg)
		}
	}
}

//打包冲榜信息给客户端
func (this *MapScoreManger) GetCurRushInfo(rushMapData *serverproto.RushActivityData) {
	if rushMapData == nil {
		return
	}

	if this.CheckInRushActivity() == false {
		rushMapData.InRush = false

		bFind := false
		for _, data := range this.RoundData {
			if data.RushId == this.RushId+1 {
				rushMapData.NextRush = data.StartTime
				bFind = true
				break
			}
		}
		if bFind == false {
			rushMapData.NextRush = 0
		}
		return
	}
	rankData := this.GetCurrentRushActivity()
	if rankData == nil {
		util.ErrorF("map config not found %v", this.RushId)
		return
	}
	rushMapData.InRush = true
	rushMapData.Stage = this.RushStage
	rushMapData.RushCount = rankData.RankRound

	_, closeTime, resetTime := this.GetRoundTime(this.RushId)
	if this.RushStage == Rush_Pet_Rank_Rush {
		rushMapData.StageEnd = closeTime
	} else {
		rushMapData.StageEnd = resetTime
	}
}

func (this *MapScoreManger) GetTop3RushMapData(rankData *model2.RankList, ackMsg *serverproto.SSGetRushDataAck) int32 {
	//从爬塔榜单上取数据
	for _, data := range rankData.Reward {
		if this.RushStage == Rush_Map_Rank_Rush {
			topListWithScore, err := service.GetRedis().ZRevRangeWithScores(model2.RushMapScorePrefix, int64(data.RankEnd-1), int64(data.RankEnd-1)).Result()
			if err == nil {
				for index, _ := range topListWithScore {
					rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)

					_, _, level := getValByRushMapScore(topListWithScore[index].Score)
					brief := &serverproto.CommonPlayerBriefInfo{}
					err2 := model.GetSystemDataFromRedis(model.RolePlayerBriefPrefix, rankUid, brief)
					if err2 != nil {
						continue
					}

					top3 := &serverproto.RushRankTop3{
						Name: brief.NickName,
						Rank: int32(data.RankEnd),
						Data: int32(level),
					}
					ackMsg.TopData = append(ackMsg.TopData, top3)
					break
				}
			}
		} else if this.RushStage == Rush_Map_Rank_Reward {
			roundStr := strconv.Itoa(int(this.RushId))
			prefixStr := model2.RushMapRankPrefix + roundStr
			topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(prefixStr, int64(data.RankEnd-1), int64(data.RankEnd-1)).Result()
			if err3 == nil {
				for index, _ := range topListWithScore {
					rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)

					_, _, level := getValByRushMapScore(topListWithScore[index].Score)
					brief := &serverproto.CommonPlayerBriefInfo{}
					err2 := model.GetSystemDataFromRedis(model.RolePlayerBriefPrefix, rankUid, brief)
					if err2 != nil {
						continue
					}

					top3 := &serverproto.RushRankTop3{
						Name: brief.NickName,
						Rank: int32(data.RankEnd),
						Data: int32(level),
					}
					ackMsg.TopData = append(ackMsg.TopData, top3)
					break
				}
			}
		}
	}
	return 0
}

func (this *MapScoreManger) GetSelfRushData(ackMsg *serverproto.SSGetRushDataAck) {
	if ackMsg == nil {
		return
	}
	rankData := this.GetCurrentRushActivity()
	if rankData == nil {
		util.ErrorF("map config not found %v", this.RushId)
		return
	}

	ackMsg.CurRushRound = this.RushId
	ackMsg.SelfRank, ackMsg.SelfLevel = this.GetSelfRushRank(ackMsg.Uid, 0)

	_, closeTime, resetTime := this.GetRoundTime(this.RushId)
	if this.RushStage == Rush_Map_Rank_Rush {
		ackMsg.EndTime = closeTime
	} else {
		ackMsg.EndTime = resetTime
	}
	this.GetTop3RushMapData(rankData, ackMsg)
}

func (this *MapScoreManger) CheckRushMapAddScore(ackMsg *serverproto.SSRushDataChangeAck) {
	if ackMsg == nil {
		return
	}
	if this.RushStage == Rush_Map_Rank_Rush {
		ackMsg.RushRound = this.RushId
		return
	}
	ackMsg.RushRound = 0
}

func (this *MapScoreManger) GetRushMapReward(ackMsg *serverproto.SSGetRushRewardAck, rewardType int32) {
	if rewardType == model2.Rush_Reward_Type_FightCount {
		this.GetRushMapBaseReward(ackMsg)
	} else if rewardType == model2.Rush_Reward_Type_Rank {
		this.GetRushMapRankReward(ackMsg)
	}
}

func (this *MapScoreManger) GetRushMapBaseReward(ackMsg *serverproto.SSGetRushRewardAck) {
	if ackMsg == nil {
		return
	}

	rankData := this.GetCurrentRushActivity()
	if rankData == nil {
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_RUSH_ACTIVITY_REWARD_FINISH)
		return
	}
	if this.RushStage != Rush_Map_Rank_Reward {
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
		return
	}
	ackMsg.RushRound = this.RushId
	ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
}

func (this *MapScoreManger) GetRushMapRankReward(ackMsg *serverproto.SSGetRushRewardAck) {
	if ackMsg == nil {
		return
	}

	rankData := this.GetCurrentRushActivity()
	if rankData == nil {
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_RUSH_ACTIVITY_REWARD_FINISH)
		return
	}
	if this.RushStage != Rush_Map_Rank_Reward {
		return
	}
	rank, _ := this.GetSelfRushRank(ackMsg.Uid, 0)
	if rank == 0 {
		return
	}
	ackMsg.RushRound = this.RushId
	for _, data := range rankData.Reward {
		if data.RankBegin <= rank && rank <= data.RankEnd {
			for _, item := range data.RewardList {
				ackMsg.ItemList = append(ackMsg.ItemList, &serverproto.KeyValueType{
					Key:   item.Key,
					Value: item.Value,
				})
			}
			break
		}
	}
}

func (this *MapScoreManger) GetRushInfo() (int32, int32) {
	if this.RushId == 0 || this.RushStage == Rush_Map_Rank_End {
		return Rush_Map_Rank_End, 0
	}
	return this.RushStage, this.RushId
}

func (this *MapScoreManger) GetRushBaseReward(uid uint64, rushRound int32, ackMsg *serverproto.SSGetRushBaseRewardAck) {
	ackMsg.Reward = false
	if this.RushId > rushRound {
		ackMsg.Reward = true
		ackMsg.RewardRound = rushRound
		return
	}

	if this.RushId > rushRound || (this.RushId == rushRound && this.RushStage == Rush_Map_Rank_End) {
		ackMsg.Reward = true
		ackMsg.RewardRound = rushRound
	}
}

func (this *MapScoreManger) GetRushReward(uid uint64, rankRound int32, ackMsg *serverproto.RankRewardList) {
	finishRound := this.RushId
	if this.RushStage < Rush_Map_Rank_End {
		finishRound = this.RushId - 1
	}
	if finishRound <= 0 || finishRound <= rankRound {
		return
	}
	ackMsg.FinishRound = finishRound

	for round := rankRound + 1; round <= finishRound; round++ {
		selfRank, _ := this.GetSelfRushRank(uid, round)
		if selfRank == 0 {
			return
		}
		rankData := model2.GetRushActivityByRound(model2.Rush_Type_Map, round)
		if rankData == nil {
			return
		}
		rankRewardData := &serverproto.RankRewardData{
			RushRound: round,
		}

		rankRewardData.MailParamList = append(rankRewardData.MailParamList, selfRank)
		for _, data := range rankData.Reward {
			if data.RankBegin <= selfRank && selfRank <= data.RankEnd {
				for _, item := range data.RewardList {
					rankRewardData.RewardList = append(rankRewardData.RewardList, &serverproto.KeyValueType{
						Key:   item.Key,
						Value: item.Value,
					})
				}
				rankRewardData.MailParamList = append(rankRewardData.MailParamList, data.RankLevel)
				break
			}
		}
		ackMsg.RankReward = append(ackMsg.RankReward, rankRewardData)
	}
}