RoServer/RO_Server_Trunk-branch_bt/roserver/cross_server/model/yuanhang_trial.go

package model

import (
	"container/heap"
	"math/rand"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/baseserver/set"
	"roserver/serverproto"
	"sort"
)

//远航试炼
const (
	YuanHangTrialViewMaxNum = 200 //最大客户端可视列表数量

	//1 你被xxx挑战，失去xxx奖励
	//2 你对xx发起了抢夺，获得了xxx奖励
	//3 你对xx发起了抢夺，但是自己无法获取到奖励
	TrialLogDataType_1 = 1
	TrialLogDataType_2 = 2
	TrialLogDataType_3 = 3
)

type yuanHangTrialList struct {
	isDirty       bool
	itemList      []*serverproto.YuanHangTrialData
	trailItemList map[uint64]*serverproto.YuanHangTrialData
}

func (this *yuanHangTrialList) addItem(item *serverproto.YuanHangTrialData) {
	this.itemList = append(this.itemList, item)
	this.isDirty = true

	this.trailItemList[item.Uid] = item
}
func (this *yuanHangTrialList) delItem(uid uint64) {
	//后续使用二分查找实现
	for idx := 0; idx < len(this.itemList); idx++ {
		if this.itemList[idx].Uid == uid {
			this.itemList = append(this.itemList[idx:], this.itemList[:idx+1]...)
			this.isDirty = true
			break
		}
	}
	delete(this.trailItemList, uid)
}
func (this *yuanHangTrialList) binarySearch(leftIndex, rightIndex int, findVal uint64) int {
	if leftIndex > rightIndex {
		return 0
	}
	middle := (leftIndex + rightIndex) / 2
	if this.itemList[middle].DirtyStamp > findVal {
		this.binarySearch(middle+1, rightIndex, findVal)
	} else if this.itemList[middle].DirtyStamp < findVal {
		this.binarySearch(leftIndex, middle-1, findVal)
	}

	return middle
}

//minheap
type TrailItemMinHeap struct {
	ItemList []*serverproto.YuanHangTrialData
}

func (h *TrailItemMinHeap) Len() int {
	return len(h.ItemList)
}
func (h *TrailItemMinHeap) Less(i, j int) bool {
	return h.ItemList[i].EndTimeStamp < h.ItemList[j].EndTimeStamp
}

func (h *TrailItemMinHeap) Swap(i, j int) {
	h.ItemList[i], h.ItemList[j] = h.ItemList[j], h.ItemList[i]
}

func (h *TrailItemMinHeap) Push(item interface{}) {
	h.ItemList = append(h.ItemList, item.(*serverproto.YuanHangTrialData))
}
func (h *TrailItemMinHeap) Pop() (ret interface{}) {
	l := len(h.ItemList)
	h.ItemList, ret = h.ItemList[:l-1], h.ItemList[l-1]
	return
}

////
type YuanHangTrialManager struct {
	trailItemMinHeap *TrailItemMinHeap
	tailItemLeftList *TrailItemMinHeap //超过200后的存储列表(排序)

	trialItemMapList map[uint64]*serverproto.YuanHangTrialData //total

	//cache fightInfo
	cacheFightRoleInfoList map[uint64]*serverproto.FightRoleInfo
	dbChangeTrialItemList  set.Interface
	lineNum                int32
	latestTrialTime        uint64 //玩家最近一次的远航操作时间戳

	notifyList []*serverproto.YuanHangTrialData

	bInit       bool
	updateTimer util.ServerTimer //主循环定时器
}

