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

package model

import (
	"encoding/base64"
	"rocommon"
	"rocommon/service"
	"rocommon/util"
	model2 "roserver/baseserver/model"
	"roserver/db/model"
	"roserver/serverproto"
	"strconv"
	"time"
)

//排名前3玩家uid列表
const (
	TOWERRANK_TOP_50   = 50   //玩家可查看排名数量
	TOWERRANK_TOP_1000 = 1000 //最大排名数量
	TOWEFIGHT_RANK     = 50   //每次更新50个到DB
	TOWERRANK_TOP_3    = 3    //玩家可查看排名数量
)
const RefreshTime = 5 * 1000
const MailMaxUids = 50
const (
	Rush_Tower_Rank_Rush   = 1 //冲榜阶段
	Rush_Tower_Rank_Reward = 2 //领奖阶段
	Rush_Tower_Rank_End    = 3 //结束
)

//爬塔战力信息
type TowerFightInfo struct {
	Uid        uint64
	FightPower int32
	TowerLevel int32
	ImgID      int32
}

type TowerMinFight struct {
	TowerLevel int32
	Brief      *serverproto.CommonPlayerBriefInfo
}

type TowerRankManger struct {
	TowerMinFightList map[int32]*serverproto.TowerBriefInfo
	TickTime          uint64
	ChangeList        map[int32]int32

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

func newTowerRankManger() *TowerRankManger {
	mag := &TowerRankManger{
		TowerMinFightList: map[int32]*serverproto.TowerBriefInfo{},
	}
	mag.TickTime = 0
	mag.ChangeList = make(map[int32]int32)
	mag.initRushTime = false
	return mag
}

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

	if this.TickTime == 0 {
		err := this.getTowerFightPowerFromRedis()
		if err != nil && err != service.NIL {
			util.ErrorF("[TowerRankManger] getTowerFightPowerFromRedis err:%v", err)
			return
		}
		err1 := this.loadRushTowerDataFromRedis()
		if err1 != nil && err1 != service.NIL {
			util.ErrorF("[TowerRankManger] loadRushTowerDataFromRedis err:%v", err1)
			return
		}
		this.TickTime = ms
		util.InfoF("[TowerRankManger] 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.SetTowerFightPowerToRedis()
		this.SwitchRushActivityState()

		this.TickTime = ms
		return
	}
}

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

	//初始化一下
	rankData := model2.GetRushActivityByRound(model2.Rush_Type_Tower, this.RushId)
	if rankData == nil {
		util.ErrorF("[TowerRankManger] 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.saveRushTowerDataToRedis()
}

func (this *TowerRankManger) getTowerFightPowerFromRedis() error {
	keyStr := model2.TowerFightpowerRankPrefix
	valueStr, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.InfoF("getTowerFightPowerFromRedis get keyStr=%v err=%v", keyStr, err)
		return err
	}
	util.InfoF("getTowerFightPowerFromRedis ---------  get keyStr=%v err=%v", keyStr, err)

	for towerLevel, towerValue := range valueStr {

		val, _ := model2.Str2Num(towerLevel)
		msgStr, err := base64.StdEncoding.DecodeString(towerValue)
		if err != nil {
			util.InfoF("getTowerFightPowerFromRedis level=%v err=%v", towerLevel, err)
			continue
		}
		tower := &serverproto.TowerBriefInfo{}
		err = rocommon.GetCodec().Unmarshal(msgStr, tower)
		if err == nil {
			this.TowerMinFightList[int32(val)] = tower
		} else {
			return err
		}
	}
	//util.DebugF("getTowerFightPowerFromRedis TowerMinFightList=%v", this.TowerMinFightList)

	return nil
}

func (this *TowerRankManger) SetTowerFightPowerToRedis() {
	if len(this.ChangeList) <= 0 {
		return
	}
	var count int = 0
	for towerLevel, _ := range this.ChangeList {
		if count >= TOWEFIGHT_RANK {
			break
		}
		data, ok := this.TowerMinFightList[towerLevel]
		if !ok {
			continue
		}

		fieldStr := strconv.FormatUint(uint64(towerLevel), 10)
		keyStr := model2.TowerFightpowerRankPrefix

		msgData, err := rocommon.GetCodec().Marshal(data)
		if err != nil {
			util.InfoF("[SetTowerFightPowerToRedis] Marshal err:%v %v %s", err, fieldStr, msgData)
			continue
		}
		msgStr := base64.StdEncoding.EncodeToString(msgData.([]byte))
		ret, err := service.GetRedis().HSet(keyStr, fieldStr, msgStr).Result()
		if err != nil {
			util.InfoF("[SetTowerFightPowerToRedis] err:%v %v", err, ret)
			continue
		}
		delete(this.ChangeList, towerLevel)
		count++
	}

	return
}

func (this *TowerRankManger) AddMinFightListGM(brief *serverproto.TowerBriefInfo) bool {
	for i := 1; i <= int(brief.CommonInfo.TowerLevel); i++ {
		bDirty := false
		if this.TowerMinFightList == nil {
			this.TowerMinFightList[brief.CommonInfo.TowerLevel] = brief
			bDirty = true
		} else {
			data, ok := this.TowerMinFightList[brief.CommonInfo.TowerLevel]
			if !ok {
				this.TowerMinFightList[brief.CommonInfo.TowerLevel] = brief
				util.DebugF("[AddMinFightList] GM add new level fight brief:%s", brief)
				bDirty = true
			} else {
				//传进来的战力更小
				if data.CommonInfo.FightPower > brief.CommonInfo.FightPower {
					this.TowerMinFightList[brief.CommonInfo.TowerLevel] = brief
					util.DebugF("[AddMinFightList] GM change new level fight brief:%s", brief)
					bDirty = true
				}
			}
		}

		if bDirty == true {
			this.ChangeList[brief.CommonInfo.TowerLevel] = 1
		}
	}
	return true
}

func (this *TowerRankManger) AddMinFightList(brief *serverproto.TowerBriefInfo) bool {
	//为零怎么可能发送过来？真是奇怪了
	var oldRecordId uint64 = 0
	bDirty := false
	if this.TowerMinFightList == nil {
		this.TowerMinFightList[brief.CommonInfo.TowerLevel] = brief
		bDirty = true
	} else {
		data, ok := this.TowerMinFightList[brief.CommonInfo.TowerLevel]
		if !ok {
			this.TowerMinFightList[brief.CommonInfo.TowerLevel] = brief
			util.DebugF("[AddMinFightList] add new level fight brief:%s", brief)
			bDirty = true
		} else {
			//传进来的战力更小
			if data.CommonInfo.FightPower > brief.CommonInfo.FightPower || brief.BattleVersion > data.BattleVersion {
				oldRecordId = data.CommonInfo.BattleRecordId
				this.TowerMinFightList[brief.CommonInfo.TowerLevel] = brief
				util.DebugF("[AddMinFightList] change new level fight brief:%s", brief)
				bDirty = true
			}
		}
	}
	if bDirty == true {
		this.ChangeList[brief.CommonInfo.TowerLevel] = 1

		//战报处理
		if oldRecordId > 0 {
			oldRecordIdStr := strconv.FormatUint(oldRecordId, 10)
			service.GetRedis().Expire(model2.BattleRecordDetailPrefix+oldRecordIdStr, time.Minute*1)
		}
		if brief.CommonInfo.BattleRecordId > 0 {
			service.GetRedis().SAdd(model2.BattleRecordDetailCheckPrefix, brief.CommonInfo.BattleRecordId)
		}

		return true
	}
	return false
}

func (this *TowerRankManger) GetMinFightList(towerLevel int32, ackMsg *serverproto.SSTowerMinFightPowerAck) {
	if len(this.TowerMinFightList) <= 0 {
		return
	}

	data, ok := this.TowerMinFightList[towerLevel]
	if ok {
		info := &serverproto.TowerMinFight{
			FightPower:    data.CommonInfo.FightPower,
			Infos:         data.CommonInfo,
			BattleTime:    uint32(data.BattleTime),
			RecordTime:    data.CommonInfo.TowerTime,
			BattleVersion: data.BattleVersion,
		}

		ackMsg.TowerInfo = append(ackMsg.TowerInfo, info)
	}
}

//passTime 传进来的是秒。所以32位够用。以防万一就用48位，所以还要判定下0xffffffffffff > passTime
func (this *TowerRankManger) GetTowerRankScore(val uint64, passTime uint64) uint64 {
	//score
	var scoreStr = val
	if scoreStr >= (1 << 16) {
		scoreStr = (1 << 16) - 1
	}
	scoreStr <<= 48
	if 0xffffffffffff > passTime {
		scoreStr |= 0xffffffffffff - passTime //通关先到的passTime越小。取反则越大，相同关卡则排在前
	} else {
		scoreStr |= 1
	}
	return scoreStr
}

//全服爬塔排名逻辑
func (this *TowerRankManger) AddTowerLevelRank(brief *serverproto.CommonPlayerBriefInfo) uint32 {
	//score
	scoreStr := getTowerScore(uint64(brief.TowerLevel), brief.TowerTime)
	//uid
	keyStr := strconv.FormatUint(brief.Uid, 10)

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

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

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

	return uint32(selfRank + 1)
}

func (this *TowerRankManger) GetTopTowerRank(uid uint64, ackMsg *serverproto.SSPassTowerLevelRankAck) int32 {
	if ackMsg == nil {
		return 0
	}

	topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(model2.TowerLevelRankPrefix, 0, TOWERRANK_TOP_50-1).Result()
	if err3 == nil {
		for index, _ := range topListWithScore {
			rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)
			//	_, _, TowerLevel := getValByRankScore(topListWithScore[index].Score)
			info := &serverproto.TowerLevelInfo{
				Rank: int32(index + 1),
				Uid:  rankUid,
			}
			ackMsg.TowerInfo = append(ackMsg.TowerInfo, info)
		}
		//获取自己的排名
		keyStr := strconv.FormatUint(uid, 10)
		selfRank, err4 := service.GetRedis().ZRevRank(model2.TowerLevelRankPrefix, keyStr).Result()
		if err4 != nil {
			util.DebugF("[GetTopTowerRank] selfRank err:%v", err4)
			return 0
		}
		ackMsg.SelfRank = int32(selfRank + 1)
		return int32(selfRank)
	}
	return 0
}

