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

package model

import (
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"sort"
	"strconv"
	"time"
)

const (
	Expired_Time          = 10 * 60 * 1000
	TrialRankExpired_Time = 1 * 60 * 1000
)

// //远航试炼缓存
var NtfViewUidList = map[uint64]uint64{}

func AddNtfUid(uid uint64) {
	NtfViewUidList[uid] = util.GetTimeMilliseconds()
}

func DelNtfUid(uid uint64) {
	delete(NtfViewUidList, uid)
}

func NtfMsg(msg interface{}) {
	nowTime := util.GetTimeMilliseconds()
	for uid, oldTime := range NtfViewUidList {
		role := RoleMag.GetRoleFromUUid(uid)
		if role == nil {
			delete(NtfViewUidList, uid)
			continue
		}
		role.ReplayGate(msg, true)

		if oldTime+Expired_Time <= nowTime {
			DelNtfUid(uid)
		}
	}
}

var cacheCrossYuanHangTrialViewList []*serverproto.YuanHangTrialData
var refreshCacheTime uint64

func SetYuanHangTrialViewList(viewList []*serverproto.YuanHangTrialData) {
	cacheCrossYuanHangTrialViewList = viewList
	refreshCacheTime = util.GetTimeMilliseconds()
}
func GetYuanHangTrialViewList() []*serverproto.YuanHangTrialData {
	//每30s重新获取一次可见列表
	nowTime := util.GetTimeMilliseconds()
	if refreshCacheTime+30*1000 < nowTime {
		return nil
	}
	return cacheCrossYuanHangTrialViewList
}
func UpdateTrialViewItem(viewDataList []*serverproto.YuanHangTrialData) {
	for idx := 0; idx < len(viewDataList); idx++ {
		bFind := false
		for k := 0; k < len(cacheCrossYuanHangTrialViewList); k++ {
			if cacheCrossYuanHangTrialViewList[k].Uid == viewDataList[idx].Uid {
				cacheCrossYuanHangTrialViewList[k] = viewDataList[idx]
				bFind = true
				break
			}
		}
		if !bFind {
			cacheCrossYuanHangTrialViewList = append(cacheCrossYuanHangTrialViewList, viewDataList[idx])
		}

		ntfRole := RoleMag.GetRoleFromUUid(viewDataList[idx].Uid)
		if ntfRole == nil {
			ntfRole = RoleMag.GetRoleFromOffline(viewDataList[idx].Uid)
			if ntfRole != nil {
				ntfRole.(*Role).GetRoleCross().UpdateTrialInfo(viewDataList[idx].BeChallengeNum)
			}
		}
	}
}

var cacheCrossYuanHangTrialRankList []*cacheTrialRank

type cacheTrialRank struct {
	StartIdx    int32
	RefreshTime uint64
	rankList    []*serverproto.CommonRankInfo
}

func UpdateYuanHangTrialRankList(startIdx int32, rankList []*serverproto.CommonRankInfo) {
	bFind := false
	for idx := 0; idx < len(cacheCrossYuanHangTrialRankList); idx++ {
		if cacheCrossYuanHangTrialRankList[idx].StartIdx == startIdx {
			cacheCrossYuanHangTrialRankList[idx].rankList = rankList
			cacheCrossYuanHangTrialRankList[idx].RefreshTime = util.GetTimeMilliseconds()
			bFind = true
			break
		}
	}
	if !bFind {
		cacheCrossYuanHangTrialRankList = append(cacheCrossYuanHangTrialRankList,
			&cacheTrialRank{
				StartIdx:    startIdx,
				rankList:    rankList,
				RefreshTime: util.GetTimeMilliseconds(),
			})
	}
}
func GetYuanHangTrialRankList(startIdx int32) []*serverproto.CommonRankInfo {
	for idx := 0; idx < len(cacheCrossYuanHangTrialRankList); idx++ {
		if cacheCrossYuanHangTrialRankList[idx].StartIdx == startIdx {
			nowTime := util.GetTimeMilliseconds()
			if cacheCrossYuanHangTrialRankList[idx].RefreshTime+TrialRankExpired_Time <= nowTime {
				return nil
			}
			return cacheCrossYuanHangTrialRankList[idx].rankList
		}
	}
	return nil
}

// 全局跨服使用GCrossRouter
// 服务器列表状态缓存
type ServerStateCache struct {
	ServerType  int32
	ServerState *serverproto.SCGCrossGetServerStateAck
	RefreshTime uint64
}

var ServerStateCacheList = map[int32]*ServerStateCache{}

// force是否判断过期需要重新获取
func GetServerStateListByType(serverType int32, force bool) *serverproto.SCGCrossGetServerStateAck {
	nowTime := util.GetTimeMilliseconds()
	if dataList, ok := ServerStateCacheList[serverType]; ok {
		if dataList.ServerState == nil || (force && dataList.RefreshTime < nowTime) {
			return nil
		}
		return dataList.ServerState
	} else {
		return nil
	}
}

