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

package model

import (
	"math/rand"
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	model2 "roserver/cross_server/model"
	"roserver/serverproto"
	"sort"
)

// 远航试炼
func (this *Role) YuanHangTrialViewList() {
	if this.GetRoleCross() != nil {
		this.GetRoleCross().YuanHangTrialViewList()
	}
}
func (this *Role) RefreshYuanHangTrialType(force bool) {
	if this.GetRoleCross() != nil {
		ret := this.GetRoleCross().RefreshYuanHangTrialType(force)
		ackMsg := &serverproto.SCCrossYuanHangTrialRefreshTrialTypeAck{
			Error: int32(ret),
		}
		this.ReplayGate(ackMsg, true)
	}
}
func (this *Role) YuanHangTrial() {
	ackMsg := &serverproto.SCCrossYuanHangTrialAck{
		Error: int32(serverproto.ErrorCode_ERROR_FAIL),
	}
	if this.GetRoleCross() != nil {
		ret := this.GetRoleCross().YuanHangTrialProcess()
		ackMsg.Error = int32(ret)
	}
	this.ReplayGate(ackMsg, true)
}
func (this *Role) YuanHangTrialReward() {
	if this.GetRoleCross() != nil {
		ret := this.GetRoleCross().YuanHangTrialReward()
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCrossYuanHangTrialRewardAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}
func (this *Role) YuanHangTrialChallenge(challengeUid, challengeUidEndTime uint64) {
	if this.GetRoleCross() != nil {
		crossMsg := &serverproto.SSCrossYuanHangTrialChallengeReq{
			ChallengeUid:        challengeUid,
			ChallengeUidEndTime: challengeUidEndTime,
		}
		this.SendSocial(crossMsg)

	}
}
func (this *Role) YuanHangTrialChallengeResult(msg *serverproto.CSCrossYuanHangTrialChallengeResultReq) {
	if this.GetRoleCross() != nil {
		//FightTime check
		if !msg.Win {
			ackMsg := &serverproto.SCCrossYuanHangTrialChallengeResultAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			this.ReplayGate(ackMsg, true)
		} else {
			crossMsg := &serverproto.SSCrossYuanHangTrialChallengeResultReq{
				ChallengedUid:        msg.ChallengeUid,
				ChallengedUidEndTime: msg.ChallengeUidEndTime,
				FightTime:            msg.FightTime,
				Win:                  msg.Win,
				FightInfo:            &serverproto.FightRoleInfo{},
				SelfNickName:         this.GetNickName(),
				SelfZone:             this.GetSelectZone(),
			}
			this.GetRoleFightInfo(crossMsg.FightInfo, false)

			this.SendSocial(crossMsg)
		}
	}
}
func (this *Role) OnYuanHangTrialChallengeResult(msg *serverproto.SSCrossYuanHangTrialChallengeResultAck) {
	if this.GetRoleCross() != nil {
		this.GetRoleCross().OnYuanHangTrialChallengeResult(msg)
	}
}

func (this *Role) YuanHangTrialRankList(startIdx int32) {
	if this.GetRoleCross() != nil {
		this.GetRoleCross().YuanHangTrialRankList(startIdx)
	}
}
func (this *Role) YuanHangTrialInfoQuery(trialUid, trialEndTime uint64) {
	if this.GetRoleCross() != nil {
		this.GetRoleCross().TrialInfoQuery(trialUid, trialEndTime)
	}
}
func (this *Role) YuanHangTrialLog(logTime uint64) {
	if this.GetRoleCross() != nil {
		this.GetRoleCross().TrialLog(logTime)
	}
}

// //巅峰之塔
func (this *Role) TopTowerFightListReq() {
	if this.GetRoleCross() != nil {
		this.GetRoleCross().TopTowerFightListReq()
	}
}
func (this *Role) TopTowerChallengeResultReq(bWin bool, fightIdx int32) {
	if this.GetRoleCross() != nil {
		ret := this.GetRoleCross().TopTowerChallengeResultReq(bWin, fightIdx)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCrossTopTowerChallengeResultAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}
func (this *Role) TopTowerForceWinReq(fightIdx int32) {
	if this.GetRoleCross() != nil {
		ret := this.GetRoleCross().TopTowerForceWinReq(fightIdx)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCCrossTopTowerForceWinAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) PlayerEnterMap(msg *serverproto.CSGCrossPlayerEnterMapReq) {
	if this.roleCross != nil && this.GetState() == ROLE_STATE_ONLINE {
		this.roleCross.PlayerEnterMap(msg)
	}
}
func (this *Role) PlayerLeave(msg *serverproto.CSGCrossPlayerLeaveMapReq) {
	if this.roleCross != nil {
		this.roleCross.PlayerLeave(msg.Pos)
	}
}
func (this *Role) PlayerMoveSync(msg *serverproto.CSGCrossPlayerMapSyncPosReq) {
	if this.roleCross != nil {
		this.roleCross.PlayerMoveSync(msg)
	}
}
func (this *Role) PlayerSyncParam(msg *serverproto.CSGCrossPlayerMapSyncParamReq) {
	if this.roleCross != nil {
		this.roleCross.PlayerSyncParam(msg)
	}
}
func (this *Role) GetPlayerMapShowInfo() *serverproto.PlayerShowInfo {
	if this.roleCross != nil {
		return this.roleCross.getPlayerMapShowInfo()
	}
	return nil
}

const (
	CrossTopTowerMaxMatchNum = 10
)

type RoleCross struct {
	SaveObject

	roleCrossInfo *serverproto.RoleCross

	selfRank  uint32
	selfScore uint64
	totalRank uint32

	//用来判断当前是否已经在地图场景中
	curLineNum int32
	curMapType int32
	curMapSID  string
}

func newRoleCross(r *Role) *RoleCross {
	roleCross := &RoleCross{
		SaveObject: SaveObject{
			role: r,
		},

		roleCrossInfo: &serverproto.RoleCross{
			Yuanhangtrial: &serverproto.RoleYuanHangTrial{},
			Crosstoptower: &serverproto.RoleCrossTopTower{},
		},
	}
	return roleCross
}

func (this *RoleCross) CopyData(data *serverproto.RoleCross) {
	if this.roleCrossInfo.Yuanhangtrial != nil {
		//只拷贝远航试炼数据
		data.Yuanhangtrial = &serverproto.RoleYuanHangTrial{
			TrialData:        this.roleCrossInfo.Yuanhangtrial.TrialData,
			ChallengeNum:     this.roleCrossInfo.Yuanhangtrial.ChallengeNum,
			TrialNum:         this.roleCrossInfo.Yuanhangtrial.TrialNum,
			RefreshTrialType: this.roleCrossInfo.Yuanhangtrial.RefreshTrialType,
			TrialScore:       this.roleCrossInfo.Yuanhangtrial.TrialScore,
		}
	}
}

func (this *RoleCross) Load(msg interface{}) bool {
	//proRole := msg.(*serverproto.Role)
	//if proRole.RoleCross != nil {
	//	this.roleCrossInfo = proRole.RoleCross
	//	if this.roleCrossInfo.Yuanhangtrial == nil {
	//		this.roleCrossInfo.Yuanhangtrial = &serverproto.RoleYuanHangTrial{}
	//	}
	//	if this.roleCrossInfo.Crosstoptower == nil {
	//		this.roleCrossInfo.Crosstoptower = &serverproto.RoleCrossTopTower{}
	//	}
	//
	//	if this.roleCrossInfo.Yuanhangtrial.RefreshTrialType <= 0 {
	//		this.roleCrossInfo.Yuanhangtrial.RefreshTrialType = 1
	//	}
	//}
	return true
}
func (this *RoleCross) OnlineProcess() {

}

func (this *RoleCross) LoadOther(msg interface{}) bool {
	info := msg.(*serverproto.RoleCross)
	if this.roleCrossInfo == nil {
		this.roleCrossInfo = &serverproto.RoleCross{}
	}
	if info.Yuanhangtrial != nil {
		this.roleCrossInfo.Yuanhangtrial = info.Yuanhangtrial
	}
	if this.roleCrossInfo.Yuanhangtrial == nil {
		this.roleCrossInfo.Yuanhangtrial = &serverproto.RoleYuanHangTrial{}
	}

	if this.roleCrossInfo.Crosstoptower == nil {
		this.roleCrossInfo.Crosstoptower = &serverproto.RoleCrossTopTower{}
	}
	if info.Crosstoptower != nil {
		this.roleCrossInfo.Crosstoptower.ValidEndTime = info.Crosstoptower.ValidEndTime
		for idx := 0; idx < len(info.Crosstoptower.FightList); idx++ {
			this.roleCrossInfo.Crosstoptower.FightList = append(this.roleCrossInfo.Crosstoptower.FightList,
				info.Crosstoptower.FightList[idx])
		}
	}

	if this.roleCrossInfo.Yuanhangtrial.RefreshTrialType <= 0 {
		this.roleCrossInfo.Yuanhangtrial.RefreshTrialType = 1
	}
	return true
}

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

	saveMsg := &serverproto.SSCrossDataSaveNtf{
		SaveData: this.roleCrossInfo,
	}
	this.role.SendDb(saveMsg)
}

func (this *RoleCross) DailyReset(notify bool) {
	this.getTrial().TrialNum = 0
	this.getTrial().ChallengeNum = 0

	this.getTopTower().ValidEndTime = 0
	this.getTopTower().FightList = this.getTopTower().FightList[:0]

	this.SetDirty(true)

	if notify {
		this.dataChangeNtf()
	}
}

func (this *RoleCross) getTrial() *serverproto.RoleYuanHangTrial {
	return this.roleCrossInfo.Yuanhangtrial
}
func (this *RoleCross) getTopTower() *serverproto.RoleCrossTopTower {
	return this.roleCrossInfo.Crosstoptower
}

func (this *RoleCross) dataChangeNtf() {
	ntfMsg := &serverproto.SCCrossYuanHangTrialDataNtf{
		YuanhangtrialData: &serverproto.RoleYuanHangTrial{
			ChallengeNum:     this.roleCrossInfo.Yuanhangtrial.ChallengeNum,
			TrialNum:         this.roleCrossInfo.Yuanhangtrial.TrialNum,
			RefreshTrialType: this.roleCrossInfo.Yuanhangtrial.RefreshTrialType,
			TrialData:        this.roleCrossInfo.Yuanhangtrial.TrialData,
			TrialScore:       this.roleCrossInfo.Yuanhangtrial.TrialScore,
		},
	}
	this.role.ReplayGate(ntfMsg, true)
}

func (this *RoleCross) CheckOpenTime() bool {
	nowTime := util.GetCurrentTimeNow()
	tmpStr := util.GetDayByTimeStr2(uint64(nowTime.UnixNano() / 1e6))
	tmpBeginTimeStr := tmpStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCrossYuanHangTrialOpenTimeBeginTime
	beginTime := util.GetTimeByStr(tmpBeginTimeStr)
	if nowTime.Before(beginTime) {
		return false
	} else {
		tmpEndTimeStr := tmpStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCrossYuanHangTrialOpenTimeEndTime
		endTime := util.GetTimeByStr(tmpEndTimeStr)
		if nowTime.After(endTime) {
			return false
		}
	}
	return true
}

func (this *RoleCross) YuanHangTrialViewList() {
	//每次打开界面重新获取自身信息
	if this.getTrial().TrialData != nil && this.getTrial().TrialData.Uid > 0 {
		if !this.getTrial().TrialData.RewardState {
			trial := this.getTrial().TrialData
			crossMsg := &serverproto.SSCrossYuanHangTrialSelfReq{
				SelfUid: this.role.GetUUid(),

				TrialType:     trial.TrialType,
				EndTimeStamp:  trial.EndTimeStamp,
				DurationTime:  trial.DurationTime,
				SelfFightInfo: &serverproto.FightRoleInfo{},
			}
			this.role.GetRoleFightInfo(crossMsg.SelfFightInfo, false)
			this.role.SendSocial(crossMsg)

			//合服成功后如果之前正在远航中的直接入排行榜
			this.addRankScore(0)
		}
	}

	cacheViewList := GetYuanHangTrialViewList()
	if len(cacheViewList) <= 0 {
		crossMsg := &serverproto.SSCrossYuanHangTrialViewListReq{}
		this.role.SendSocial(crossMsg)
	} else {
		ackMsg := &serverproto.SCCrossYuanHangTrialViewListAck{
			TrialViewList: cacheViewList,
		}
		this.role.ReplayGate(ackMsg, true)
	}

	//添加到变更通知列表中
	AddNtfUid(this.role.GetUUid())
}

func (this *RoleCross) RefreshYuanHangTrialType(force bool) serverproto.ErrorCode {
	//if !this.CheckOpenTime() {
	//	return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_OPEN
	//}

	shipType := this.getTrial().RefreshTrialType
	if shipType <= 0 {
		shipType = 1
	}
	convertData, ok := model.ConvertYuanHangTrail[shipType]
	if !ok {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if convertData.ShipRefreshSuccessRate <= 0 {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_TOP_SHIPLEVEL
	}

	//强制升级到顶级消耗
	if force {
		//根据资源列表优先级进行消耗
		retErr := serverproto.ErrorCode_ERROR_SHOP_RESOURCE_NOT_NEOUGH
		for idx := 0; idx < len(convertData.ShipRefreshTopLevelCost); idx++ {
			consumeItem := convertData.ShipRefreshTopLevelCost[idx]
			if this.role.GetRoleBag().CanDelItem(consumeItem.Key, consumeItem.Value) {
				this.role.DelItem(consumeItem.Key, consumeItem.Value, AddItemST{
					AddFrom: AddFrom_CrossYuanHangTrial,
					Notify:  true,
				})
				retErr = serverproto.ErrorCode_ERROR_OK
				break
			}
		}
		if retErr != serverproto.ErrorCode_ERROR_OK {
			return retErr
		}
	} else {
		//消耗特殊道具
		if !this.role.GetRoleBag().CanDelItemList(convertData.ConsumeSpecialItemList) {
			//消耗金币
			if !this.role.GetRoleBag().CanDelItemList(convertData.ConsumeNormalList) {
				return serverproto.ErrorCode_ERROR_SHOP_RESOURCE_NOT_NEOUGH
			}
			this.role.DelItemList(convertData.ConsumeNormalList, AddItemST{
				AddFrom: AddFrom_CrossYuanHangTrial,
				Notify:  true,
			})
		} else {
			this.role.DelItemList(convertData.ConsumeSpecialItemList, AddItemST{
				AddFrom: AddFrom_CrossYuanHangTrial,
				Notify:  true,
			})
		}
	}

	oldShipType := this.getTrial().RefreshTrialType
	retShipType, err := convertData.RefreshShip(force)
	if err != serverproto.ErrorCode_ERROR_OK {
		return err
	}
	this.getTrial().RefreshTrialType = retShipType
	this.SetDirty(true)

	util.InfoF("uid=%v RefreshYuanHangTrialType oldTrialType=%v newTrialType=%v", this.role.GetUUid(), oldShipType, retShipType)

	this.dataChangeNtf()

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCross) YuanHangTrialProcess() serverproto.ErrorCode {
	if !this.CheckOpenTime() {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_OPEN
	}

	if this.getTrial().RefreshTrialType <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	if this.getTrial().TrialNum >= model.GlobalCrossYuanHangTrialMaxNum {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NUM_LIMIT
	}

	nowTime := util.GetTimeMilliseconds()
	if this.getTrial().TrialData == nil {
		this.getTrial().TrialData = &serverproto.YuanHangTrialData{}
	}
	trial := this.getTrial().TrialData
	if trial.Uid > 0 {
		if trial.EndTimeStamp <= nowTime && !trial.RewardState {
			return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_CAN_REWARD
		}
		if !trial.RewardState {
			return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_HAS_TRIAL
		}
	}

	convertData, ok := model.ConvertYuanHangTrail[this.getTrial().RefreshTrialType]
	if !ok {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	durationTime := uint64(convertData.Duration * 1000)
	trial.Uid = this.role.GetUUid()
	trial.TrialType = this.getTrial().RefreshTrialType
	trial.EndTimeStamp = nowTime + durationTime
	trial.RewardState = false
	trial.BeChallengeNum = 0
	trial.DurationTime = convertData.Duration //s
	trial.LineNum = rand.Int31n(10) + 1
	this.getTrial().TrialNum++

	//reset refresh trial type
	this.getTrial().RefreshTrialType = 1
	this.SetDirty(true)
	util.InfoF("uid=%v YuanHangTrialProcess trialData=%v", this.role.GetUUid(), this.getTrial())

	this.dataChangeNtf()

	crossMsg := &serverproto.SSCrossYuanHangTrialReq{
		TrialType:     trial.TrialType,
		EndTimeStamp:  trial.EndTimeStamp,
		DurationTime:  trial.DurationTime, //s
		SelfFightInfo: &serverproto.FightRoleInfo{},
	}
	this.role.GetRoleFightInfo(crossMsg.SelfFightInfo, false)
	this.role.SendSocial(crossMsg)

	//合服后添加(挑战过一次后自动入榜)
	this.addRankScore(0)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCross) YuanHangTrialReward() serverproto.ErrorCode {
	if this.getTrial().TrialData == nil ||
		this.getTrial().TrialData.Uid <= 0 ||
		this.getTrial().TrialData.RewardState ||
		this.getTrial().TrialData.EndTimeStamp <= 0 {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_HAS_REWARD
	}

	nowTime := util.GetTimeMilliseconds()
	trial := this.getTrial().TrialData
	if trial.EndTimeStamp > nowTime {
		return serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_HAS_REWARD
	}

	convertData, ok := model.ConvertYuanHangTrail[this.getTrial().TrialData.TrialType]
	if !ok {
		util.InfoF("uid=%v YuanHangTrialReward not rewardData shipLevel=%v", this.role.GetUUid(), this.getTrial().TrialData.TrialType)
		return serverproto.ErrorCode_ERROR_FAIL
	}
	addItemList := map[int32]int32{}
	for k, v := range convertData.ShipRewardList {
		addItemList[k] += v
	}
	// 特权(飞艇被抢劫掉落减少至)
	vipTransportRobbery := this.role.GetRoleBase().GetVipData(model.Vip_System_TransportRobbery)
	for k, v := range convertData.BeAttackLoseItemList {
		tmpVal := float32(v*this.getTrial().TrialData.BeChallengeNum) * float32(vipTransportRobbery) / 10000.0
		addItemList[k] -= int32(tmpVal)
		if addItemList[k] <= 0 {
			addItemList[k] = 0
			delete(addItemList, k)
		}
	}

	ret := this.role.CanAddItemList(addItemList)
	if ret != serverproto.ErrorCode_ERROR_OK {
		return ret
	}

	this.role.AddItemList(addItemList, AddFrom_CrossYuanHangTrial, true)
	trial.RewardState = true
	this.SetDirty(true)
	this.dataChangeNtf()

	ackMsg := &serverproto.SCCrossYuanHangTrialRewardAck{}
	for k, v := range addItemList {
		if k <= 0 || v <= 0 {
			continue
		}
		ackMsg.RewardList = append(ackMsg.RewardList, &serverproto.KeyValueType{Key: k, Value: v})
	}
	this.role.ReplayGate(ackMsg, true)
	util.InfoF("uid=%v YuanHangTrialReward trialType=%v rewardList=%v", this.role.GetUUid(),
		trial.TrialType, ackMsg.RewardList)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCross) OnYuanHangTrialChallengeResult(msg *serverproto.SSCrossYuanHangTrialChallengeResultAck) {
	ackMsg := &serverproto.SCCrossYuanHangTrialChallengeResultAck{
		Error: msg.Error,
	}
	if this.getTrial() == nil {
		util.FatalF("uid=%v OnYuanHangTrialChallengeResult", this.role.GetUUid())
		return
	}

	if msg.Error != int32(serverproto.ErrorCode_ERROR_OK) {
		this.role.ReplayGate(ackMsg, true)
		//合服后添加(挑战过一次后自动入榜)
		this.addRankScore(0)
	} else {
		convertData, ok := model.ConvertYuanHangTrail[msg.ShipTrialLevel]
		if !ok {
			util.InfoF("uid=%v OnYuanHangTrialChallengeResult not rewardData shipLevel=%v", this.role.GetUUid(), this.getTrial().TrialData.TrialType)
		} else {
			this.getTrial().ChallengeNum++
			this.SetDirty(true)

			//判断可获得奖励次数
			if this.getTrial().ChallengeNum <= model.GlobalCrossYuanHangTrialRewardNum {
				if ret := this.role.CanAddItemList(convertData.BeAttackRewardList); ret != serverproto.ErrorCode_ERROR_OK {
					//通过邮件发送
				} else {
					this.role.AddItemList(convertData.BeAttackRewardList, AddFrom_CrossYuanHangTrial, true)
				}
				ackMsg.RewardList = append(ackMsg.RewardList, convertData.BeAttackRewardListSlice...)
			} else {
				msg.LogData.Type = model2.TrialLogDataType_3
			}

			//添加排行榜积分
			ackMsg.OldScore = this.getTrial().TrialScore
			this.addRankScore(convertData.BeAttackScore)
			ackMsg.NewScore = this.getTrial().TrialScore

			this.dataChangeNtf()
		}
	}
	//添加挑战日志
	if msg.LogData != nil {
		if len(ackMsg.RewardList) > 0 {
			msg.LogData.ItemList = append(msg.LogData.ItemList, ackMsg.RewardList...)
		}
		this.getTrial().LogList = append(this.getTrial().LogList, msg.LogData)
		this.SetDirty(true)
	}
	util.InfoF("uid=%v SCCrossYuanHangTrialChallengeResultAck msg=%v", this.role.GetUUid(), ackMsg)

	this.role.ReplayGate(ackMsg, true)
}

func (this *RoleCross) addRankScore(addScore int32) {
	this.getTrial().TrialScore += addScore
	this.SetDirty(true)

	ntfMsg := &serverproto.SSCrossYuanHangTrialUpdateRankScoreNtf{
		Uid:       this.role.GetUUid(),
		RankScore: uint64(this.getTrial().TrialScore),
	}
	this.role.SendSocial(ntfMsg)
}

func (this *RoleCross) YuanHangTrialRankList(startIdx int32) {
	rankList := GetYuanHangTrialRankList(startIdx)
	if len(rankList) <= 0 || this.selfRank <= 0 || this.selfScore <= 0 {
		ssMsg := &serverproto.SSCrossYuanHangTrialRankListReq{
			Uid:      this.role.GetUUid(),
			StartIdx: startIdx,
		}
		this.role.SendSocial(ssMsg)
	} else {
		ackMsg := &serverproto.SCCrossYuanHangTrialRankListAck{
			SelfRank:  this.selfRank,
			SelfScore: this.selfScore,
			TotalRank: this.totalRank,
			RankList:  rankList,
			StartIdx:  startIdx,
		}
		this.role.ReplayGate(ackMsg, true)
	}
}

func (this *RoleCross) UpdateRankListSelfInfoCache(ssAckMsg *serverproto.SSCrossYuanHangTrialRankListAck) uint64 {
	this.selfRank = ssAckMsg.SelfRank
	this.selfScore = ssAckMsg.SelfScore
	this.totalRank = ssAckMsg.TotalRank
	return this.selfScore
}

func (this *RoleCross) UpdateTrialInfo(beChangeNum int32) {
	if this.roleCrossInfo.Yuanhangtrial.TrialData == nil {
		return
	}

	if this.roleCrossInfo.Yuanhangtrial.TrialData.BeChallengeNum != beChangeNum {
		this.roleCrossInfo.Yuanhangtrial.TrialData.BeChallengeNum = beChangeNum
		this.dataChangeNtf()
	}
}

func (this *RoleCross) AddLog(logData *serverproto.YuanHangTrialLogData) {
	if this.getTrial() != nil {
		// 特权(飞艇被抢劫掉落减少至)
		vipTransportRobbery := this.role.GetRoleBase().GetVipData(model.Vip_System_TransportRobbery)
		for idx := 0; idx < len(logData.ItemList); idx++ {
			tmpVal := float32(logData.ItemList[idx].Value) / 10000.0 * float32(vipTransportRobbery)
			logData.ItemList[idx].Value = int32(tmpVal)
		}
		this.getTrial().LogList = append(this.getTrial().LogList, logData)
		this.SetDirty(true)
		if len(this.getTrial().LogList) > MaxUidLogCount+10 {
			tmpIdx := len(this.getTrial().LogList) - MaxUidLogCount
			this.getTrial().LogList = this.getTrial().LogList[tmpIdx:]
			this.SetDirty(true)
		}
	}
}

// 查询飞艇信息
func (this *RoleCross) TrialInfoQuery(trialUid, trialEndTime uint64) {
	crossMsg := &serverproto.SSCrossYuanHangTrialInfoReq{
		TrialUid:     trialUid,
		TrialEndTime: trialEndTime,
	}
	if !this.role.SendSocial(crossMsg) {
		ackMsg := &serverproto.SCCrossYuanHangTrialInfoAck{
			Error: int32(serverproto.ErrorCode_ERROR_CROSS_YUANHANGTRIAL_NOT_JOIN),
		}
		this.role.ReplayGate(ackMsg, true)
	}
}

const MaxUidLogCount = 50

func (this *RoleCross) TrialLog(logTime uint64) {
	ackMsg := &serverproto.SCCrossYuanHangTrialLogAck{}
	if len(this.getTrial().LogList) > MaxUidLogCount {
		tmpIdx := len(this.getTrial().LogList) - MaxUidLogCount
		this.getTrial().LogList = this.getTrial().LogList[tmpIdx:]
		this.SetDirty(true)
	}

	//获取最新列表
	if logTime <= 0 {
		starIdx := len(this.getTrial().LogList)
		if starIdx > 0 {
			for idx := starIdx - 1; idx >= 0; idx-- {
				ackMsg.LogList = append(ackMsg.LogList, this.getTrial().LogList[idx])
				if len(ackMsg.LogList) >= 10 {
					break
				}
			}
		}
	} else {
		for idx := len(this.getTrial().LogList) - 1; idx >= 0; idx-- {
			if this.getTrial().LogList[idx].RecordTime < logTime {
				ackMsg.LogList = append(ackMsg.LogList, this.getTrial().LogList[idx])
				if len(ackMsg.LogList) >= 10 {
					break
				}
			}
		}
	}

	if len(ackMsg.LogList) < 10 {
		ackMsg.IsEnd = true
	}

	this.role.ReplayGate(ackMsg, true)
}

// //巅峰之塔
// 当前数据是否合法
func (this *RoleCross) topTowerTimeInvalid() bool {
	if this.roleCrossInfo.Crosstoptower == nil {
		return false
	}
	nowTime := util.GetTimeMilliseconds()
	diffDay := util.GetDurationDay2(this.roleCrossInfo.Crosstoptower.ValidEndTime, nowTime)
	if diffDay > 1 {
		return true
	}
	return false
}
func (this *RoleCross) checkTopTowerOpenTime() bool {
	nowTime := util.GetCurrentTimeNow()
	tmpStr := util.GetDayByTimeStr2(uint64(nowTime.UnixNano() / 1e6))
	tmpBeginTimeStr := tmpStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCrossTopTowerOpenTimeBeginTime
	beginTime := util.GetTimeByStr(tmpBeginTimeStr)
	if nowTime.Before(beginTime) {
		return true
	} else {
		tmpEndTimeStr := tmpStr.Format(util.DATE_FORMAT1) + " " + model.GlobalCrossTopTowerOpenTimeEndTime
		endTime := util.GetTimeByStr(tmpEndTimeStr)
		if nowTime.After(endTime) {
			return true
		}
	}
	return false
}

func (this *RoleCross) getFightListList(towerData *serverproto.RoleCrossTopTower) {
	towerData.ValidEndTime = this.getTopTower().ValidEndTime

	for idx := 0; idx < len(this.getTopTower().FightList); idx++ {
		if this.getTopTower().FightList[idx].FightInfo == nil {
			this.getTopTower().FightList[idx].FightInfo = model.ConvertRobotCrossTopTower[0].FightInfo
		}
		tmpInfo := &serverproto.TopTowerFightRoleInfo{
			Idx:         this.getTopTower().FightList[idx].Idx,
			RewardState: this.getTopTower().FightList[idx].RewardState,
			FightInfo: &serverproto.FightRoleInfo{
				IsRobot:     this.getTopTower().FightList[idx].FightInfo.IsRobot,
				BriefInfo:   this.getTopTower().FightList[idx].FightInfo.BriefInfo,
				JobLevel:    this.getTopTower().FightList[idx].FightInfo.JobLevel,
				FashionData: this.getTopTower().FightList[idx].FightInfo.FashionData,
			},
		}
		towerData.FightList = append(towerData.FightList, tmpInfo)
	}
}

func (this *RoleCross) TopTowerFightListReq() {
	if this.topTowerTimeInvalid() || (this.getTopTower() != nil && len(this.getTopTower().FightList) <= 0) {
		//重新获取对阵玩家
		crossSSMsg := &serverproto.SSCrossTopTowerMatchFightReq{}
		this.role.SendSocial(crossSSMsg)
	} else {
		ackMsg := &serverproto.SCCrossTopTowerFightListAck{
			ToptowerData: &serverproto.RoleCrossTopTower{},
		}
		if this.getTopTower() == nil {
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
		} else {
			this.getFightListList(ackMsg.ToptowerData)
		}

		this.role.ReplayGate(ackMsg, true)
	}
}
func (this *RoleCross) OnTopTowerFightMatchList(ssAckMsg *serverproto.SSCrossTopTowerMatchFightAck) {
	ackMsg := &serverproto.SCCrossTopTowerFightListAck{
		Error: ssAckMsg.Error,
	}
	if ssAckMsg.Error != int32(serverproto.ErrorCode_ERROR_OK) {
		this.role.ReplayGate(ackMsg, true)
		return
	}

	//对应层数上无数据需要填充对应的机器人，且填充的机器人不能重复
	this.getTopTower().FightList = ssAckMsg.FightInfoList
	this.getTopTower().ValidEndTime = util.GetTimeMilliseconds()
	this.fillMatchListWithRobot()
	this.SetDirty(true)

	ackMsg.ToptowerData = &serverproto.RoleCrossTopTower{}
	this.getFightListList(ackMsg.ToptowerData)

	this.role.ReplayGate(ackMsg, true)
}

func (this *RoleCross) topTowerGetFightInfoByIdx(fightIdx int32) *serverproto.TopTowerFightRoleInfo {
	for idx := 0; idx < len(this.getTopTower().FightList); idx++ {
		if this.getTopTower().FightList[idx].Idx == fightIdx {
			return this.getTopTower().FightList[idx]
		}
	}
	return nil
}
func (this *RoleCross) fillMatchListWithRobot() {
	if len(this.getTopTower().FightList) >= CrossTopTowerMaxMatchNum ||
		len(model.ConvertRobotCrossTopTower) <= 0 {
		return
	}

	randIdx := rand.Intn(len(model.ConvertRobotCrossTopTower))
	for idx := 1; idx <= CrossTopTowerMaxMatchNum; idx++ {
		fightInfo := this.topTowerGetFightInfoByIdx(int32(idx))
		if fightInfo != nil {
			continue
		}

		robotInfo := &serverproto.TopTowerFightRoleInfo{
			Idx:       int32(idx),
			FightInfo: model.ConvertRobotCrossTopTower[randIdx].FightInfo,
		}
		this.getTopTower().FightList = append(this.getTopTower().FightList, robotInfo)

		randIdx++
		if randIdx >= len(model.ConvertRobotCrossTopTower) {
			randIdx = 0
		}
	}

	sort.Slice(this.getTopTower().FightList, func(i, j int) bool {
		return this.getTopTower().FightList[i].Idx < this.getTopTower().FightList[j].Idx
	})
}

func (this *RoleCross) TopTowerChallengeReq(fightIdx int32) (serverproto.ErrorCode, *serverproto.TopTowerFightRoleInfo) {
	if !this.checkTopTowerOpenTime() {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_OPEN, nil
	}
	if this.topTowerTimeInvalid() {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_INVALID, nil
	}

	fightInfo := this.topTowerGetFightInfoByIdx(fightIdx)
	if fightInfo == nil {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_FIND, nil
	}
	if fightInfo.RewardState {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_HAS_REWARD, nil
	}
	return serverproto.ErrorCode_ERROR_OK, fightInfo
}

func (this *RoleCross) TopTowerChallengeResultReq(bWin bool, fightIdx int32) serverproto.ErrorCode {
	if !bWin {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if !this.checkTopTowerOpenTime() {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_OPEN
	}
	if this.topTowerTimeInvalid() {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_INVALID
	}

	fightInfo := this.topTowerGetFightInfoByIdx(fightIdx)
	if fightInfo == nil {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_FIND
	}
	if fightInfo.RewardState {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_HAS_REWARD
	}

	//获取奖励
	ackMsg := &serverproto.SCCrossTopTowerChallengeResultAck{}
	for idx := 0; idx < len(model.ConvertTopTowerRewardList); idx++ {
		//找到对应奖励
		if model.ConvertTopTowerRewardList[idx].Idx == fightInfo.Idx {
			this.role.AddItemList(model.ConvertTopTowerRewardList[idx].WinRewardList, AddFrom_CrossTopTower, true)

			for k, v := range model.ConvertTopTowerRewardList[idx].WinRewardList {
				ackMsg.RewardList = append(ackMsg.RewardList, &serverproto.KeyValueType{Key: k, Value: v})
			}

			fightInfo.RewardState = true
			this.SetDirty(true)

			break
		}
	}
	if len(ackMsg.RewardList) <= 0 {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_FIND
	}
	ackMsg.FightInfo = fightInfo
	this.role.ReplayGate(ackMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleCross) TopTowerForceWinReq(fightIdx int32) serverproto.ErrorCode {
	if !this.checkTopTowerOpenTime() {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_OPEN
	}

	if this.topTowerTimeInvalid() {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_INVALID
	}

	fightInfo := this.topTowerGetFightInfoByIdx(fightIdx)
	if fightInfo == nil {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_FIND
	}
	if fightInfo.RewardState {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_HAS_REWARD
	}

	//获取奖励
	ackMsg := &serverproto.SCCrossTopTowerForceWinAck{}
	for idx := 0; idx < len(model.ConvertTopTowerRewardList); idx++ {
		//找到对应奖励
		if model.ConvertTopTowerRewardList[idx].Idx == fightInfo.Idx {
			//消耗是否满足
			if !this.role.GetRoleBag().CanDelItemList(model.ConvertTopTowerRewardList[idx].ForceWinCostList) {
				return this.role.GetResNotice(int32(serverproto.ResType_Res_Rmb))
			}
			this.role.DelItemList(model.ConvertTopTowerRewardList[idx].ForceWinCostList, AddItemST{AddFrom: AddFrom_CrossTopTower})

			this.role.AddItemList(model.ConvertTopTowerRewardList[idx].WinRewardList, AddFrom_CrossTopTower, true)

			for k, v := range model.ConvertTopTowerRewardList[idx].WinRewardList {
				ackMsg.RewardList = append(ackMsg.RewardList, &serverproto.KeyValueType{Key: k, Value: v})
			}

			fightInfo.RewardState = true
			this.SetDirty(true)

			break
		}
	}
	if len(ackMsg.RewardList) <= 0 {
		return serverproto.ErrorCode_ERROR_CROSS_TOPTOWER_NOT_FIND
	}

	ackMsg.FightInfo = fightInfo
	this.role.ReplayGate(ackMsg, true)

	//更新被买路排行榜
	if !fightInfo.FightInfo.IsRobot {
		crossSSMsg := &serverproto.SSCrossTopTowerForceWinRankUpdateNtf{
			FightUid: fightInfo.FightInfo.BriefInfo.Uid,
		}
		this.role.SendSocial(crossSSMsg)
	}

	return serverproto.ErrorCode_ERROR_OK
}

////全局跨服地图相关
//PlayerEnterMap(msg *serverproto.CSGCrossPlayerEnterMapReq)
//PlayerLeave(msg *serverproto.CSGCrossPlayerLeaveMapReq)
//PlayerMoveSync(msg *serverproto.CSGCrossPlayerMapSyncPosReq)
//
////获取玩家地图展示信息
//GetPlayerMapShowInfo(info *serverproto.PlayerShowInfo)

func (this *RoleCross) getPlayerMapShowInfo() *serverproto.PlayerShowInfo {
	info := &serverproto.PlayerShowInfo{
		Uid:         this.role.GetUUid(),
		Level:       this.role.GetRoleLevel(),
		VipLevel:    this.role.GetRoleVipLevel(),
		Gender:      this.role.GetRoleBase().GetRoleSex(),
		JobId:       this.role.GetRoleBase().RoleData().HeroData.ConfigId,
		NickName:    this.role.GetRoleBase().GetRoleName(),
		FashionData: this.role.GetRoleBase().roleBase.FashionData,
		HeadId:      this.role.GetHeadId(),
		ImgId:       this.role.GetImageId(),
		HeadFrameId: this.role.GetRoleBase().RoleData().GetHeadFrameId(),
		FightPower:  int32(this.role.roleBattleAttr.curTotalFightPower),
		FromZone:    this.role.GetSelectZone(),
		RealZone:    int32(service.GetServiceConfig().Node.Zone),
	}
	return info
}

func (this *RoleCross) GetCrossCurSpaceId() int32 {
	return this.curLineNum
}

func (this *RoleCross) PlayerEnterMap(msg *serverproto.CSGCrossPlayerEnterMapReq) {
	//todo
	// 获取进入地图位置
	if this.curLineNum > 0 {
		////玩家已经在当前地图
		//if this.curLineNum == msg.LineNum {
		//	return
		//}
		this.PlayerLeave(nil)
	}
	//选择线路未满的房间(线路号从小达到)
	targetServiceNode := ""
	if msg.LineNum <= 0 {
		targetServiceNode, msg.LineNum = GetServerStateByType(msg.MapType)
	} else {
		targetServiceNode = GetServerStateByTypeAndLine(msg.MapType, msg.LineNum)
	}
	if targetServiceNode == "" {
		util.InfoF("uid=%v PlayerEnterMap targetServiceNode nil maptype=%v", this.role.GetUUid(), msg.MapType)
		ackMsg := &serverproto.SCGCrossPlayerEnterMapAck{
			Error: int32(serverproto.ErrorCode_ERROR_FAIL),
		}
		this.role.ReplayGate(ackMsg, true)
		return
	}

	//包括切换地图
	ssEnterMsg := &serverproto.SSGCrossMapEnterReq{
		AoiLine:  msg.LineNum,
		MapType:  msg.MapType,
		ShowInfo: this.getPlayerMapShowInfo(),
		Pos:      msg.Pos,
		Dir:      msg.Dir,
		SelfMapParam: &serverproto.SelfCrossMapParam{
			LoverUid: 1,
		},
	}
	this.role.SendSocialWithSID(ssEnterMsg, targetServiceNode)
}

func (this *RoleCross) OnPlayerEnterMapSuccess(msg *serverproto.SSGCrossMapEnterAck) {
	this.curLineNum = msg.LineNum
	this.curMapType = msg.MapType
	this.curMapSID = msg.MapSid
}

func (this *RoleCross) PlayerLeave(position *serverproto.Vector3) {
	if this.curLineNum > 0 && this.curMapType > 0 {
		ssLeaveMsg := &serverproto.SSGCrossMapLeaveReq{
			Pos: position,
		}
		this.role.SendSocial(ssLeaveMsg)

		//reset map aoi data
		this.curLineNum = 0
		this.curMapType = 0
		this.curMapSID = ""
	}
}

func (this *RoleCross) PlayerMoveSync(msg *serverproto.CSGCrossPlayerMapSyncPosReq) {
	if this.curLineNum > 0 && msg.Pos != nil {
		ssSyncMsg := &serverproto.SSGCrossMapSyncPosReq{
			Pos:        msg.Pos,
			Dir:        msg.Dir,
			CurSpaceId: this.curLineNum,
		}
		this.role.SendSocial(ssSyncMsg)
	}
}
func (this *RoleCross) PlayerSyncParam(msg *serverproto.CSGCrossPlayerMapSyncParamReq) {
	if this.curLineNum > 0 && msg.Pos != nil {
		ssSyncMsg := &serverproto.SSGCrossMapSyncParamReq{
			Pos:        msg.Pos,
			ParamId:    msg.ParamId,
			CurSpaceId: this.curLineNum,
		}
		this.role.SendSocial(ssSyncMsg)
	}
}

func (this *RoleCross) FashionShowChangeNtf() {
	if this.curLineNum > 0 {
		showInfo := &serverproto.PlayerShowInfo{
			Uid:         this.role.GetUUid(),
			FashionData: this.role.GetRoleBase().roleBase.FashionData,
		}

		ssCrossMsg := &serverproto.SSGCrossMapUnitShowUpdateNtf{
			CurSpaceId: this.curLineNum,
		}
		ssCrossMsg.ShowInfoList = append(ssCrossMsg.ShowInfoList, showInfo)

		this.role.SendSocial(ssCrossMsg)
	}
}