//=================================================      爬塔冲榜     =================================================
//加载赛季数据
func (this *TowerRankManger) loadRushTowerDataFromRedis() error {
	keyStr := model2.RushTowerPrefix
	ret, err := service.GetRedis().Get(keyStr).Result()
	if err != nil {
		util.InfoF("LoadTowerData 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("LoadTowerData success:%v", rushData)
		return nil
	}
	util.InfoF("LoadTowerData failed")
	return err
}

func (this *TowerRankManger) saveRushTowerDataToRedis() {
	keyStr := model2.RushTowerPrefix
	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("SaveTowerData err=%v ret=%v", keyStr, ret)
		return
	}
	util.InfoF("SaveTowerData save rushData sucess : %v", rushData)
}

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

//是否有新的冲榜开启
func (this *TowerRankManger) CheckNewRushActivity() {
	//如果在活动内，不做处理
	if this.RushId != 0 && this.RushStage != int32(Rush_Tower_Rank_End) {
		return
	}
	//配置有问题
	rankData := model2.GetRushActivityByRound(model2.Rush_Type_Tower, 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_Tower_Rank_Rush
				this.RewardList = make(map[uint64]int32)

				this.saveRushTowerDataToRedis()
				util.InfoF("start new rushTower  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 rushTower  newStartTime:%v, newCloseTime:%v, newResetTime:%v, serverStart:%s", newStartTime, newCloseTime, newResetTime, startUpDayStr)
		this.saveRushTowerDataToRedis()
	}
}

