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

package model

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

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
}

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

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

func (this *CrossManager) Update(ms uint64) {
	if !this.initStartUp {
		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)
		}
	}
}