RoServer/RO_Server_Trunk-branch_0.1.39/roserver/game/model/competition_manager.go

package model

//赛季玩法，骑士团
import (
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"time"
)

type CompetitionSeasonManager struct {
	updateTimer util.ServerTimer //更新定时器
	initStartUp bool

	initSendFromDB        bool
	initRecvFromDB        bool
	initSendFromDBTime    uint64
	serverCompetitionData []*serverproto.ServerCompetitionInfo

	preCompetitionId, curCompetitionId int32 //当前赛季和下一赛季
	curComStartTime, curComEndTime     time.Time
	curComPeriodTimeList               []time.Time //周期结算赛季时间
	curCompetitionSubId                int32
}

func newCompetitionSeasonManager() *CompetitionSeasonManager {
	mag := &CompetitionSeasonManager{
		initStartUp:    false,
		initSendFromDB: false,
		initRecvFromDB: false,
	}
	mag.updateTimer = util.NewDurationTimer(util.GetCurrentTime(), 5000)
	return mag
}

//根据开服时间计算开启和结束时间，重置开服时间需要重新初始化(重新启动服务器)
func (this *CompetitionSeasonManager) initConvertCompetitionTime(startUptime uint64, nowTime uint64) {
	loc := util.GetLoc()
	//初始化当前属于第几赛季
	startUpTimeStr := time.Unix(int64(startUptime/1000), 0).In(loc).Format(util.DATE_FORMAT1)
	startUpDayTime := util.GetDayByTimeStr1(startUpTimeStr)
	//util.InfoF("startUpDayTime=%v", startUpDayTime)

	tempSTime := startUpDayTime
	//for _, data := range model.ConvertCompTimeIdList {
	//	tempSTime1 := util.GetTimeByStr(tempSTime.Format(util.DATE_FORMAT1) + " " + data.BeginTimeStr)
	//	tempETime1 := time.Unix(tempSTime.Unix()+int64(data.Duration-1)*DaySec, 0).In(loc)
	//	tempETime1 = util.GetTimeByStr(tempETime1.Format(util.DATE_FORMAT1) + " " + data.EndTimeStr)
	//	util.DebugF("%v | %v", tempSTime1, tempETime1)
	//
	//	data.CalBeginTime = tempSTime1
	//	data.CalEndTime = tempETime1
	//
	//	for idx := 0; idx < len(data.PeriodEndStrList); idx++ {
	//		periodDay := data.PeriodEndStrList[idx]
	//		tempETime1 = time.Unix(tempSTime.Unix()+int64(periodDay-1)*DaySec, 0).In(loc)
	//		tempETime1 = util.GetTimeByStr(tempETime1.Format(util.DATE_FORMAT1) + " " + data.EndTimeStr)
	//		util.DebugF("rewardidx=%v", tempETime1)
	//		data.PeriodEndTimeList = append(data.PeriodEndTimeList, tempETime1)
	//	}
	//
	//	tempSTime = time.Unix(tempSTime.Unix()+int64(data.Duration+data.ResetTime)*DaySec, 0).In(loc)
	//}

	nowTimeDate := util.GetTimeByUint64(nowTime)
	//下一个赛季根据上一个赛季的开启时间来决定（服务器开启时本赛季已经开启但是服务器赛季数
	// 据中没有开启记录,则以当前时间作为本赛季的开启时间）
	var serverCompID int32 = 0
	for idx := 0; idx < len(this.serverCompetitionData); idx++ {
		if this.serverCompetitionData[idx].CompetitionId > serverCompID {
			serverCompID = this.serverCompetitionData[idx].CompetitionId
		}
	}
	tmpStartUpDayTime := util.GetDayByTimeStr1(nowTimeDate.Format(util.DATE_FORMAT1))
	tempSTime = tmpStartUpDayTime
	for _, data := range model.ConvertCompTimeIdList {
		if data.CompetitionId <= serverCompID {
			for idx := 0; idx < len(this.serverCompetitionData); idx++ {
				if this.serverCompetitionData[idx].CompetitionId == data.CompetitionId {
					data.CalBeginTime = util.GetTimeByUint64(this.serverCompetitionData[idx].StartTime)
					data.CalEndTime = util.GetTimeByUint64(this.serverCompetitionData[idx].EndTime)
					util.DebugF("comid=%v %v | %v", data.CompetitionId, data.CalBeginTime, data.CalEndTime)

					tmpStartUpTimeStr := data.CalBeginTime.Format(util.DATE_FORMAT1)
					tmpStartUpDayTime = util.GetDayByTimeStr1(tmpStartUpTimeStr)
					tempSTime = tmpStartUpDayTime
					for k := 0; k < len(data.PeriodEndStrList); k++ {
						periodDay := data.PeriodEndStrList[k]
						tempETime1 := time.Unix(tempSTime.Unix()+int64(periodDay-1)*DaySec, 0).In(loc)
						tempETime1 = util.GetTimeByStr(tempETime1.Format(util.DATE_FORMAT1) + " " + data.EndTimeStr)
						util.DebugF("rewardidx=%v", tempETime1)
						data.PeriodEndTimeList = append(data.PeriodEndTimeList, tempETime1)
					}
					tempSTime = time.Unix(tempSTime.Unix()+int64(data.Duration+data.ResetTime)*DaySec, 0).In(loc)
					break
				}
			}
		} else {
			tempSTime1 := util.GetTimeByStr(tempSTime.Format(util.DATE_FORMAT1) + " " + data.BeginTimeStr)
			tempETime1 := time.Unix(tempSTime.Unix()+int64(data.Duration-1)*DaySec, 0).In(loc)
			tempETime1 = util.GetTimeByStr(tempETime1.Format(util.DATE_FORMAT1) + " " + data.EndTimeStr)
			util.DebugF("comid=%v %v | %v", data.CompetitionId, tempSTime1, tempETime1)
			//判断根据上个赛季的开始时间当前赛季是否已经开启，如果已经开启则设置当前赛季的
			// 开启时间为当前服务器时间,否则使用上个赛季的开启时间
			if nowTimeDate.After(tempSTime1) || nowTimeDate.Equal(tempSTime1) {
				tmpStartUpDayTime = util.GetDayByTimeStr1(nowTimeDate.Format(util.DATE_FORMAT1))
				tempSTime = tmpStartUpDayTime
			}

			tempSTime1 = util.GetTimeByStr(tempSTime.Format(util.DATE_FORMAT1) + " " + data.BeginTimeStr)
			tempETime1 = time.Unix(tempSTime.Unix()+int64(data.Duration-1)*DaySec, 0).In(loc)
			tempETime1 = util.GetTimeByStr(tempETime1.Format(util.DATE_FORMAT1) + " " + data.EndTimeStr)
			util.DebugF("comid=%v %v | %v", data.CompetitionId, tempSTime1, tempETime1)
			data.CalBeginTime = tempSTime1
			data.CalEndTime = tempETime1

			for idx := 0; idx < len(data.PeriodEndStrList); idx++ {
				periodDay := data.PeriodEndStrList[idx]
				tempETime1 = time.Unix(tempSTime.Unix()+int64(periodDay-1)*DaySec, 0).In(loc)
				tempETime1 = util.GetTimeByStr(tempETime1.Format(util.DATE_FORMAT1) + " " + data.EndTimeStr)
				util.DebugF("rewardidx=%v", tempETime1)
				data.PeriodEndTimeList = append(data.PeriodEndTimeList, tempETime1)
			}
			tempSTime = time.Unix(tempSTime.Unix()+int64(data.Duration+data.ResetTime)*DaySec, 0).In(loc)
		}
	}
}