func (this *TowerRankManger) 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 *TowerRankManger) SwitchRushActivityState() {
	if this.CheckInRushActivity() == false {
		this.CheckNewRushActivity()
		return
	}
	//活动结束。且又没有新的赛季直接返回
	if this.RushId == 0 || this.RushStage == int32(Rush_Tower_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_Tower_Rank_Reward {
			//进入领奖阶段，备份排行榜单
			this.backUpTowerRankData()
			this.RushStage = Rush_Tower_Rank_Reward
			this.saveRushTowerDataToRedis()
		}
	} else if curTime > resetTime {
		//未找到，备份数据。直接结束活动
		if this.RushStage == Rush_Tower_Rank_Rush || this.RushStage == Rush_Tower_Rank_Reward {
			//活动结束了，则备份榜单。函数本身已经判定Key是否存在
			this.backUpTowerRankData()

			//发送未领取的排行版邮件
			this.SendRushTowerReward()
			this.RushStage = Rush_Tower_Rank_End
			this.saveRushTowerDataToRedis()
		}
	}
}

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

func (this *TowerRankManger) GetSelfRushRank(uid uint64, rushId int32) (int32, int32) {
	//从爬塔榜单上取数据
	if this.RushStage == Rush_Tower_Rank_Rush {

		keyStr := strconv.FormatUint(uid, 10)
		selfRank, rankErr := service.GetRedis().ZRevRank(model2.TowerLevelRankPrefix, keyStr).Result()
		if rankErr == nil && rankErr != service.NIL {
			topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(model2.TowerLevelRankPrefix, selfRank, selfRank).Result()
			if err3 == nil {
				for index, _ := range topListWithScore {
					rankUid, _ := strconv.ParseUint(topListWithScore[index].Member.(string), 10, 64)
					if rankUid == uid {
						_, _, towerLevel := getValByTowerScore(topListWithScore[index].Score)
						return int32(selfRank + 1), int32(towerLevel)
					}
				}
			} else {
				util.DebugF("[GetTopTowerRank] selfRank err:%v", err3)
			}
		}
	} else {
		rushRound := this.RushId
		if rushId != 0 {
			rushRound = rushId
		}
		roundStr := strconv.Itoa(int(rushRound))
		prefixStr := model2.RushTowerRankPrefix + 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 {
						_, _, towerLevel := getValByTowerScore(topListWithScore[index].Score)

						return int32(selfRank + 1), int32(towerLevel)
					}
				}
			} else {
				util.DebugF("[GetTopTowerRank] selfRank err:%v", err3)
			}
		}
	}
	return 0, 0
}