func newYuanHangTrialManager() *YuanHangTrialManager {
	mag := &YuanHangTrialManager{
		trialItemMapList:       map[uint64]*serverproto.YuanHangTrialData{},
		trailItemMinHeap:       &TrailItemMinHeap{},
		tailItemLeftList:       &TrailItemMinHeap{},
		cacheFightRoleInfoList: map[uint64]*serverproto.FightRoleInfo{},
		dbChangeTrialItemList:  set.New(set.NonThreadSafe),
	}
	mag.updateTimer = util.NewDurationTimer(util.GetCurrentTime(), 1000)
	heap.Init(mag.trailItemMinHeap)
	heap.Init(mag.tailItemLeftList)

	return mag
}
func (this *YuanHangTrialManager) Update(ms uint64) {
	if !this.bInit {
		if this.initTrialDataFromDB() {
			this.bInit = true
		}
		return
	}

	if !this.updateTimer.IsStart() || !this.updateTimer.IsExpired(ms) {
		return
	}

	this.refreshViewList(ms)

	//save change uid
	this.saveItemData()

	//notify list
	if len(this.notifyList) > 0 {
		ssNotifyMsg := &serverproto.SSCrossYuanHangTrialViewNtf{}
		ssNotifyMsg.TrialViewList = append(ssNotifyMsg.TrialViewList, this.notifyList...)
		SendAllZoneSocial(ssNotifyMsg)

		this.notifyList = this.notifyList[:0]
	}
}

//服务器启动时数据初始化
func (this *YuanHangTrialManager) initTrialDataFromDB() bool {
	tmpItemList, bOk := GetTrialItemFromRedis()
	if !bOk {
		return false
	}

	sort.Slice(tmpItemList, func(i, j int) bool {
		return tmpItemList[i].EndTimeStamp < tmpItemList[j].EndTimeStamp
	})

	for idx := 0; idx < len(tmpItemList); idx++ {
		if idx < YuanHangTrialViewMaxNum {
			heap.Push(this.trailItemMinHeap, tmpItemList[idx])
		} else {
			heap.Push(this.tailItemLeftList, tmpItemList[idx])
		}
		this.trialItemMapList[tmpItemList[idx].Uid] = tmpItemList[idx]
	}
	return true
}

func (this *YuanHangTrialManager) refreshViewList(ms uint64) {
	//更新可视列表中是否有玩家远航结束
	if this.trailItemMinHeap.Len() <= 0 && this.tailItemLeftList.Len() <= 0 {
		return
	}

	//当前可视列表中过期的玩家移除
	for {
		if this.trailItemMinHeap.Len() <= 0 {
			break
		}
		itemInfo := heap.Pop(this.trailItemMinHeap).(*serverproto.YuanHangTrialData)
		if itemInfo == nil {
			break
		}
		//玩家远航结束，需要添加新玩家到可视列表中
		if ms >= itemInfo.EndTimeStamp {
			if this.tailItemLeftList.Len() > 0 {
				addItemInfo := heap.Pop(this.tailItemLeftList).(*serverproto.YuanHangTrialData)
				if addItemInfo != nil {
					heap.Push(this.trailItemMinHeap, addItemInfo)
					this.dbChangeTrialItemList.Add(addItemInfo.Uid)
					//添加到通知列表中
					this.addNotifyList(addItemInfo)
				}
			}
			this.dbChangeTrialItemList.Add(itemInfo.Uid)
		} else {
			heap.Push(this.trailItemMinHeap, itemInfo)
			break
		}
	}

	//添加新玩家到可视列表中(填充可视列表最大数量)
	needAddNum := YuanHangTrialViewMaxNum - this.trailItemMinHeap.Len()
	if needAddNum > 0 {
		for idx := 0; idx < needAddNum; idx++ {
			if this.tailItemLeftList.Len() <= 0 {
				break
			}
			addItemInfo := heap.Pop(this.tailItemLeftList).(*serverproto.YuanHangTrialData)
			if addItemInfo != nil {
				heap.Push(this.trailItemMinHeap, addItemInfo)

				//添加到通知列表中
				this.addNotifyList(addItemInfo)
			}
		}
	}
}

func (this *YuanHangTrialManager) saveItemData() {
	if this.dbChangeTrialItemList.Size() <= 0 {
		return
	}
	saveList := this.dbChangeTrialItemList.List()
	for idx := 0; idx < len(saveList); idx++ {
		saveUid := saveList[idx].(uint64)
		if item, ok := this.trialItemMapList[saveUid]; ok {
			SetTrialItemToRedis(item, saveUid)
		} else {
			//数据库中需要在获取奖励之后才删除
			//SetTrialItemToRedis(nil, saveUid)
		}
	}

	this.dbChangeTrialItemList.Clear()
}