func GetServerStateByTypeAndLine(serverType, lineNum int32) string {
	retSID := ""
	listData := GetServerStateListByType(serverType, false)
	if listData == nil {
		return retSID
	}
	for idx := 0; idx < len(listData.ServerList); idx++ {
		tmpNodeId := listData.ServerList[idx]
		beginLineNum := (tmpNodeId.Id-1)*tmpNodeId.MaxLineNum + 1
		endLineNum := tmpNodeId.Id * tmpNodeId.MaxLineNum
		if beginLineNum <= lineNum && lineNum <= endLineNum {
			retSID = tmpNodeId.Sid
			break
		}
	}
	return retSID
}

// 选择线路未满的房间(线路号从小达到)
func GetServerStateByType(serverType int32) (string, int32) {
	retSID := ""
	listData := GetServerStateListByType(serverType, false)
	if listData == nil {
		return retSID, 0
	}
	var lineNum int32 = 0
	for idx := 0; idx < len(listData.ServerList); idx++ {
		tmpNodeId := listData.ServerList[idx]
		beginLineNum := (tmpNodeId.Id-1)*tmpNodeId.MaxLineNum + 1
		endLineNum := tmpNodeId.Id * tmpNodeId.MaxLineNum
		for lineIdx := beginLineNum; lineIdx <= endLineNum; lineIdx++ {
			bFull := false
			for k := 0; k < len(tmpNodeId.StateList); k++ {
				if tmpNodeId.StateList[k].Line == lineIdx {
					if tmpNodeId.StateList[k].CurNum >= tmpNodeId.MaxSpaceEntityNum {
						bFull = true
					}
					break
				}
			}
			if !bFull {
				retSID = tmpNodeId.Sid
				lineNum = lineIdx
				break
			}
		}
	}
	return retSID, lineNum
}

func UpdateServerStateListByType(serverType int32, serverStateData *serverproto.SSGetGServerStateAck) {
	if len(serverStateData.ServerList) <= 0 {
		return
	}

	nowTime := util.GetTimeMilliseconds()
	if dataList, ok := ServerStateCacheList[serverType]; ok {
		dataList.ServerState.ServerList = serverStateData.ServerList
		dataList.RefreshTime = nowTime + 5*1000
	} else {
		ServerStateCacheList[serverType] = &ServerStateCache{
			ServerType:  serverType,
			RefreshTime: nowTime + 5*1000,
			ServerState: &serverproto.SCGCrossGetServerStateAck{
				ServerType: serverType,
				ServerList: serverStateData.ServerList,
			},
		}
		sort.Slice(ServerStateCacheList[serverType].ServerState.ServerList, func(i, j int) bool {
			return ServerStateCacheList[serverType].ServerState.ServerList[i].Id <
				ServerStateCacheList[serverType].ServerState.ServerList[j].Id
		})
	}

	//人数为0的线路初始化
	listData := ServerStateCacheList[serverType].ServerState
	for idx := 0; idx < len(listData.ServerList); idx++ {
		tmpNodeId := listData.ServerList[idx]
		if len(tmpNodeId.StateList) >= int(tmpNodeId.MaxLineNum) {
			continue
		}
		beginLineNum := (tmpNodeId.Id-1)*tmpNodeId.MaxLineNum + 1
		endLineNum := tmpNodeId.Id * tmpNodeId.MaxLineNum
		for lineIdx := beginLineNum; lineIdx <= endLineNum; lineIdx++ {
			bFind := false
			for k := 0; k < len(tmpNodeId.StateList); k++ {
				if tmpNodeId.StateList[k].Line == lineIdx {
					bFind = true
					break
				}
			}
			if !bFind {
				tmpNodeId.StateList = append(tmpNodeId.StateList, &serverproto.StateDetailDesc{Line: lineIdx})
			}
		}
	}
}

// 分发来自跨服的消息
func SendMsgFromCrossRouter(msg interface{}, cliId model.ClientID) {
	if cliId.SessID > 0 {
		role := RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.DebugF("uid=%v receive SSGCrossMapEnterNtf ms=%v", role.GetUUid(), msg)

		role.ReplayGate(msg, true)
	} else if len(cliId.SessIdList) > 0 {
		var clientIdLIstMap = map[string][]uint64{}
		//只发送当前game相关的玩家
		for idx := 0; idx < len(cliId.SessIdList); idx++ {
			role := RoleMag.GetRoleFromUUid(cliId.SessIdList[idx])
			if role == nil {
				continue
			}
			serviceId := role.CliID().ServiceID
			clientIdLIstMap[serviceId] = append(clientIdLIstMap[serviceId], role.CliID().SessID)
		}

		for key, dataList := range clientIdLIstMap {
			ReplayGateList(msg, dataList, key, true)
		}
	}
}

type CrossManager struct {
	updateTimer                    util.ServerTimer //更新定时器
	initStartUp                    bool
	seasonStartTime, seasonEndTime time.Time
	refreshTime                    time.Time
}

func newCrossMag() *CrossManager {
	mag := &CrossManager{}
	mag.updateTimer = util.NewDurationTimer(util.GetCurrentTime(), 5000)
	return mag
}