func (this *TowerRankManger) GetCurrentRushActivity() *model2.RankList {
	curRushId := int32(0)
	if Rush_Tower_Rank_Rush <= this.RushStage && this.RushStage < Rush_Tower_Rank_End {
		curRushId = this.RushId
		if curRushId == 0 {
			return nil
		}
	}
	return model2.GetRushActivityByRound(model2.Rush_Type_Tower, curRushId)
}

func (this *TowerRankManger) 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 *TowerRankManger) SendRushTowerReward() {
	rankData := model2.GetRushActivityByRound(model2.Rush_Type_Tower, this.RushId)
	if rankData == nil {
		return
	}

	//发送邮件奖励
	roundStr := strconv.Itoa(int(this.RushId))
	prefixStr := model2.RushTowerRankPrefix + roundStr
	topListWithScore, err3 := service.GetRedis().ZRevRangeWithScores(prefixStr, 0, TOWERRANK_TOP_1000-1).Result()
	if err3 == nil {
		ntfMsg := &serverproto.SSRushActivityRankRewardNtf{
			MailCfgId: model2.GlobalMailIdRushTower,
			MailType:  int32(serverproto.MailType_MailType_RushTower),
			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 *TowerRankManger) GetCurRushInfo(rushTowerData *serverproto.RushActivityData) {
	if rushTowerData == nil {
		return
	}

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

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

	_, closeTime, resetTime := this.GetRoundTime(this.RushId)
	if this.RushStage == Rush_Tower_Rank_Rush {
		rushTowerData.StageEnd = closeTime //model2.GetRushActivityTimeStamp(rankData.CloseDay, rankData.CloseTime)
	} else {
		rushTowerData.StageEnd = resetTime //model2.GetRushActivityTimeStamp(rankData.RestDay, rankData.RestTime)
	}
}

func (this *TowerRankManger) GetTop3RushTowerData(rankData *model2.RankList, ackMsg *serverproto.SSGetRushDataAck) int32 {
	//从爬塔榜单上取数据
	for _, data := range rankData.Reward {
		if this.RushStage == Rush_Tower_Rank_Rush {
			topListWithScore, err := service.GetRedis().ZRevRangeWithScores(model2.TowerLevelRankPrefix, 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 := getValByTowerScore(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)
				}
			}
		} else if this.RushStage == Rush_Tower_Rank_Reward {
			roundStr := strconv.Itoa(int(this.RushId))
			prefixStr := model2.RushTowerRankPrefix + 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 := getValByTowerScore(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)
				}
			}
		}
	}
	return 0
}