func (this *YuanHangTrialManager) addTrialItem(uid uint64, trialType int32, endTimeStamp uint64, durationTime int32,
	zone, fromZone int32) *serverproto.YuanHangTrialData {
	nowTime := util.GetTimeMilliseconds()
	this.lineNum = (this.lineNum+1)%10 + 1
	if this.latestTrialTime <= 0 {
		this.latestTrialTime = nowTime
	} else if this.latestTrialTime+30000 < nowTime {
		this.latestTrialTime = nowTime
		this.lineNum = rand.Int31n(10) + 1
	}

	item := &serverproto.YuanHangTrialData{
		Uid:          uid,
		TrialType:    trialType,
		DirtyStamp:   nowTime,
		EndTimeStamp: endTimeStamp,
		Zone:         zone,
		FromRealZone: fromZone,
		DurationTime: durationTime,
		LineNum:      this.lineNum,
	}

	this.trialItemMapList[item.Uid] = item

	//添加到可见列表中
	if this.trailItemMinHeap.Len() < YuanHangTrialViewMaxNum {
		heap.Push(this.trailItemMinHeap, item)
		this.addNotifyList(item)
	} else {
		heap.Push(this.tailItemLeftList, item)
	}
	this.dbChangeTrialItemList.Add(uid)

	return item
}

func (this *YuanHangTrialManager) addNotifyList(notifyItem *serverproto.YuanHangTrialData) {
	for idx := 0; idx < len(this.notifyList); idx++ {
		if this.notifyList[idx].Uid == notifyItem.Uid {
			this.notifyList[idx] = notifyItem
			return
		}
	}
	this.notifyList = append(this.notifyList, notifyItem)
}

func (this *YuanHangTrialManager) getFightRoleInfo(uid uint64) *serverproto.FightRoleInfo {
	if fightInfo, ok := this.cacheFightRoleInfoList[uid]; ok {
		return fightInfo
	}

	err, fightInfo := GetFightInfoFromRedis(uid)
	if err != nil {
		util.InfoF("getFightRoleInfo uid=%v err=%v", uid, err)
		return nil
	}
	this.cacheFightRoleInfoList[uid] = fightInfo
	return fightInfo
}

//获取远航可视列表
func (this *YuanHangTrialManager) GetTrialViewList(bViewList bool, uidTrialInfo uint64) ([]*serverproto.YuanHangTrialData, *serverproto.YuanHangTrialData) {
	if uidTrialInfo > 0 {
		if item, ok := this.trialItemMapList[uidTrialInfo]; ok {
			if bViewList {
				return this.trailItemMinHeap.ItemList, item
			} else {
				return nil, item
			}
		}
	}

	if bViewList {
		return this.trailItemMinHeap.ItemList, nil
	}

	return nil, nil
}

//发起远航试炼
// @trialType 远航类型 (1,2,3,4,5...)
func (this *YuanHangTrialManager) YuanHangTrial(fromZone int32, uid uint64, trialType int32, endTimeStamp uint64,
	fightInfo *serverproto.FightRoleInfo, durationTime int32) *serverproto.YuanHangTrialData {
	zone := fightInfo.BriefInfo.SelectZone
	if zone <= 0 {
		zone = fromZone
	}
	addTrialItem := this.addTrialItem(uid, trialType, endTimeStamp, durationTime, zone, fromZone)

	err := SetFightInfoToRedis(uid, fightInfo)
	util.InfoF("uid=%v YuanHangTrial err=%v addTrialItem=%v", uid, err, addTrialItem)
	this.cacheFightRoleInfoList[uid] = fightInfo

	//notify other
	return addTrialItem
}