func (this *CompetitionSeasonManager) init(ms, startUptime uint64) {
	if this.initStartUp {
		return
	}
	this.initStartUp = true

	//init competition by ServiceStartupTime
	this.initConvertCompetitionTime(startUptime, ms)

	//初始化当前属于第几赛季
	nowTimeDate := util.GetTimeByUint64(ms)
	for _, data := range model.ConvertCompTimeIdList {
		if (nowTimeDate.After(data.CalBeginTime) || nowTimeDate.Equal(data.CalBeginTime)) &&
			(nowTimeDate.Before(data.CalEndTime) || nowTimeDate.Equal(data.CalEndTime)) {
			this.curCompetitionId = data.CompetitionId

			this.curComStartTime = data.CalBeginTime
			this.curComEndTime = data.CalEndTime
			this.curComPeriodTimeList = data.PeriodEndTimeList

			for idx := 0; idx < len(this.curComPeriodTimeList); idx++ {
				tmpTime := this.curComPeriodTimeList[idx]
				this.curCompetitionSubId = int32(idx + 1)
				if nowTimeDate.Before(tmpTime) {
					break
				}
			}
			util.DebugF("CurCompId=%v stime=%v etime=%v subid=%v", this.curCompetitionId, this.curComStartTime,
				this.curComEndTime, this.curCompetitionSubId)
			//break
			continue //计算获得下一个赛季
		} else if nowTimeDate.Before(data.CalBeginTime) {
			break
		} else if nowTimeDate.After(data.CalEndTime) {
			this.preCompetitionId = data.CompetitionId
		}
	}

	this.serverCompetitionSaveNtf()
}