func (this *TowerRankManger) GetSelfRushData(ackMsg *serverproto.SSGetRushDataAck) {
	if ackMsg == nil {
		return
	}
	rankData := this.GetCurrentRushActivity()
	if rankData == nil {
		util.ErrorF("tower 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_Tower_Rank_Rush {
		ackMsg.EndTime = closeTime //model2.GetRushActivityTimeStamp(rankData.CloseDay, rankData.CloseTime)
	} else {
		ackMsg.EndTime = resetTime //model2.GetRushActivityTimeStamp(rankData.RestDay, rankData.RestTime)
	}
	this.GetTop3RushTowerData(rankData, ackMsg)
}

func (this *TowerRankManger) CheckRushTowerAddScore(ackMsg *serverproto.SSRushDataChangeAck) {
	if ackMsg == nil {
		return
	}
	if this.RushStage == Rush_Tower_Rank_Rush {
		ackMsg.RushRound = this.RushId
		return
	}
	ackMsg.RushRound = 0
}

func (this *TowerRankManger) GetRushTowerReward(ackMsg *serverproto.SSGetRushRewardAck, rewardType int32) {
	if rewardType == model2.Rush_Reward_Type_FightCount {
		this.GetRushTowerBaseReward(ackMsg)
	} else if rewardType == model2.Rush_Reward_Type_Rank {
		this.GetRushTowerRankReward(ackMsg)
	}
}

func (this *TowerRankManger) GetRushTowerBaseReward(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_Tower_Rank_Reward && this.RushStage != Rush_Tower_Rank_Rush {
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
		return
	}
	ackMsg.RushRound = this.RushId
	ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
}

func (this *TowerRankManger) GetRushTowerRankReward(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_Tower_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 *TowerRankManger) GetRushInfo() (int32, int32) {
	if this.RushId == 0 || this.RushStage == Rush_Tower_Rank_End {
		return Rush_Tower_Rank_End, 0
	}
	return this.RushStage, this.RushId
}

func (this *TowerRankManger) 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_Tower_Rank_End) {
		ackMsg.Reward = true
		ackMsg.RewardRound = rushRound
	}
}

func (this *TowerRankManger) GetRushReward(uid uint64, rankRound int32, ackMsg *serverproto.RankRewardList) {
	finishRound := this.RushId
	if this.RushStage < Rush_Tower_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_Tower, 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)
	}
}