//非正常情况下不调用该接口
func (this *YuanHangTrialManager) YuanHangTrialForceSelf(ssMsg *serverproto.SSCrossYuanHangTrialSelfReq, fromZone int32) {
	_, ok := this.trialItemMapList[ssMsg.SelfUid]
	if !ok {
		nowTime := util.GetTimeMilliseconds()
		if ssMsg.EndTimeStamp > nowTime {
			zone := ssMsg.SelfFightInfo.BriefInfo.SelectZone
			if zone <= 0 {
				zone = fromZone
			}
			addTrialItem := this.addTrialItem(ssMsg.SelfUid, ssMsg.TrialType, ssMsg.EndTimeStamp, ssMsg.DurationTime, zone, fromZone)
			//err := SetFightInfoToRedis(ssMsg.SelfUid, ssMsg.SelfFightInfo)
			util.InfoF("uid=%v YuanHangTrialForceSelf addTrialItem=%v", ssMsg.SelfUid, addTrialItem)
			this.cacheFightRoleInfoList[ssMsg.SelfUid] = ssMsg.SelfFightInfo
		}
	}

	SetFightInfoToRedis(ssMsg.SelfUid, ssMsg.SelfFightInfo)
}

//飞艇信息
//trialUid 飞艇对应玩家
//trialUidEndTime 当前玩家飞艇对应的结束时间
func (this *YuanHangTrialManager) GetTrialInfo(trialUid, trialUidEndTime uint64) (serverproto.ErrorCode, *serverproto.YuanHangTrialData) {
	trialItem, ok := this.trialItemMapList[trialUid]
	if !ok {
		//必须是该玩家的本次远航试炼
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN, nil
	}
	nowTime := util.GetTimeMilliseconds()
	if trialItem.EndTimeStamp <= nowTime {
		//本次查询的玩家对应的飞艇已经结束
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN, nil
	}

	return serverproto.ErrorCode_ERROR_OK, trialItem
}

// @param selfUid 发起挑战玩家
// @param challengeUid 被挑战玩家
// @param beChallengeMaxNum 最大被挑战次数
func (this *YuanHangTrialManager) GetChallengeTrialItem(selfUid, challengeUid, challengeUidEndTime uint64,
	beChallengeMaxNum int32, ssAckMsg *serverproto.SSCrossYuanHangTrialChallengeAck) serverproto.ErrorCode {
	trialItem, ok := this.trialItemMapList[challengeUid]
	if !ok || trialItem.EndTimeStamp < challengeUidEndTime {
		//必须是该玩家的本次远航试炼
		util.InfoF("uid=%v GetChallengeTrialItem challenge item not exist existUidAndTime[%v,%v] not[%v,%v]", selfUid,
			trialItem.Uid, trialItem.EndTimeStamp, challengeUid, challengeUidEndTime)
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN
	}
	nowTime := util.GetTimeMilliseconds()
	if trialItem.EndTimeStamp <= nowTime {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN
	}

	//是否已经抢夺过一次该玩家
	for idx := 0; idx < len(trialItem.BeChallengeUidList); idx++ {
		if trialItem.BeChallengeUidList[idx] == selfUid {
			return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_CHALLENGED
		}
	}

	//抢夺次数上限判断
	if beChallengeMaxNum <= 0 {
		convertData, ok := model.ConvertYuanHangTrail[trialItem.TrialType]
		if ok {
			beChallengeMaxNum = convertData.BeAttackNum
		}
	}
	if trialItem.BeChallengeNum >= beChallengeMaxNum {
		return serverproto.ErrorCode_ERROR_CORSS_YUANHANGTRIAL_BE_CHALLENGE_LIMIT
	}

	//获取挑战玩家信息
	fightInfo := this.getFightRoleInfo(challengeUid)
	if fightInfo == nil {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN
	}
	ssAckMsg.FightInfo = fightInfo
	ssAckMsg.ChallengeUid = challengeUid
	ssAckMsg.ChallengeUidEndTime = challengeUidEndTime

	return serverproto.ErrorCode_ERROR_OK
}