const initSendDurationTime uint64 = 1 * 60 * 1000

//成功发送消息返回true
func (this *CompetitionSeasonManager) initCompetitionInfoFromDB() bool {
	util.InfoF("initCompetitionInfoFromDB send to db")
	ssReqMsg := &serverproto.SSGetServerCompetitionReq{}
	if SendDb(ssReqMsg) {
		return true
	}
	return false
}

//获取当前已经开启的赛季ID(from db)
func (this *CompetitionSeasonManager) DoUpdateCompetitionInfoFromDB(ssAckMsg *serverproto.SSGetServerCompetitionAck) {
	this.initRecvFromDB = true
	this.serverCompetitionData = append(this.serverCompetitionData, ssAckMsg.CompetitionDataList...)
	RuneShopMag.StRecRound = ssAckMsg.RounInfo
}

func (this *CompetitionSeasonManager) Update(ms uint64) {
	//获取当前服务器的赛季信息
	if !this.initSendFromDB {
		if this.initSendFromDBTime > 0 && ms-this.initSendFromDBTime <= 5*1000 {
			return
		}
		if this.initCompetitionInfoFromDB() {
			this.initSendFromDB = true
			this.initSendFromDBTime = ms
		}
		this.initSendFromDBTime = ms
		return
	}
	if !this.initRecvFromDB {
		if ms-this.initSendFromDBTime >= initSendDurationTime {
			this.initSendFromDB = false
		}
		return
	}

	//开服时间
	if !this.initStartUp {
		startUpTime := service.GetServiceStartupTime()
		if startUpTime > 0 {
			this.init(ms, startUpTime)
		}
	}

	if this.initStartUp && this.updateTimer.IsStart() && this.updateTimer.IsExpired(ms) {
		nowTimeDate := util.GetTimeByUint64(ms)

		if this.curCompetitionId > 0 {
			//logUtil.InfoF("curtCompetitionId:%v endTime:%v", this.curCompetitionId, this.curComEndTime)
			//赛季结算
			if nowTimeDate.After(this.curComEndTime) {
				util.InfoF("EndCompetitionSeasonManager id=%v subid=%v endtime=%v", this.curCompetitionId, this.curCompetitionSubId, this.curComEndTime)
				this.DoCompetitionReward(this.curCompetitionId, this.curCompetitionSubId)

				this.preCompetitionId = this.curCompetitionId
				this.curCompetitionId = 0
				this.curCompetitionSubId = 0
			} else {
				//赛季中间周期结算处理
				if nowTimeDate.After(this.curComPeriodTimeList[this.curCompetitionSubId-1]) {
					util.InfoF("EndCompetitionSeasonManager id=%v subid=%v endtime=%v",
						this.curCompetitionId, this.curCompetitionSubId, this.curComPeriodTimeList[this.curCompetitionSubId-1])
					this.DoCompetitionReward(this.curCompetitionId, this.curCompetitionSubId)
					this.curCompetitionSubId++
				}
			}
		} else {
			//开启新赛季
			ret, nextData, nextCompetitionId := this.getNexCompetitionTime()
			//ret, nextSTime, nextETime, nextCompetitionId := this.getNexCompetitionTime()
			if ret && nowTimeDate.After(nextData.CalBeginTime) {
				util.InfoF("NewCompetitionSeasonManager id=%v %v-%v", nextCompetitionId, nextData.CalBeginTime, nextData.CalEndTime)

				this.curCompetitionId = nextCompetitionId
				this.curComStartTime = nextData.CalBeginTime
				this.curComEndTime = nextData.CalEndTime
				this.curComPeriodTimeList = nextData.PeriodEndTimeList
				this.curCompetitionSubId = 1

				this.DoCompetitionRefresh()
			}
		}
	}
}

