RoServer/RO_Server_Trunk-branch_bt/roserver/game/model/role_competition.go

package model

import (
	"math/rand"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"time"
)

//competition
//获取给定赛季信息
func (this *Role) GetCompetition(competitionId int32) {
	if this.roleCompetition != nil {
		ret := this.roleCompetition.GetCompetition(competitionId)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCompetitionAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}
func (this *Role) CompetitionAddScore(itemList []*serverproto.KeyValueType) {
	if this.roleCompetition != nil {
		ret := this.roleCompetition.CompetitionAddScore(itemList)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCompetitionScoreAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) DoUpdateScoreNtf(msg *serverproto.SSCompetitionUpdateScoreAck) {
	if this.roleCompetition != nil {
		this.roleCompetition.DoUpdateScoreNtf(msg)
	}
}

func (this *Role)GetDivineInfo() {
	ackMsg := &serverproto.SCCompetitionStarInfoAck{}
	if this.roleCompetition != nil {
		this.roleCompetition.GetDivineInfo(ackMsg)
	}
	this.ReplayGate(ackMsg, true)
}

func (this *Role)OnStarDivine(useTicket bool) {
	ackMsg := &serverproto.SCCompetitionStarDivineAck{
		Error: int32(serverproto.ErrorCode_ERROR_FAIL),
	}
	if this.roleCompetition != nil {
		bRet := this.roleCompetition.OnStarDivine(useTicket, ackMsg)
		ackMsg.Error = int32(bRet)
	}
	this.ReplayGate(ackMsg, true)
}

func (this *Role)GetDivineReward() {
	ackMsg := &serverproto.SCCompetitionStarCloseRewardAck{
		Error: int32(serverproto.ErrorCode_ERROR_FAIL),
	}
	if this.roleCompetition != nil {
		bRet := this.roleCompetition.GetDivineReward(ackMsg)
		ackMsg.Error = int32(bRet)
	}
	this.ReplayGate(ackMsg, true)
}

func (this *Role)VoteIdol(uid uint64, ticketCount int32) {
		ackMsg := &serverproto.SCCompetitionOnVoteAck{
			Error: int32(serverproto.ErrorCode_ERROR_FAIL),
		}

	if this.roleCompetition != nil {
		bRet := this.roleCompetition.VoteIdol(uid, ticketCount, true)
		ackMsg.Error = int32(bRet)
		if bRet != serverproto.ErrorCode_ERROR_OK {
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role)CheckInSeason() (serverproto.ErrorCode, int32) {
	if this.roleCompetition != nil {
		bRet, competitionId := this.roleCompetition.CheckInIdolSeason()
		return bRet, competitionId
	}
	return serverproto.ErrorCode_ERROR_FAIL, 0
}

func (this *Role)GetSelfVoteData(ackMsg *serverproto.SCCompetitionFansRewardRankAck) {
	if this.roleCompetition != nil {
		this.roleCompetition.GetSelfVoteData(ackMsg)
	}
}

func (this *Role)CheckFansReward(uid uint64, rewardLevel int32) serverproto.ErrorCode {
	if this.roleCompetition != nil {
		bRet := this.roleCompetition.CheckFansReward(uid, rewardLevel)
		return bRet
	}
	return serverproto.ErrorCode_ERROR_FAIL
}

func (this *Role)GetFansReward(idolUid uint64, rewardLevel int32, boxCount int32) {
	ackMsg := &serverproto.SCCompetitionFansGetRewardAck{
		Error:       int32(serverproto.ErrorCode_ERROR_FAIL),
		Uid:         idolUid,
		RewardLevel: rewardLevel,
	}

	if this.roleCompetition != nil {
		addItemList := map[int32]int32{}
		bRet, rewardFlag := this.roleCompetition.GetFansReward(idolUid, boxCount, true, addItemList)
		for itemId, itemCount := range addItemList {
			ackMsg.RewardList = append(ackMsg.RewardList, &serverproto.KeyValueType{
				Key:   itemId,
				Value: itemCount,
			})
		}
		ackMsg.RewardFlag = rewardFlag

		ackMsg.Error = int32(bRet)
	}
	this.ReplayGate(ackMsg, true)
}

func (this *Role)GetAllFansReward(idol_list []*serverproto.KeyValueType64) {
	if this.roleCompetition != nil {
		this.roleCompetition.GetAllFansReward(idol_list)
	}
}

func (this *Role)GetIdolDayReward(id int32) {
	ackMsg := &serverproto.SCCompetitionFansDayRewardAck{
		Error: int32(serverproto.ErrorCode_ERROR_FAIL),
		Id:    id,
	}
	if this.roleCompetition != nil {
		bRet := this.roleCompetition.GetIdolDayReward(id)
		ackMsg.Error = int32(bRet)
	}
	this.ReplayGate(ackMsg, true)
}

//上交道具获取积分

type RoleCompetition struct {
	SaveObject

	//当前进行中的赛季时间信息
	curCompInfo            *serverproto.CompetitionInfo
	rewardCompetitionId    int32
	rewardCompetitionSubId int32
	divineInfo             *serverproto.DivineInfo
	idolInfo               *serverproto.IdolInfo

	tempAddScore int32
}

func newRoleCompetition(r *Role) *RoleCompetition {
	com := &RoleCompetition{
		SaveObject: SaveObject{
			role: r,
		},
		curCompInfo: &serverproto.CompetitionInfo{},
		divineInfo:  &serverproto.DivineInfo{},
		idolInfo:    &serverproto.IdolInfo{},
	}
	return com
}

func (this *RoleCompetition) Load(msg interface{}) bool {
	proRole := msg.(*serverproto.Role)
	if proRole != nil && proRole.RoleCompetition != nil {
		this.rewardCompetitionId = proRole.RoleCompetition.RewardCompetitionId
		this.rewardCompetitionSubId = proRole.RoleCompetition.RewardCompetitionSubId

		if proRole.RoleCompetition.CurCompetition != nil {
			this.curCompInfo = proRole.RoleCompetition.CurCompetition
		}
		if proRole.RoleCompetition.Divine != nil {
			this.divineInfo = proRole.RoleCompetition.Divine
		}
		if proRole.RoleCompetition.Idol != nil {
			this.idolInfo = proRole.RoleCompetition.Idol
		}
	}

	util.GetTimeMilliseconds()
	if CompetitionMag.curCompetitionId > 0 {
		if this.curCompInfo.CompetitionId != CompetitionMag.curCompetitionId {
			this.curCompInfo.ComParam = 0
			this.curCompInfo.ComParamAddTime = 0
		}
		this.curCompInfo.CompetitionId = CompetitionMag.curCompetitionId
		this.curCompInfo.CurEndTime = uint64(CompetitionMag.curComEndTime.UnixNano() / 1e6)
	} else {
		this.curCompInfo.CompetitionId = CompetitionMag.preCompetitionId
		this.curCompInfo.ComParam = 0
		this.curCompInfo.ComParamAddTime = 0
		this.curCompInfo.CurEndTime = 0
	}

	util.DebugF("uid=%v RoleCompetition Load...", this.role.GetUUid())
	return true
}

func (this *RoleCompetition) CompetitionRefresh() {
	util.GetTimeMilliseconds()
	if CompetitionMag.curCompetitionId > 0 {
		if this.curCompInfo.CompetitionId != CompetitionMag.curCompetitionId {
			this.curCompInfo.ComParam = 0
			this.curCompInfo.ComParamAddTime = 0
		}
		this.curCompInfo.CompetitionId = CompetitionMag.curCompetitionId
		this.curCompInfo.CurEndTime = uint64(CompetitionMag.curComEndTime.UnixNano() / 1e6)
	} else {
		this.curCompInfo.CompetitionId = CompetitionMag.preCompetitionId
		this.curCompInfo.ComParam = 0
		this.curCompInfo.ComParamAddTime = 0
		this.curCompInfo.CurEndTime = 0
	}
}

func (this *RoleCompetition) CopyData(data *serverproto.RoleCompetition) {
	//重新登录刷新赛季信息
	if CompetitionMag.curCompetitionId > 0 {
		this.curCompInfo.CompetitionId = CompetitionMag.curCompetitionId
		this.curCompInfo.CurEndTime = uint64(CompetitionMag.curComEndTime.UnixNano() / 1e6)
	} else {
		this.curCompInfo.CompetitionId = CompetitionMag.preCompetitionId
		this.curCompInfo.CurEndTime = 0
	}
	data.CurCompetition = this.curCompInfo
}

func (this *RoleCompetition) Save() {
	this.SetDirty(false)
	util.DebugF("uid=%v RoleCompetition save...", this.role.GetUUid())

	ssSaveMsg := &serverproto.SSCompetitionSaveReq{
		CompetitionData: &serverproto.RoleCompetition{
			RewardCompetitionId:    this.rewardCompetitionId,
			RewardCompetitionSubId: this.rewardCompetitionSubId,
			CurCompetition: &serverproto.CompetitionInfo{
				ComParam:        this.curCompInfo.ComParam,
				ComParamAddTime: this.curCompInfo.ComParamAddTime,
				CompetitionId:   this.curCompInfo.CompetitionId,
			},
			Divine: this.divineInfo,
			Idol:   this.idolInfo,
		},
	}
	this.role.SendDb(ssSaveMsg)
}

func (this *RoleCompetition)DailyReset(notify bool) {
	if this.idolInfo != nil {
		this.idolInfo.DayReward = this.idolInfo.DayReward[0:0]
		this.NeedResetIdolRewardTime()
		util.InfoF("uid=%v RoleCompetition DailyReset ... this.idolInfo:%v ", this.role.GetUUid(), this.idolInfo)
		this.SetDirty(true)
	}
}

//上交道具获得积分
func (this RoleCompetition) UpdateRankByCompetitionScore(isOnline bool) {
	if CompetitionMag.IsCompetitionOnline() {
		compData, ok := model.ConvertCompTimeList[CompetitionMag.curCompetitionId]
		if !ok {
			util.ErrorF("uid=%v UpdateRankByArenaScore data not find!!!! id=%v", this.role.GetUUid(), CompetitionMag.curCompetitionId)
			return
		}
		//第二赛季上交道具获得积分赛季，上线就进入排行榜
		if compData.CompetitionType == int32(model.CompetitionType_XuanBa) ||
			compData.CompetitionType == int32(model.CompetitionType_DuoBao) ||
			compData.CompetitionType == int32(model.CompetitionType_ZhanBu) ||
			compData.CompetitionType == int32(model.CompetitionType_Idol) {
			//上线更新的方式，积分必须为0
			if isOnline && this.curCompInfo.ComParam > 0 {
				return
			}
			if this.curCompInfo.CompetitionId != CompetitionMag.curCompetitionId {
				this.curCompInfo.ComParam = 0
				this.SetDirty(true)
			}
			if this.curCompInfo.CompetitionId == CompetitionMag.curCompetitionId || this.curCompInfo.CompetitionId <= 0 {
				ssUpdateScoreMsg := &serverproto.SSCompetitionUpdateScoreReq{
					CompetitionId: CompetitionMag.curCompetitionId,
					Uid:           this.role.GetUUid(),
					Score:         this.curCompInfo.ComParam,
				}
				if compData.CompetitionType == int32(model.CompetitionType_Idol) {
					ssUpdateScoreMsg.FansUid = this.role.GetUUid()
				}
				this.role.SendRank(ssUpdateScoreMsg)
			}
		}
	}
}

func (this *RoleCompetition) OnlineGetCompetitionReward() {
	this.CompetitionRefresh()
	//第二赛季上交道具获得积分赛季，上线就进入排行榜
	this.UpdateRankByCompetitionScore(true)

	//处理玩家注册时所在的赛季，之前的赛季不做奖励处理
	if this.rewardCompetitionId <= 0 {
		this.rewardCompetitionId = CompetitionMag.GetCompetitionIdByTime(this.role.RegisterTime) + 1
	}

	//获取历史赛季奖励
	ssMsg := &serverproto.SSCompetitionRewardHistoryReq{
		SCompetitionId:    this.rewardCompetitionId,
		SCompetitionSubId: this.rewardCompetitionSubId,
	}
	if CompetitionMag.curCompetitionId != 0 {
		ssMsg.ECompetitionId = CompetitionMag.curCompetitionId
		ssMsg.ECompetitionSubId = CompetitionMag.curCompetitionSubId - 1
	} else {
		ssMsg.ECompetitionId = CompetitionMag.preCompetitionId

		compData, ok := model.ConvertCompTimeList[CompetitionMag.preCompetitionId]
		if !ok {
			//该错误发生在数据未初始化完成时玩家登陆和配置数据出错时
			//可以比较log时间和服务器启动时间
			util.ErrorF("uid=%v DoCompetitionNtf data not find!!!! id=%v", this.role.GetUUid(), CompetitionMag.preCompetitionId)
			return
		}
		ssMsg.ECompetitionSubId = int32(len(compData.PeriodEndTimeList))
	}

	//无赛季,或者赛季已经过了，上线领取奖励
	if (CompetitionMag.preCompetitionId >= int32(model.CompetitionType_Idol)) {
		if len(this.idolInfo.VoteData) > 0 {
			ssMsg := &serverproto.SSCompetitionFansGetAllRewardReq{
				CompetitionId:    int32(model.CompetitionType_Idol),
				CompetitionType:  int32(model.CompetitionType_Idol),
				CompetitionSubId: 3,
				IsFinish:         true,
			}

			fansData := &serverproto.FansVoteRewardData{
				Uid: this.role.GetUUid(),
			}
			for _, voteData := range this.idolInfo.VoteData {
				fansData.IdolList = append(fansData.IdolList, &serverproto.KeyValueType64{
					Key: voteData.Key,
				})
			}
			ssMsg.Data = append(ssMsg.Data, fansData)
			SendRankService(ssMsg)
		}
	}
	if ssMsg.SCompetitionId >= ssMsg.ECompetitionId && ssMsg.SCompetitionSubId >= ssMsg.ECompetitionSubId {
		return
	}
	this.role.SendRank(ssMsg)
}

func (this *RoleCompetition) GetCompetition(competitionId int32) serverproto.ErrorCode {
	reqCompetitionId := competitionId
	if reqCompetitionId <= 0 {
		if CompetitionMag.curCompetitionId != 0 {
			reqCompetitionId = CompetitionMag.curCompetitionId
		} else if CompetitionMag.preCompetitionId != 0 {
			reqCompetitionId = CompetitionMag.preCompetitionId
		}
	}

	compData, ok := model.ConvertCompTimeList[reqCompetitionId]
	if !ok && reqCompetitionId > 0 {
		return serverproto.ErrorCode_ERROR_COMPETITION_DATA_NOT_FOUND
	}
	//判断获取的赛季是否合法
	nowTime := util.GetCurrentTimeNow()
	if compData != nil && nowTime.Before(compData.CalBeginTime) {
		return serverproto.ErrorCode_ERROR_COMPETITION_NOT_OPEN
	}

	registerCompId := CompetitionMag.GetCompetitionIdByTime(this.role.RegisterTime)
	//无赛季数据
	if reqCompetitionId <= registerCompId {
		ntfMsg := &serverproto.SCCompetitionNtf{
			CompetitionData: &serverproto.CompetitionInfo{
				CompetitionId: reqCompetitionId,
				CurEndTime:    0,
			},
			NextCompetitionTime: 0,
		}
		if reqCompetitionId == CompetitionMag.preCompetitionId && CompetitionMag.curCompetitionId == 0 {
			ret, nextData, _ := CompetitionMag.getNexCompetitionTime()
			if ret {
				ntfMsg.NextCompetitionTime = uint64(nextData.CalBeginTime.UnixNano() / 1e6)
			}
		}

		this.role.ReplayGate(ntfMsg, true)
		//ack for client show
		ackMsg := &serverproto.SCCompetitionAck{
			Error:         int32(serverproto.ErrorCode_ERROR_OK),
			CompetitionId: reqCompetitionId,
		}
		this.role.ReplayGate(ackMsg, true)
		return serverproto.ErrorCode_ERROR_OK
	}

	if compData != nil {
		//对应赛季ID
		ssMsg := &serverproto.SSGetCompetitionDataReq{
			CompetitionId:   reqCompetitionId,
			CompetitionType: compData.CompetitionType,
			SubIdNum:        int32(len(compData.PeriodEndTimeList)),
		}
		if CompetitionMag.curCompetitionId == reqCompetitionId {
			ssMsg.IsNowCompetition = true
		}
		this.role.SendRank(ssMsg)
	}

	return serverproto.ErrorCode_ERROR_OK
}

//from rank
func (this *RoleCompetition) DoGetCompetitionNtf(ssAckMsg *serverproto.SSGetCompetitionDataAck) {
	competitionId := ssAckMsg.CompetitionData.CompetitionId
	compData, ok := model.ConvertCompTimeList[competitionId]
	if !ok {
		util.ErrorF("uid=%v DoCompetitionNtf data not find!!!! id=%v", this.role.GetUUid(), competitionId)
		return
	}
	convertData, ok := model.ConvertCompTypeList[competitionId]
	if !ok {
		util.ErrorF("DoGetCompetitionNtf comp data invalid err compId=%v", competitionId)
		return
	}

	ntfMsg := &serverproto.SCCompetitionNtf{
		CompetitionData: ssAckMsg.CompetitionData,
		Data:            ssAckMsg.IdolData,
		//RankList:        append(ssAckMsg.RankList),
	}
	if ssAckMsg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
		ntfMsg.CompetitionData.CurEndTime = uint64(compData.GetCalEndTime().UnixNano() / 1e6)
		if ssAckMsg.CompetitionData.CompetitionId == CompetitionMag.preCompetitionId {
			if CompetitionMag.curCompetitionId == 0 {
				ret, nextData, _ := CompetitionMag.getNexCompetitionTime()
				if ret {
					ntfMsg.NextCompetitionTime = uint64(nextData.CalBeginTime.UnixNano() / 1e6)
				}
			}
		}
		curFind := false
		//周期结算信息
		for idx := 0; idx < len(ssAckMsg.CompetitionData.RewardInfoList); idx++ {
			tmpRewardIdx := ssAckMsg.CompetitionData.RewardInfoList[idx].RewardIdx
			endTime := compData.PeriodEndTimeList[tmpRewardIdx-1].UnixNano() / 1e6
			ntfMsg.CompetitionData.RewardInfoList[idx].RewardEndTme = uint64(endTime)
			if tmpRewardIdx == CompetitionMag.curCompetitionSubId && CompetitionMag.curCompetitionSubId > 0 {
				curFind = true
			}
		}
		//当前周期数据
		if !curFind && CompetitionMag.curCompetitionSubId > 0 {
			curSubInfo := &serverproto.CompetitionRewardInfo{
				RewardIdx:    CompetitionMag.curCompetitionSubId,
				RewardEndTme: uint64(CompetitionMag.curComPeriodTimeList[CompetitionMag.curCompetitionSubId-1].UnixNano() / 1e6),
				ParamList:    []int32{ssAckMsg.CompetitionData.TotalRank},
			}
			//表示未参加
			if ssAckMsg.CompetitionData.SelfRank <= 0 {
				curSubInfo.ParamList = []int32{ssAckMsg.CompetitionData.TotalRank} //这是TotalRank返回的数值表示最后一档
			} else {
				_, _, sectionId := convertData.GetRankSection(int64(ssAckMsg.CompetitionData.SelfRank),
					int64(ssAckMsg.CompetitionData.TotalRank))
				curSubInfo.ParamList = []int32{sectionId}
			}
			ntfMsg.CompetitionData.RewardInfoList = append(ntfMsg.CompetitionData.RewardInfoList, curSubInfo)

			if ntfMsg.CompetitionData.CompetitionId == int32(model.CompetitionType_Idol) {
				if len(this.idolInfo.DayReward) > 0 {
				//	ntfMsg.Data.DayReward = this.idolInfo.DayReward
					ntfMsg.Data.DayReward = append(ntfMsg.Data.DayReward, this.idolInfo.DayReward[0:]...)
				}
				//打包领奖数据
				if len(model.GlobalCompetitionIdolDayReward) >= 2 {
					if this.idolInfo != nil {
						if this.idolInfo.FirstBegin == 0 || this.idolInfo.FirstEnd == 0 ||
							this.idolInfo.SecondBegin == 0 || this.idolInfo.SecondEnd == 0 {
							this.NeedResetIdolRewardTime()
						}

						ntfMsg.Data.FirstBegin = this.idolInfo.FirstBegin
						ntfMsg.Data.FirstEnd = this.idolInfo.FirstEnd

						ntfMsg.Data.SecondBegin = this.idolInfo.SecondBegin
						ntfMsg.Data.SecondEnd = this.idolInfo.SecondEnd
					}
				}
			}
		}
	} else {
		//表示非法数据
		//无赛季数据
		ntfMsg.CompetitionData.CurEndTime = 0
		ntfMsg.NextCompetitionTime = 0
	}
	if competitionId != int32(model.CompetitionType_Idol) {	//偶像季的赛季分数，是从Rank带过来的。
		ntfMsg.CompetitionData.ComParam = this.curCompInfo.ComParam
	}
	this.role.ReplayGate(ntfMsg, true)

	//ack for client show
	ackMsg := &serverproto.SCCompetitionAck{
		Error:         int32(ssAckMsg.Error),
		CompetitionId: ssAckMsg.CompetitionData.CompetitionId,
	}
	util.DebugF("uid=%v DoCompetitionNtf  ntfMsg=%v", this.role.GetUUid(), ntfMsg)
	this.role.ReplayGate(ackMsg, true)
}

func (this *RoleCompetition)NeedResetIdolRewardTime() {
	loc := util.GetLoc()
	nowTime := util.GetCurrentTimeNow()
	dayStartTimeStr := nowTime.Format(util.DATE_FORMAT1)
	startUpDayStr := util.GetDayByTimeStr1(dayStartTimeStr)

	//reqRewardStart 领奖开始时间，reqRewardEnd领奖结束时间
	begin1 := util.GetTimeByStr(startUpDayStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCompetitionIdolDayReward[1].StartTime)
	rewardStart1 := time.Unix(begin1.Unix(), 0).In(loc)
	end1 := util.GetTimeByStr(startUpDayStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCompetitionIdolDayReward[1].EndTime)
	rewardEnd1 := time.Unix(end1.Unix(), 0).In(loc)

	this.idolInfo.FirstBegin = uint64(rewardStart1.UnixNano() / 1e6)
	this.idolInfo.FirstEnd = uint64(rewardEnd1.UnixNano() / 1e6)

	begin2 := util.GetTimeByStr(startUpDayStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCompetitionIdolDayReward[2].StartTime)
	rewardStart2 := time.Unix(begin2.Unix(), 0).In(loc)
	end2 := util.GetTimeByStr(startUpDayStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCompetitionIdolDayReward[2].EndTime)
	rewardEnd2 := time.Unix(end2.Unix(), 0).In(loc)

	this.idolInfo.SecondBegin = uint64(rewardStart2.UnixNano() / 1e6)
	this.idolInfo.SecondEnd = uint64(rewardEnd2.UnixNano() / 1e6)

	this.SetDirty(true)
}


//from rank，获取赛季奖励ZhaoMu
func (this *RoleCompetition) DoCompetitionReward(CompetitionData *model.CompetitionTypeData, compSubId, sectionId int32) {
	//已经获取奖励
	if this.rewardCompetitionId > CompetitionData.CompetitionId {
		return
	}
	//发起多次领取奖励操作
	if this.rewardCompetitionId == CompetitionData.CompetitionId && this.rewardCompetitionSubId == compSubId {
		return
	}

	rewardDataList, ok := CompetitionData.ConditionList[sectionId]
	if !ok {
		util.ErrorF("uid=%v DoCompetitionReward invalid CompetitionId=%v sectionId=%v", this.role.GetUUid(),
			CompetitionData.CompetitionId, sectionId)
		return
	}
	if len(rewardDataList.ConditionList) > 0 {
		//对应周期奖励
		addItemList := rewardDataList.RewardList[int32(compSubId-1)]
		mailId := this.getMailConfigId(CompetitionData.CompetitionType)
		this.role.GetRoleMail().AddMail(mailId, serverproto.MailType_MailType_Competition,
			addItemList, []int32{sectionId}, "", "")
	}

	//第四赛季的占卜奖励发放//且最后一个阶段奖励发送完
	if CompetitionData.CompetitionId == int32(model.CompetitionType_ZhanBu) && compSubId == int32(len(rewardDataList.RewardList)) {
		this.SendDivineReward()
	}

	this.rewardCompetitionId = CompetitionData.CompetitionId
	this.rewardCompetitionSubId = compSubId
	this.SetDirty(true)
	util.InfoF("uid=%v DoCompetitionReward CompetitionId=%v sectionId=%v", this.role.GetUUid(),
		CompetitionData.CompetitionId, sectionId)
}

//from rank上线时一次性获取历史赛季奖励
func (this *RoleCompetition) DoCompetitionRewardHistory(rewardList []*serverproto.KeyValueTypeList,
	competitionId, competitionSubId int32) {
	for _, data := range rewardList {
		compId := data.Key
		if compId < this.rewardCompetitionId {
			continue
		}
		if this.rewardCompetitionId < compId {
			this.rewardCompetitionId = compId
			this.SetDirty(true)
		}
		if this.rewardCompetitionSubId < data.ValueList[0] {
			this.rewardCompetitionSubId = data.ValueList[0]
			this.SetDirty(true)
		}

		//获取奖励
		compData, ok := model.ConvertCompTypeList[compId]
		if !ok || len(data.ValueList) <= 0 {
			util.ErrorF("uid=%v DoCompetitionRewardHistory invalid compId=%v %v", this.role.GetUUid(), compId, data.ValueList)
			continue
		}

		//所在宝箱档位数据
		switch model.CompetitionType(compData.CompetitionType) {
		case model.CompetitionType_ZhaoMu:
			sectionId := data.ValueList[1]
			sectionRewardData, ok1 := compData.ConditionList[sectionId]
			if !ok1 {
				continue
			}
			if len(sectionRewardData.ConditionList) > 0 {
				//对应周期奖励
				addItemList := sectionRewardData.RewardList[data.ValueList[0]-1]
				this.role.GetRoleMail().AddMail(this.getMailConfigId(compData.CompetitionType), serverproto.MailType_MailType_Competition,
					addItemList, []int32{sectionId}, "", "")
			}
		case model.CompetitionType_XuanBa:
			fallthrough
		case model.CompetitionType_DuoBao:
			fallthrough
		case model.CompetitionType_Idol:
			fallthrough
		case model.CompetitionType_ZhanBu:
			sectionId := data.ValueList[1]
			sectionRewardData, ok1 := compData.ConditionList[sectionId]
			if !ok1 {
				continue
			}
			if len(sectionRewardData.ConditionList) > 0 {
				//对应周期奖励
				addItemList := sectionRewardData.RewardList[data.ValueList[0]-1]
				this.role.GetRoleMail().AddMail(this.getMailConfigId(compData.CompetitionType), serverproto.MailType_MailType_Competition,
					addItemList, []int32{sectionId}, "", "")
			}

			//第四赛季的占卜奖励发放
			if competitionId == int32(model.CompetitionType_ZhanBu) && competitionSubId == int32(len(sectionRewardData.RewardList)) {
				this.SendDivineReward()
			}
		}
	}


	if competitionId >= 0 {
		this.rewardCompetitionId = competitionId
	}
	if competitionSubId >= 0 {
		this.rewardCompetitionSubId = competitionSubId
	}

	util.InfoF("uid=%v DoCompetitionRewardHistory rewardCompetitionId=%v rewardCompetitionSubId=%v",
		this.role.GetUUid(), this.rewardCompetitionId, this.rewardCompetitionSubId)
}

//检查是否在对应的赛季内
func (this *RoleCompetition)CheckInCompetitionSeason(competitionId int32) (int32, int32) {
	if !CompetitionMag.IsCompetitionOnline() {
		return Shop_Time_Not_Ready_To_Show, 0
	}

	if this.curCompInfo.CompetitionId < competitionId {	//未到开始赛季
		return Shop_Time_Not_Ready_To_Show, 0
	} else if this.curCompInfo.CompetitionId > competitionId {	//当前赛季已过
		return Shop_Time_Out_Of_Date, 0
	}

	return Shop_Time_Show, competitionId
}

//选拔季积分添加
func (this *RoleCompetition) CompetitionAddScore(itemList []*serverproto.KeyValueType) serverproto.ErrorCode {
	if !CompetitionMag.IsCompetitionOnline() {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	compData, ok := model.ConvertCompTimeList[CompetitionMag.curCompetitionId]
	if !ok {
		util.ErrorF("uid=%v CompetitionAddScore data not find!!!! id=%v", this.role.GetUUid(), CompetitionMag.curCompetitionId)
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if compData.CompetitionType != int32(model.CompetitionType_XuanBa) {
		util.ErrorF("uid=%v CompetitionAddScore curr compType invalid id=%v", this.role.GetUUid(), CompetitionMag.curCompetitionId)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//相同赛季类型，不同赛季
	if this.curCompInfo.ComParamAddTime > 0 {
		tmpCompId := CompetitionMag.GetCompetitionIdByTime(this.curCompInfo.ComParamAddTime) + 1
		if tmpCompId != CompetitionMag.curCompetitionId ||
			this.curCompInfo.CompetitionId != CompetitionMag.curCompetitionId {
			this.curCompInfo.ComParam = 0
		}
	}

	rand.Seed(int64(util.GetTimeMilliseconds()))
	var addScore int32 = 0
	//特殊道具系统消息通知得分处理
	var systemMessageScore int32 = 0
	for idx := 0; idx < len(itemList); idx++ {
		if itemList[idx].Value <= 0 {
			continue
		}
		itemNum := this.role.GetItemNum(itemList[idx].Key)
		if itemNum >= uint32(itemList[idx].Value) {
			itemNum = uint32(itemList[idx].Value)
		}
		itemData, ok := model.GlobalCompetitionScoreItem[itemList[idx].Key]
		if !ok {
			continue
		}
		this.role.DelItem(itemList[idx].Key, int32(itemNum), AddItemST{AddFrom: AddFrom_Competition})
		//random score
		if itemData.Value > 0 {
			for k := 0; k < int(itemNum); k++ {
				tmpScore := this.getSpecialItemScore()
				addScore += tmpScore
				systemMessageScore += tmpScore
			}
		} else {
			addScore += itemData.Key * int32(itemNum)
		}
	}

	this.curCompInfo.ComParam += addScore
	this.curCompInfo.ComParamAddTime = util.GetTimeMilliseconds()
	this.SetDirty(true)

	util.InfoF("uid=%v CompetitionAddScore score=%v addScore=%v", this.role.GetUUid(), this.curCompInfo.ComParam, addScore)

	this.UpdateRankByCompetitionScore(false)

	if systemMessageScore > 0 {
		this.role.AddSystemMessage(SystemMessageType_Competition, AddSystemMsg{ParamId: systemMessageScore})
	}
	return serverproto.ErrorCode_ERROR_OK
}

//夺宝季积分添加
func (this *RoleCompetition) CompetitionAddScoreDuoBao(addScore int32) serverproto.ErrorCode {
	compData, ok := model.ConvertCompTimeList[CompetitionMag.curCompetitionId]
	if !ok {
		util.ErrorF("uid=%v CompetitionAddScoreDuoBao data not find!!!! curCompetitionId=%v",
			this.role.GetUUid(), CompetitionMag.curCompetitionId)
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if compData.CompetitionType != int32(model.CompetitionType_DuoBao) &&
		compData.CompetitionType != int32(model.CompetitionType_ZhanBu) &&
		compData.CompetitionType != int32(model.CompetitionType_Idol) {
		util.ErrorF("uid=%v CompetitionAddScore curr compType invalid curCompetitionId=%v compType=%v",
			this.role.GetUUid(), CompetitionMag.curCompetitionId, compData.CompetitionType)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//相同赛季类型，不同赛季
	if this.curCompInfo.ComParamAddTime > 0 {
		tmpCompId := CompetitionMag.GetCompetitionIdByTime(this.curCompInfo.ComParamAddTime) + 1
		if tmpCompId != CompetitionMag.curCompetitionId ||
			this.curCompInfo.CompetitionId != CompetitionMag.curCompetitionId {
			this.curCompInfo.ComParam = 0
		}
	}

	this.curCompInfo.ComParam += addScore
	this.curCompInfo.ComParamAddTime = util.GetTimeMilliseconds()
	this.SetDirty(true)

	util.InfoF("uid=%v CompetitionAddScoreDuoBao addscore=%v", this.role.GetUUid(), this.curCompInfo.ComParam)

	this.UpdateRankByCompetitionScore(false)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCompetition) DoUpdateScoreNtf(msg *serverproto.SSCompetitionUpdateScoreAck) {
	if this.curCompInfo.ComParam > 0 {
		ackMsg := &serverproto.SCCompetitionScoreAck{
			Error:        int32(serverproto.ErrorCode_ERROR_OK),
			ComScore:     this.curCompInfo.ComParam,
			NextComScore: msg.NextComScore,
			SelfRank:     msg.SelfRank,
			TotalRank:    msg.TotalRank,
			SectionId:    msg.SectionId,
			LastComScore: msg.LastComScore,
		}
		this.role.ReplayGate(ackMsg, true)
	}
}

func (this *RoleCompetition) getMailConfigId(compType int32) int32 {
	switch model.CompetitionType(compType) {
	case model.CompetitionType_ZhaoMu:
		return 20001
	case model.CompetitionType_XuanBa:
		return 20002
	case model.CompetitionType_DuoBao:
		return 20003
	case model.CompetitionType_ZhanBu:
		return 20004
	case model.CompetitionType_Idol:
		return 20005
	}
	return 0
}

func (this *RoleCompetition) getSpecialItemScore() int32 {
	tmpLen := len(model.GlobalCompetitionScoreItemFactor)
	randVal := rand.Int31n(model.GlobalCompetitionScoreItemFactor[tmpLen-1].Key) + 1

	tmpIdx := 0
	for idx := 0; idx < len(model.GlobalCompetitionScoreItemFactor); idx++ {
		tmpIdx = idx
		if model.GlobalCompetitionScoreItemFactor[idx].Key >= randVal {
			break
		}
	}

	left := model.GlobalCompetitionScoreItemFactor[tmpIdx].ValueList[0]
	right := model.GlobalCompetitionScoreItemFactor[tmpIdx].ValueList[1]
	return left + rand.Int31n(right-left) + 1
}

//==========================================  占卜季  开始 ==========================================
//占星数据请求
func (this *RoleCompetition) GetDivineInfo(ackMsg *serverproto.SCCompetitionStarInfoAck) {
	if this.divineInfo == nil || ackMsg == nil {
		return
	}
	ackMsg.Stars = this.divineInfo.CurStars
}

//占星请求
func (this *RoleCompetition) OnStarDivine(useTicket bool, ackMsg *serverproto.SCCompetitionStarDivineAck) serverproto.ErrorCode {
	if this.divineInfo == nil || ackMsg == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	//全部点亮，退出
	starCount := len(this.divineInfo.CurStars)
	if starCount >= 12 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	//配置都没找到，瞎扯淡了。
	cfgData, ok := model.ConvertCompetitionDevine[int32(starCount)]
	if !ok {
		//日志
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//计算消耗
	var costItemList = map[int32]int32{}
	if this.role.CheckResLitNum(cfgData.ItemCost) {
		for key, value := range cfgData.ItemCost {
			costItemList[key] = value
		}
	} else if this.role.CheckResLitNum(cfgData.GoldCost) {
		for key, value := range cfgData.GoldCost {
			costItemList[key] = value
		}
	} else {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//计算概率//幸运券逻辑
	useProbability := cfgData.NormalRate
	ticketCount := int32(0)
	if useTicket == true {
		if cfgData.LuckyTicket == 0 {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		ticketCount = int32(this.role.GetResNum(cfgData.LuckyTicket))
		if ticketCount < cfgData.TicketCount {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		useProbability = 10000
		ticketCount = cfgData.TicketCount
		this.divineInfo.FailedCount = 0
	}
	if ticketCount != 0 {
		costItemList[cfgData.LuckyTicket] += cfgData.TicketCount
	}

	if useTicket == false {
		if this.divineInfo.FailedCount >= 2 {
			useProbability = cfgData.SpecialRate
		}
	}

	//抽取逻辑
	//计算是否成功
	success := false
	if useProbability == 10000 {
		success = true
	} else {
		randNum := rand.Int31n(10000)
		if randNum+1 <= useProbability {
			success = true
		}
	}

	//创建抽取池//成功，从未抽取库中抽取//失败，从现有库中抽取
	var starPool []int32
	 if success == true {
		 for i := 1; i <= 12; i++ {
		 	bFind := false
		 	for _, star := range this.divineInfo.CurStars {
		 		if star == int32(i) {
		 			bFind = true
				}
			}
		 	if bFind == true {
		 		continue
			}
			 starPool = append(starPool, int32(i))
		 }
		 this.divineInfo.FailedCount = 0
	 } else {
		 for _, star := range this.divineInfo.CurStars {
			 starPool = append(starPool, star)
		 }
		 this.divineInfo.FailedCount++
	 }

	//捕获异常
	if starPool == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	newStarCount := len(starPool)
	if newStarCount <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	startId := int32(0)
	poolIndex := rand.Int31n(int32(newStarCount))
	if poolIndex < int32(newStarCount) {
		startId = starPool[poolIndex]
	}
	if 1 <= startId && startId <= 12 {
		//扣除道具，
		this.role.DelItemList(costItemList, AddItemST{AddFrom: AddFrom_Divine})

		//进行抽取操作。
		if success == true {
			this.divineInfo.CurStars = append(this.divineInfo.CurStars, startId)
			ackMsg.Light = true
		} else {
			for i := 0; i < len(this.divineInfo.CurStars); i++ {
				if this.divineInfo.CurStars[i] == startId {
					this.divineInfo.CurStars = append(this.divineInfo.CurStars[:i], this.divineInfo.CurStars[i+1:]...)
				}
			}
			ackMsg.Light = false
		}
	}

	//赛季增加积分。
	this.role.GetRoleCompetition().CompetitionAddScoreDuoBao(cfgData.ScorePoint)
	//增加积分
	this.SetDirty(true)

	ackMsg.Star = startId
	ackMsg.Stars = this.divineInfo.CurStars
	return serverproto.ErrorCode_ERROR_OK
}

//
func (this *RoleCompetition) GetDivineReward(ackMsg *serverproto.SCCompetitionStarCloseRewardAck) serverproto.ErrorCode {
	if this.divineInfo == nil || ackMsg == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	starCount := len(this.divineInfo.CurStars)
	if starCount <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	cfgData, ok := model.ConvertCompetitionDevine[int32(starCount)]
	if !ok {
		//日志
		util.ErrorF("uid=%v SendDivineReward send divine reward config not found starCount=%v ", starCount)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	if len(cfgData.RewardList) > 0 {
		this.role.AddItemList(cfgData.RewardList, AddFrom_DrawCard, true)
	} else {
		//日志
		util.ErrorF("uid=%v SendDivineReward send divine reward empty starCount=%v ", starCount)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	this.divineInfo.CurStars = []int32{}
	this.divineInfo.FailedCount = 0
	this.SetDirty(true)

	ackMsg.Stars = this.divineInfo.CurStars
	for key, value := range cfgData.RewardList {
		ackMsg.RewardList = append(ackMsg.RewardList, &serverproto.KeyValueType{
			Key:   key,
			Value: value,
		})
	}

	//播报
	if cfgData.BroadCast == 1 {
		this.role.AddSystemMessage(SystemmessageType_Divine,
			AddSystemMsg{ParamId: int32(starCount)})
	}
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCompetition) SendDivineReward() {
	if this.divineInfo == nil {
		return
	}
	starCount := int32(len(this.divineInfo.CurStars))
	if starCount <= 0 {
		return
	}

	cfgData, ok := model.ConvertCompetitionDevine[starCount]
	if !ok {
		//日志
		util.ErrorF("uid=%v SendDivineReward send divine reward config not found starCount=%v ", starCount)
		return
	}

	if len(cfgData.RewardList) <= 0 {
		//日志
		util.ErrorF("uid=%v SendDivineReward send divine reward empty starCount=%v ", starCount)
		return
	}

	this.divineInfo.CurStars = []int32{}
	this.divineInfo.FailedCount = 0

	if len(cfgData.RewardList) > 0 {
		this.role.GetRoleMail().AddMail(model.GloablMailDivineReward, serverproto.MailType_MailType_Competition,
			cfgData.RewardList, []int32{int32(model.CompetitionType_ZhanBu)}, "", "")
	}

	this.SetDirty(true)
	return
}

//==========================================  占卜季  结束 ==========================================

//==========================================  偶像季  开始 ==========================================

//上交道具获得积分
func (this *RoleCompetition) UpdateIdolRankByCompetitionScore(score int32, curScore int32, idolUid uint64) {
	if CompetitionMag.IsCompetitionOnline() {
		compData, ok := model.ConvertCompTimeList[CompetitionMag.curCompetitionId]
		if !ok {
			util.ErrorF("uid=%v UpdateIdolRankByCompetitionScore data not find!!!! id=%v", this.role.GetUUid(), CompetitionMag.curCompetitionId)
			return
		}
		//第二赛季上交道具获得积分赛季，上线就进入排行榜
		if 	compData.CompetitionType == int32(model.CompetitionType_Idol) {
			//上线更新的方式，积分必须为0
			if this.curCompInfo.CompetitionId != CompetitionMag.curCompetitionId {
				this.curCompInfo.ComParam = 0
				this.SetDirty(true)
			}
			if this.curCompInfo.CompetitionId == CompetitionMag.curCompetitionId || this.curCompInfo.CompetitionId <= 0 {
				ssUpdateScoreMsg := &serverproto.SSCompetitionUpdateScoreReq{
					CompetitionId: CompetitionMag.curCompetitionId,
					Uid:           idolUid,
					Score:         score,
					FansUid:       this.role.GetUUid(),
					CurVoteScore:  curScore,
				}
				this.role.SendRank(ssUpdateScoreMsg)
			}
		}
	}
}

//赛季给别人加分
func (this *RoleCompetition) CompetitionAddScoreIdol(addScore int32, curScore int32, idolUid uint64) serverproto.ErrorCode {
	compData, ok := model.ConvertCompTimeList[CompetitionMag.curCompetitionId]
	if !ok {
		util.ErrorF("uid=%v CompetitionAddScoreDuoBao data not find!!!! curCompetitionId=%v",
			this.role.GetUUid(), CompetitionMag.curCompetitionId)
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if 	compData.CompetitionType != int32(model.CompetitionType_Idol) {
		util.ErrorF("uid=%v CompetitionAddScore curr compType invalid curCompetitionId=%v compType=%v",
			this.role.GetUUid(), CompetitionMag.curCompetitionId, compData.CompetitionType)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//相同赛季类型，不同赛季
	if this.curCompInfo.ComParamAddTime > 0 {
		tmpCompId := CompetitionMag.GetCompetitionIdByTime(this.curCompInfo.ComParamAddTime) + 1
		if tmpCompId != CompetitionMag.curCompetitionId ||
			this.curCompInfo.CompetitionId != CompetitionMag.curCompetitionId {
			this.curCompInfo.ComParam = 0
		}
	}
	this.curCompInfo.ComParamAddTime = util.GetTimeMilliseconds()
	this.SetDirty(true)

	util.InfoF("uid=%v CompetitionAddScoreDuoBao addscore=%v", this.role.GetUUid(), this.curCompInfo.ComParam)

	this.UpdateIdolRankByCompetitionScore(addScore, curScore, idolUid)

	return serverproto.ErrorCode_ERROR_OK
}

const VoteItemId = 238
func (this *RoleCompetition) VoteIdol(uid uint64, ticketCount int32, needItem bool) (serverproto.ErrorCode) {
	if ticketCount <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if this.idolInfo == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	if CompetitionMag.curCompetitionId != int32(model.CompetitionType_Idol) {
		return serverproto.ErrorCode_ERROR_ARENA_NOT_IN_SEASON
	}
	//道具是否够
	costItemList := map[int32]int32{}
	if needItem == true {
		costItemList[VoteItemId] = ticketCount
		if this.role.CheckResLitNum(costItemList) == false {
			util.DebugF("uid=%v build_guild error resource not enough!! costItemList=%v", this.role.GetUUid(), costItemList)
			return serverproto.ErrorCode_ERROR_FAIL
		}
	}
	
	totalTicket := ticketCount
	//是否在赛季内，
	bFind := false
	if len(this.idolInfo.VoteData) > 0 {
		for _, data := range this.idolInfo.VoteData {
			if data.Key == uid {
				data.Value += ticketCount
				totalTicket = data.Value
				bFind = true
				break
			}
		}
	}
	if bFind == false {
		this.idolInfo.VoteData = append(this.idolInfo.VoteData, &serverproto.KeyValueType64{
			Key:   uid,
			Value: ticketCount,
		})
	}

	bRet := this.CompetitionAddScoreIdol(totalTicket, ticketCount, uid)
	if bRet != serverproto.ErrorCode_ERROR_OK {
		return bRet
	}

	if needItem == true {
		this.role.DelItemList(costItemList, AddItemST{AddFrom: AddFrom_IdolSeason})
	}

	this.SetDirty(true)
	util.InfoF("uid=%v VoteIdol, totalTicket:%v, ticketCount:%v", this.role.GetUUid(), totalTicket, ticketCount)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCompetition)CheckInIdolSeason() (serverproto.ErrorCode, int32) {
	bRet, competitionId := this.CheckInCompetitionSeason(int32(model.CompetitionType_Idol))
	if bRet == Shop_Time_Show {
		return serverproto.ErrorCode_ERROR_OK, competitionId
	}
	return serverproto.ErrorCode_ERROR_FAIL, 01
}

func (this *RoleCompetition)GetSelfVoteData(ackMsg *serverproto.SCCompetitionFansRewardRankAck) {
	if ackMsg == nil || this.idolInfo == nil {
		return
	}
	ackMsg.RewardData = this.idolInfo.VoteData
}

//简单校验是否透过这个人
func (this *RoleCompetition)CheckFansReward(uid uint64, rewardLevel int32) serverproto.ErrorCode {
	if this.idolInfo == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if uid == this.role.GetUUid() {
		return serverproto.ErrorCode_ERROR_OK
	}

	bFind := false
	for _, data := range this.idolInfo.VoteData {
		if data.Key != uid {
			continue
		}
		bFind = true
		break
	}

	if bFind == false {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	return serverproto.ErrorCode_ERROR_OK
}

//uid 爱豆UID ， rewardLevel 领取的奖励等级，boxScore 爱豆的宝箱分数
func (this *RoleCompetition)GetFansReward(idolUid uint64, boxScore int32, needAdd bool, itemList map[int32]int32) (serverproto.ErrorCode, int32) {
	if this.idolInfo == nil {
		return serverproto.ErrorCode_ERROR_FAIL, 0
	}

	bFind := false
	rewardFlag := int32(0)
	for _, data := range this.idolInfo.VoteData {
		if data.Key != idolUid {
			continue
		}
		bFind = true

		addItemList := map[int32]int32{}
		//从第一档开始

		for i:=int32(1); i <= int32(len(model.ConvertIdolBoxData)); i++ {
			_, ok := model.ConvertIdolBoxData[i]
			if !ok {
				continue
			}
			//判定分数是否够
			if boxScore < model.ConvertIdolBoxData[i].BoxCount {
				break
			}
			//判定领取非自己的粉丝馈赠，票数是否够
			if idolUid != this.role.GetUUid() && data.Value < model.ConvertIdolBoxData[i].TicketCount {
				continue
			}

			//检查这个奖励是否领取过//防止game-rank卡顿，多条从rank返回的领取包，刷奖励。所以给奖励还要判定一下
			if (data.Value2 & (1 << uint32(i-1))) != 0 {
				continue
			}
			//记录领奖标示
			data.Value2  |= 1 << uint32(i-1)

			//打包数据
			for _, reward := range model.ConvertIdolBoxData[i].Reward {
				itemList[reward.Key] += reward.Value

				if needAdd == true {
					addItemList[reward.Key] += reward.Value
				}
			}
		}

		if needAdd == true && len(addItemList) > 0 {
			this.role.AddItemList(addItemList, AddFrom_IdolSeason, true)
		}
		rewardFlag = data.Value2
		break
	}

	if bFind == false {
		return serverproto.ErrorCode_ERROR_FAIL, 0
	}

	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK, rewardFlag
}

func (this *RoleCompetition)GetAllFansReward(idol_list []*serverproto.KeyValueType64) {
	if this.idolInfo == nil || len(this.idolInfo.VoteData) <= 0 {
		return
	}

	addItemList := map[int32]int32{}
	for _, data := range idol_list {
		util.DebugF("uid=%v GetAllFansReward addItemList:%v", this.role.GetUUid(), addItemList)

		this.GetFansReward(data.Key, data.Value, false, addItemList)
	}
	this.idolInfo.VoteData = this.idolInfo.VoteData[0:0]
	this.SetDirty(true)
	util.DebugF("uid=%v GetAllFansReward final addItemList:%v", this.role.GetUUid(), addItemList)
	if len(addItemList) > 0 {
		this.role.GetRoleMail().AddMail(model.GloablMailIdolFansReward, serverproto.MailType_MailType_Idol,
			addItemList, []int32{int32(model.CompetitionType_Idol)}, "", "")
	}
}

func (this *RoleCompetition)GetIdolDayReward(id int32) serverproto.ErrorCode {
	if this.role.GetRoleBase().GetRoleLevel() < model.GlobalCompetitonDayRewardLevel {
		return serverproto.ErrorCode_ERROR_USEITEM_ROLE_LEVEL_NOT_ENOUGH
	}
	rewardData, ok:= model.GlobalCompetitionIdolDayReward[id]
	if !ok {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//判定是否在时间内
	curTime := util.GetCurrentTime()

	loc := util.GetLoc()
	nowTime := util.GetCurrentTimeNow()
	dayStartTimeStr := nowTime.Format(util.DATE_FORMAT1)
	startUpDayStr := util.GetDayByTimeStr1(dayStartTimeStr)

	//reqRewardStart 领奖开始时间，reqRewardEnd领奖结束时间
	reqBegin := util.GetTimeByStr(startUpDayStr.Format(util.DATE_FORMAT1) + " " + rewardData.StartTime)
	reqRewardStart := time.Unix(reqBegin.Unix(), 0).In(loc)
	reqEnd := util.GetTimeByStr(startUpDayStr.Format(util.DATE_FORMAT1) + " " + rewardData.EndTime)
	reqRewardEnd := time.Unix(reqEnd.Unix(), 0).In(loc)

	startTime := uint64(reqRewardStart.UnixNano() / 1e6)
	endTime := uint64(reqRewardEnd.UnixNano() / 1e6)

	if curTime < startTime || endTime < curTime {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//判定是否领取过
	for _, reward := range this.idolInfo.DayReward {
		if reward == id {
			return serverproto.ErrorCode_ERROR_FAIL
		}
	}
	//给道具
	addItemList := map[int32]int32{}
	addItemList[rewardData.ItemId] = rewardData.ItemCount
	this.role.AddItemList(addItemList, AddFrom_IdolSeason, true)

	//打标记
	this.idolInfo.DayReward = append(this.idolInfo.DayReward, id)
	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCompetition)GetRewardDate(ackMsg *serverproto.SCCompetitionOnVoteAck) {
	if ackMsg == nil {
		return
	}
	ackMsg.RewardData = this.idolInfo.VoteData
}

func (this *RoleCompetition)AddSeasonBoxScore(score int32, broadCast bool) {
	if this.idolInfo == nil {
		util.InfoF("uid=%v AddSeasonBoxScore this.idolInfo is nil", this.role.GetUUid())
		return
	}
	//非第五赛季
	if CompetitionMag.curCompetitionId != int32(model.CompetitionType_Idol) {
		return
	}
	bFind := false
	myUid := uint64(this.role.GetUUid())
	for _, data := range this.idolInfo.VoteData {
		if data.Key == myUid {
			bFind = true
			break
		}
	}
	if bFind == false {
		this.idolInfo.VoteData = append(this.idolInfo.VoteData, &serverproto.KeyValueType64{
			Key:   myUid,
			Value: 0,
		})
		this.SetDirty(true)
	}
	this.idolInfo.BoxScore += score
	ntfMsg := &serverproto.SSCompetitionAddIdolBoxScoreNtf{
		Uid:           this.role.GetUUid(),
		Score:         this.idolInfo.BoxScore,
		CompetitionId: int32(model.CompetitionType_Idol),
	}
	this.role.SendRank(ntfMsg)

	//播报
	if broadCast {
		this.role.AddSystemMessage(SystemmessageType_Idol, AddSystemMsg{})
	}
}

const (
	IdolSeason_Box = 243		//箱子补偿道具ID
	IdolSeason_Ticket = 244		//票数补偿道具ID
)
func (this *RoleCompetition)UseIdolSeasonItem(itemId int32, count int32) {
	if itemId == IdolSeason_Ticket {
		this.role.GetRoleCompetition().VoteIdol(this.role.GetUUid(), count, false)
	} else if itemId == IdolSeason_Box {
		this.role.GetRoleCompetition().AddSeasonBoxScore(count, false)
	}
}
//==========================================  偶像季  结束 ==========================================