func (this *CrossManager) init(ms uint64) {
	nowTime := util.GetTimeByUint64(ms)
	if nowTime.Before(this.refreshTime.AddDate(0, 0, 7)) {
		return
	}
	endTime := util.GetLatestWeek10HourTime(ms)
	if nowTime.After(endTime) {
		msg := &serverproto.SSCrossYuanHangTrialRankUpdateReq{}
		SendCrossService(msg)
		util.InfoF("cross rank refresh time:%v", nowTime)
		this.refreshTime = nowTime
	}

}

func (this *CrossManager) getSeasonTime(seasonId int32) (time.Time, time.Time) {
	resetTime := int64((model.ConvertArenaSeason.Reset + 1) * HourMs)
	diffDurationDay := model.ConvertArenaSeason.DiffDurationDay
	deltaTime := (diffDurationDay + resetTime) * int64(seasonId-1)

	loc := util.GetLoc()
	startTime := time.Unix(model.ConvertArenaSeason.StartTime.Unix()+deltaTime, 0).In(loc)
	endTime := time.Unix(model.ConvertArenaSeason.EndTime.Unix()+deltaTime, 0).In(loc)
	return startTime, endTime
}

func (this *CrossManager) Update(ms uint64) {
	this.init(ms)

	if this.initStartUp && this.updateTimer.IsStart() && this.updateTimer.IsExpired(ms) {
		if len(ServerStateCacheList) <= 0 {
			ssStateMsg := &serverproto.SSGetGServerStateReq{
				ServerType: model.SERVICE_NODE_TYPE_GLOBALCROSSMAP,
			}
			SendSocial(ssStateMsg)
		}
	}
}

// 获取对应赛季奖励
func (this *CrossManager) GetSeasonReward(role uint64, selfRank, rewardSeasonId int32) {
	if selfRank <= 0 || role == 0 {
		return
	}

	//获取排名奖励，发送邮件
	for _, data := range model.ConvertCrossRankInfo.RewardInfo {
		if selfRank >= data.Left && selfRank <= data.Right {
			itemList := make([]*serverproto.KeyValueType, 0)
			for k, v := range data.RewardList {
				itemList = append(itemList, &serverproto.KeyValueType{
					Key:   k,
					Value: v,
				})
			}
			//发送邮件,不在线的通过db那边清空分数
			AddMailOnlineAndOffline([]uint64{role}, model.GlobalMailyuanhangRankAward, int32(serverproto.MailType_MailType_GM),
				itemList, []int32{int32(util.GetTimeSeconds())}, "飞艇排行榜奖励", "恭喜您在遠航試煉中獲得了第"+strconv.FormatInt(int64(selfRank), 10)+"名")
			//在线的清空分数
			r := RoleMag.GetRoleFromUUid(role)
			if r != nil {
				r.SetYuanRankScore()
			}
			util.InfoF("send rank award uid:%v award:%v", role, itemList)
			break
		}
	}
	//
	//// 赛季第一名触发称号事件
	//var value int32 = 1
	//if selfRank != 1 {
	//	value = role.roleTask.GetTypeCnt(int32(serverproto.TaskType_Eve_Arean_First)) * -1
	//} else {
	//	TaskMagCheck(role, serverproto.TaskType_Eve_Arean_First_Cnt, 1)
	//}
	//role.roleTask.AddTypeCnt(serverproto.TaskType_Eve_Arean_First, value)
	//TaskMagCheck(role, serverproto.TaskType_Eve_Arean_First, rewardSeasonId)
}

// 赛季结算
func (this *CrossManager) DoSeasonReward(seasonId int32) {
	ssMsg := &serverproto.SSArenaRankUpdateReq{
		LastSeasonId: seasonId,
	}
	sendNum := 0
	for _, chRole := range RoleMag.channelRoleList {
		if chRole.GetState() != ROLE_STATE_ONLINE {
			continue
		}
		//段位奖励
		//chRole.(*Role).GetRoleArena().ScoreLevelReward()

		//top排行奖励
		//if chRole.(*Role).GetRoleArena().arenaInfo.Score >= model.MinTopRankScore {
		if chRole.(*Role).GetRoleArena().arenaInfo.Score > 0 {
			ssMsg.RewardPlayerList = append(ssMsg.RewardPlayerList, chRole.GetUUid())
			sendNum++
			if sendNum >= 50 {
				SendRankService(ssMsg)

				sendNum = 0
				ssMsg.RewardPlayerList = ssMsg.RewardPlayerList[:0]
			}
		}
	}

	//rank处理结算数据
	SendRankService(ssMsg)
}

// 开启新赛季
func (this *CrossManager) DoSeasonRefresh() {
	for _, chRole := range RoleMag.channelRoleList {
		if chRole.GetState() == ROLE_STATE_ONLINE ||
			chRole.GetState() == ROLE_STATE_OFFLINE {
			chRole.(*Role).GetRoleArena().DoSeasonRefresh()
		}
	}
}