//当前是否处在赛季中（不管具体哪一个赛季）

func (this *CompetitionSeasonManager) IsCompetitionOnline() bool {
	if this.curCompetitionId > 0 {
		nowTimeDate := util.GetTimeByUint64(util.GetTimeMilliseconds())
		if nowTimeDate.Before(this.curComEndTime) || nowTimeDate.Equal(this.curComEndTime) {
			return true
		}
	}
	return false
}

func (this *CompetitionSeasonManager) serverCompetitionSaveNtf() {
	if this.curCompetitionId > 0 {
		bFind := false
		for idx := 0; idx < len(this.serverCompetitionData); idx++ {
			if this.serverCompetitionData[idx].CompetitionId == this.curCompetitionId {
				bFind = true
				break
			}
		}
		if !bFind {
			addData := &serverproto.ServerCompetitionInfo{
				CompetitionId: this.curCompetitionId,
				StartTime:     uint64(this.curComStartTime.UnixNano() / 1e6),
				EndTime:       uint64(this.curComEndTime.UnixNano() / 1e6),
			}
			this.serverCompetitionData = append(this.serverCompetitionData, addData)

			ssNtfMsg := &serverproto.SSServerCompetitionInfoSaveNtf{
				CompetitionData: addData,
			}
			SendDb(ssNtfMsg)
		}
	}
}

func (this *CompetitionSeasonManager) getNexCompetitionTime() (bool, *model.CompetitionTimeData, int32) {
	retCompetitionId := this.preCompetitionId
	if this.curCompetitionId != 0 {
		retCompetitionId = this.curCompetitionId
	}
	bFind := false
	//确保赛季ID不是顺序添加时也生效，中间打断，而不是通过map来查找
	for _, data := range model.ConvertCompTimeIdList {
		if bFind || retCompetitionId == 0 {
			retCompetitionId = data.CompetitionId
			return true, data, retCompetitionId
		}
		if data.CompetitionId == retCompetitionId {
			bFind = true
		}
	}
	return false, nil, retCompetitionId
}

func (this *CompetitionSeasonManager) DoCompetitionReward(competitionId int32, subId int32) {
	convertData, ok := model.ConvertCompTimeList[competitionId]
	if !ok {
		util.DebugF("DoSeasonReward data not find competitionId=%v subId=%v", competitionId, subId)
		return
	}

	ssMsg := &serverproto.SSCompetitionRewardReq{
		CompetitionId:    competitionId,
		CompetitionType:  convertData.CompetitionType,
		CompetitionSubId: subId,
	}
	if len(convertData.PeriodEndTimeList) == int(subId) {
		ssMsg.EndSubId = true
	}
	for _, chRole := range RoleMag.channelRoleList {
		if chRole.GetState() == ROLE_STATE_ONLINE {
			ssMsg.RewardUidList = append(ssMsg.RewardUidList, &serverproto.KeyValueType64{
				Key:   chRole.GetUUid(),
				Value: chRole.(*Role).GetRoleArena().GetArenaScore(),
			})
			if len(ssMsg.RewardUidList) >= 50 {
				SendRankService(ssMsg)
				ssMsg.RewardUidList = ssMsg.RewardUidList[:0]
			}
		}
	}

	//结算数据处理
	SendRankService(ssMsg)
	if convertData.CompetitionType == int32(model.CompetitionType_Idol) && subId == 3{
		this.SendFansReward(int32(model.CompetitionType_Idol), 3, convertData)
	}
}