//挑战结果通知
func (this *YuanHangTrialManager) ChallengeTrialItemResult(selfUid, challengeUid, challengeUidEndTime uint64,
	selfNickName string, selfZone int32, bWin bool, fightInfo *serverproto.FightRoleInfo, ssAckMsg *serverproto.SSCrossYuanHangTrialChallengeResultAck) serverproto.ErrorCode {

	trialItem, ok := this.trialItemMapList[challengeUid]
	if !ok || trialItem.EndTimeStamp < challengeUidEndTime {
		//必须是该玩家的本次远航试炼
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN
	}
	nowTime := util.GetTimeMilliseconds()
	if trialItem.EndTimeStamp <= nowTime {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN
	}

	convertData, ok := model.ConvertYuanHangTrail[trialItem.TrialType]
	if ok {
		if trialItem.BeChallengeNum >= convertData.BeAttackNum {
			return serverproto.ErrorCode_ERROR_CORSS_YUANHANGTRIAL_BE_CHALLENGE_LIMIT
		}
	}
	SetFightInfoToRedis(selfUid, fightInfo)
	this.cacheFightRoleInfoList[selfUid] = fightInfo

	//挑战日志记录
	beChallengePlayer := this.getFightRoleInfo(trialItem.Uid)
	if beChallengePlayer != nil {
		ssAckMsg.LogData = &serverproto.YuanHangTrialLogData{
			Type:             TrialLogDataType_2,
			RecordTime:       nowTime,
			State:            true,
			TargetPlayerUid:  trialItem.Uid,
			TargetPlayerZone: trialItem.Zone,
			TargetPlayerName: beChallengePlayer.BriefInfo.NickName,
			TrialType:        trialItem.TrialType,
		}
	}
	ssAckMsg.ShipTrialLevel = trialItem.TrialType

	trialItem.BeChallengeNum++
	trialItem.BeChallengeUidList = append(trialItem.BeChallengeUidList, selfUid)
	trialItem.DirtyStamp = nowTime
	this.dbChangeTrialItemList.Add(challengeUid)

	this.addNotifyList(trialItem)

	//被挑战日志记录
	//通知被挑战玩家
	this.addBeChallengeLog(trialItem, nowTime, selfUid, selfZone, selfNickName)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *YuanHangTrialManager) UpdateRankScore(uid, rankScore uint64) {
	UpdateTrialRankScore(uid, rankScore)
}

//远航试炼排行榜
func (this *YuanHangTrialManager) GetTrialRankList(uid uint64, startIdx int32,
	ssAckMsg *serverproto.SSCrossYuanHangTrialRankListAck) {
	selfRank, selfScore, totalRank, rankList := GetTrialRankList(uid, startIdx)
	ssAckMsg.SelfRank = selfRank
	ssAckMsg.SelfScore = selfScore
	ssAckMsg.TotalRank = totalRank
	ssAckMsg.RankList = rankList
}

func (this *YuanHangTrialManager) addBeChallengeLog(trialItem *serverproto.YuanHangTrialData,
	nowTime uint64, targetPlayerUid uint64, targetPlayerZone int32, targetPlayerNickName string) {
	//通知被挑战玩家
	logNtf := &serverproto.SSCrossYuanHangTrialLogNtf{
		NtfUid: trialItem.Uid,
	}
	logNtf.LogData = &serverproto.YuanHangTrialLogData{
		Type:             TrialLogDataType_1,
		RecordTime:       nowTime,
		State:            true,
		TargetPlayerUid:  targetPlayerUid,
		TargetPlayerZone: targetPlayerZone,
		TargetPlayerName: targetPlayerNickName,
		TrialType:        trialItem.TrialType,
	}
	//失去的奖励
	convertData, ok := model.ConvertYuanHangTrail[trialItem.TrialType]
	if ok {
		logNtf.LogData.ItemList = append(logNtf.LogData.ItemList, convertData.BeAttackLoseItemListSlice...)
	}

	util.InfoF("uid=%v addBeChallengeLog trialType=%v beAttackedUid=%v realZone=%v", targetPlayerUid, trialItem.TrialType, trialItem.Uid, trialItem.FromRealZone)
	SendZoneSocial(logNtf, trialItem.FromRealZone)
}