func (this *CompetitionSeasonManager)GMSendReward() {
	convertData, ok := model.ConvertCompTimeList[int32(model.CompetitionType_Idol)]
	if !ok {
		util.DebugF("DoSeasonReward data not find competitionId=%v subId=%v", int32(model.CompetitionType_Idol), 3)
		return
	}

	if convertData.CompetitionType == int32(model.CompetitionType_Idol) {
		this.SendFansReward(int32(model.CompetitionType_Idol), 3, convertData)
	}
}

func (this *CompetitionSeasonManager) SendFansReward(competitionId int32, subId int32, convertData *model.CompetitionTimeData) {
	if convertData == nil {
		return
	}

	ssMsg := &serverproto.SSCompetitionFansGetAllRewardReq{
		CompetitionId:    competitionId,
		CompetitionType:  convertData.CompetitionType,
		CompetitionSubId: subId,
		IsFinish:         false,
	}

	for _, chRole := range RoleMag.channelRoleList {
		if chRole.GetState() == ROLE_STATE_ONLINE {
			if chRole.(*Role).GetRoleCompetition().idolInfo == nil ||
				len(chRole.(*Role).GetRoleCompetition().idolInfo.VoteData) <= 0 {
				continue
			}
			fansData := &serverproto.FansVoteRewardData{
				Uid: chRole.GetUUid(),
			}
			for _, voteData := range chRole.(*Role).GetRoleCompetition().idolInfo.VoteData {
				fansData.IdolList = append(fansData.IdolList, &serverproto.KeyValueType64{
					Key: voteData.Key,
				})
			}
			ssMsg.Data = append(ssMsg.Data, fansData)

			if len(ssMsg.Data) >= 10 {
				SendRankService(ssMsg)
				ssMsg.Data = ssMsg.Data[:0]
			}
		}
	}

	ssMsg.IsFinish = true
	SendRankService(ssMsg)
}

func (this *CompetitionSeasonManager) DoCompetitionRefresh() {
	// 开启新赛季
	this.serverCompetitionSaveNtf()

	for _, chRole := range RoleMag.channelRoleList {
		if chRole.GetState() == ROLE_STATE_ONLINE {
			chRole.(*Role).GetRoleCompetition().CompetitionRefresh()
		}
	}
}

//给定时间获得可以获得奖励的赛季起始ID(返回的赛季的ID不算在内)
func (this *CompetitionSeasonManager) GetCompetitionIdByTime(uTime uint64) int32 {
	var retCompetitionId int32 = 0
	uDayTime := util.GetTimeByUint64(uTime)
	//util.DebugF("GetCompetitionIdByTime=%v", uDayTime)

	for _, data := range model.ConvertCompTimeIdList {
		if uDayTime.After(data.CalEndTime) {
			retCompetitionId = data.CompetitionId
		}
		if uDayTime.Before(data.CalBeginTime) ||
			(uDayTime.After(data.CalBeginTime) && uDayTime.Before(data.CalEndTime)) {
			break
		}
	}
	return retCompetitionId
}

func (this *CompetitionSeasonManager) CompetitionItemCheck(configId int32) int32 {
	data, ok := model.ConvertCompTypeList[this.curCompetitionId]
	if !ok {
		return 0
	}

	if data.CompetitionItemList.Has(configId) && this.curComEndTime.Unix() > 0 {
		if util.GetTimeSeconds() > this.curComEndTime.Unix() {
			return 0
		}

		cfgData := GetItemCfg(configId)
		if cfgData != nil && cfgData.ItemTime == Item_Time_Type_Competition_4 {
			return -1
		}

		return int32(this.curComEndTime.Unix())
	}
	return 0
}