RoServer/RO_Server_Trunk-branch_bt/roserver/battleboss/model/boss_manager.go

package model

import (
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/baseserver/set"
	"roserver/serverproto"
	"time"
)

const MAX_AOI_LINE_BOSS_NUM = 100
const MAX_BOSS_CHALLENGE_PLAYER_NUM = 8
const BOSS_REWARD_MAIL_CONFIG_ID_Other = 2

const (
	BOSS_RESULT_WIN      = 1
	BOSS_RESULT_TIME_OUT = 2

	INIT_STATE_NONE   = 0
	INIT_STATE_INIT   = 1 //获取数据
	INIT_STATE_FINISH = 2 //初始化完成
)
const NO_AOILINE_BOSS = "NOAOI"
const MAX_NO_AOILINE_BOSS_NUM = 20

type RefreshBossInfo struct {
	posId         int32
	summonTimeIdx int
	bossData      *model.ConvertWorldBossData

	refreshTime time.Time //刷新boss的时间错，逻辑中使用

	stop bool
}

func (this *RefreshBossInfo) printDebugString(addStr string) {
	util.DebugF("msg=%v pos=%v bossid=%v summonidx=%v refreshtime=%v", addStr, this.posId,
		this.bossData.Id, this.summonTimeIdx, this.refreshTime.String())
}

////////////////////////////////AoiLineBossManager
type WorldBossManager struct {
	mapRouterNode string
	socialNode    string
	updateTimer   util.ServerTimer //定时器

	bossList map[uint64]*PlayerBoss //[bossId *PlayerBoss]

	//挑战玩家所在boss场景
	challengePlayerList map[uint64]*PlayerBoss

	initStartUp                 int32 //维护时需要加载维护前的boss状态信息(血量，攻击记录)
	refreshBossInfoList         map[int32]*RefreshBossInfo
	refreshBossInfoActivityList map[int32]*RefreshBossInfo

	startUpDayTime time.Time //开服整数点时间
	startDiffDay   int32     //当前距离开服时间的天数
}

func newWorldBossManager() *WorldBossManager {
	mag := &WorldBossManager{
		bossList:                    map[uint64]*PlayerBoss{},
		challengePlayerList:         map[uint64]*PlayerBoss{},
		mapRouterNode:               "",
		socialNode:                  "",
		refreshBossInfoList:         map[int32]*RefreshBossInfo{},
		refreshBossInfoActivityList: map[int32]*RefreshBossInfo{},
	}

	mag.challengePlayerList = map[uint64]*PlayerBoss{}
	mag.updateTimer = util.NewDurationTimer(util.GetTimeMilliseconds(), 500)

	mag.initRefresh()

	return mag
}

//获取最近一天的boss刷新时间
func (this *WorldBossManager) getCurrentDayBossData(currentDay int32, pos int32) *model.ConvertWorldBossData {
	valList, ok := model.ConvertWorldBoss[pos]
	if !ok {
		return nil
	}

	var retData *model.ConvertWorldBossData = nil
	for idx := 0; idx < len(valList); idx++ {
		if valList[idx].StartDay <= currentDay {
			retData = valList[idx]
		} else if valList[idx].StartDay > currentDay {
			break
		}
	}
	if retData == nil {
		if len(valList) > 0 {
			retData = valList[len(valList)-1]
		}
	}
	return retData
}

func (this *WorldBossManager) initRefresh() bool {
	startUpTime := service.GetServiceStartupTime() //ms
	if startUpTime <= 0 {
		return false
	}

	this.startUpDayTime = util.GetDayByTimeStr2(startUpTime)
	this.startDiffDay = util.GetDurationDay1(startUpTime, uint64(util.GetTimeMilliseconds())) + 1

	//util.DebugF("nowhourtime=%v", nowHourTime.String())
	//普通世界boss
	for key := range model.ConvertWorldBoss {
		tmp := this.getRefreshInfo(key)
		tmp.printDebugString("initrefresh")
	}
	//活动世界boss(变身)
	for _, bossDataInfo := range model.ConvertWorldBossChangePlayList {
		this.getRefreshInfoChangePlay(bossDataInfo)
	}

	this.initStartUp = INIT_STATE_FINISH

	//开服时间
	return true
}

func (this *WorldBossManager) getRefreshInfo(pos int32) *RefreshBossInfo {
	bFind := false
	k := 0
	tmpStartDiffDay := this.startDiffDay
	nowHourTime := util.GetHourByTime(0)
	//key == 0 表示最后一个位置
	bossDataInfo := this.getCurrentDayBossData(tmpStartDiffDay, pos)
	if bossDataInfo == nil {
		return nil
	}
	for k = 0; k < len(bossDataInfo.SummonTime); k++ {
		if bossDataInfo.SummonTime[k].After(nowHourTime) {
			bFind = true
			break
		}
	}

	if !bFind {
		k = 0
		tmpStartDiffDay++
		bossDataInfo = this.getCurrentDayBossData(tmpStartDiffDay, pos)
		if bossDataInfo != nil && len(bossDataInfo.SummonTime) > 0 {
			bFind = true
		}
	}

	if bFind {
		tmpTime := this.startUpDayTime.AddDate(0, 0, int(tmpStartDiffDay-1))
		tmpSummonTime := bossDataInfo.SummonTime[k].Hour()*60*60 + bossDataInfo.SummonTime[k].Minute()*60 + bossDataInfo.SummonTime[k].Second()
		tmpTime = tmpTime.Add(time.Duration(tmpSummonTime) * time.Second)
		//util.DebugF("%v tmpTime:%v :%v", key, tmpTime.String(), tmpSummonTime)
		refreshInfo := &RefreshBossInfo{
			posId:       bossDataInfo.RefreshId,
			bossData:    bossDataInfo,
			refreshTime: tmpTime,
		}
		refreshInfo.summonTimeIdx = k + int(tmpStartDiffDay-1)*len(bossDataInfo.SummonTime)
		this.refreshBossInfoList[pos] = refreshInfo
		return refreshInfo
	}
	return nil
}

func (this *WorldBossManager) getRefreshInfoChangePlay(bossDataInfo *model.ConvertWorldBossData) *RefreshBossInfo {
	tmpStartDiffDay := this.startDiffDay
	nowHourTime := util.GetHourByTime(0)

	//<=0表示根据给定的时间来开启[BossBeginTime,BossEndTime]
	if bossDataInfo.StartDay <= 0 {
		bFind := false
		k := 0
		for k = 0; k < len(bossDataInfo.SummonTime); k++ {
			if bossDataInfo.SummonTime[k].After(nowHourTime) {
				bFind = true
				break
			}
		}
		if !bFind {
			k = 0
			tmpStartDiffDay++
			bFind = true
		}

		tmpTime := this.startUpDayTime.AddDate(0, 0, int(tmpStartDiffDay-1))
		tmpSummonTime := bossDataInfo.SummonTime[k].Hour()*60*60 + bossDataInfo.SummonTime[k].Minute()*60 + bossDataInfo.SummonTime[k].Second()
		tmpTime = tmpTime.Add(time.Duration(tmpSummonTime) * time.Second)

		refreshInfo := &RefreshBossInfo{
			bossData:    bossDataInfo,
			refreshTime: tmpTime,
		}
		refreshInfo.summonTimeIdx = k + int(tmpStartDiffDay-1)*len(bossDataInfo.SummonTime)
		this.refreshBossInfoActivityList[refreshInfo.bossData.Id] = refreshInfo

		util.DebugF("getRefreshInfoChangePlay bossid=%v summonidx=%v refreshtime=%v",
			bossDataInfo.Id, refreshInfo.summonTimeIdx, tmpTime.String())
		return refreshInfo
	} else {
		//todo...
	}

	return nil
}

func (this *WorldBossManager) refreshBoss() {
	if len(this.refreshBossInfoList) <= 0 {
		return
	}

	nowTime := util.GetCurrentTimeNow()
	for _, info := range this.refreshBossInfoList {
		//util.InfoF("now=%v summon=%v", nowHourTime.String(), info.bossData.SummonTime[info.summonTimeIdx].String())
		if nowTime.After(info.refreshTime) {
			//refresh key-pos boss
			//1,remove old-pos boss
			//2,add new-pos boss
			bRefresh := true
			for _, bossVal := range this.bossList {
				if bossVal.summonBossType != model.SummonBossType_Normal {
					continue
				}
				if int32(bossVal.bossUid)%model.WorldBossListNum == info.posId {
					//正在挑战中的boss不进行刷新处理
					if bossVal.GetState() == BOSS_STATE_FIGHTING {
						bRefresh = false
					} else {
						DelWorldBossList(bossVal)
						delete(this.bossList, bossVal.bossUid)
					}
					break
				}
			}

			if bRefresh {
				this.AddBossFromRefresh(info.bossData, int32(info.summonTimeIdx))
			}

			tmpIdx := info.summonTimeIdx % len(info.bossData.SummonTime)
			//if tmpIdx <= 0 && info.summonTimeIdx > 0 {
			//	tmpIdx = len(info.bossData.SummonTime)
			//}
			startUpTime := service.GetServiceStartupTime()
			this.startDiffDay = util.GetDurationDay1(startUpTime, uint64(util.GetTimeMilliseconds())) + 1
			tmpAddDay := this.startDiffDay

			if len(info.bossData.SummonTime) <= tmpIdx+1 {
				//boss存活时间可能到下一天
				//判断下一天是否有新的boss刷新
				if info.refreshTime.Day() == nowTime.Day() {
					//如果当前刷新时间已经用完，则直接找第二天的刷新时间(需要判断刷新时对应的天数和当前时间做比较)
					tmpAddDay++
				}
				nextBossInfo := this.getCurrentDayBossData(tmpAddDay, info.posId)
				info.bossData = nextBossInfo
			}

			if nowTime.Day() != info.refreshTime.Day() { //应对测试期间之前改天数的方式
				tmpPosId := info.posId
				info = this.getRefreshInfo(tmpPosId)
			} else {
				info.summonTimeIdx++

				k := info.summonTimeIdx % len(info.bossData.SummonTime)
				tmpTime := this.startUpDayTime.AddDate(0, 0, int(tmpAddDay-1))
				tmpSummonTime := info.bossData.SummonTime[k].Hour()*60*60 + info.bossData.SummonTime[k].Minute()*60 + info.bossData.SummonTime[k].Second()
				tmpTime = tmpTime.Add(time.Duration(tmpSummonTime) * time.Second)
				info.refreshTime = tmpTime
			}
			info.printDebugString("RefreshBoss")
		}
	}
}

func (this *WorldBossManager) refreshBossChangePlay(ms uint64) {
	if len(this.refreshBossInfoActivityList) <= 0 {
		return
	}
	nowTime := util.GetTimeByUint64(ms)
	for key, info := range this.refreshBossInfoActivityList {
		//活动过期
		if nowTime.After(info.bossData.BossEndTime) {
			bossVal, ok := this.bossList[uint64(info.bossData.Id)]
			if ok {
				bossVal.SwitchState(int32(BOSS_STATE_TIME_OUT), nil)
				delete(this.bossList, uint64(info.bossData.Id))
			}
			delete(this.refreshBossInfoActivityList, key)
			continue
		}

		if nowTime.Before(info.refreshTime) || nowTime.Before(info.bossData.BossBeginTime) {
			continue
		}

		bRefresh := true
		bossVal, ok := this.bossList[uint64(info.bossData.Id)]
		if ok {
			if bossVal.GetState() == BOSS_STATE_FIGHTING {
				bRefresh = false
			} else {
				DelWorldBossList(bossVal)
				delete(this.bossList, bossVal.bossUid)
			}
		}
		if bRefresh {
			this.AddBossFromRefresh(info.bossData, int32(info.summonTimeIdx))
		}

		tmpIdx := info.summonTimeIdx % len(info.bossData.SummonTime)
		startUpTime := service.GetServiceStartupTime()
		this.startDiffDay = util.GetDurationDay1(startUpTime, uint64(util.GetTimeMilliseconds())) + 1
		tmpAddDay := this.startDiffDay
		if len(info.bossData.SummonTime) <= tmpIdx+1 {
			//boss存活时间可能到下一天
			//判断下一天是否有新的boss刷新
			if info.refreshTime.Day() == nowTime.Day() {
				//如果当前刷新时间已经用完，则直接找第二天的刷新时间(需要判断刷新时对应的天数和当前时间做比较)
				tmpAddDay++
			}
			info.summonTimeIdx = 0
		} else {
			info.summonTimeIdx++
		}

		if nowTime.Day() != info.refreshTime.Day() { //应对测试期间之前改天数的方式
			info = this.getRefreshInfoChangePlay(info.bossData)
		} else {
			//info.summonTimeIdx++

			k := info.summonTimeIdx % len(info.bossData.SummonTime)
			tmpTime := this.startUpDayTime.AddDate(0, 0, int(tmpAddDay-1))
			tmpSummonTime := info.bossData.SummonTime[k].Hour()*60*60 + info.bossData.SummonTime[k].Minute()*60 + info.bossData.SummonTime[k].Second()
			tmpTime = tmpTime.Add(time.Duration(tmpSummonTime) * time.Second)
			info.refreshTime = tmpTime
		}

		if bRefresh {
			util.DebugF("nextWorldBossRefreshTime=%v", info.refreshTime.String())
		}

		info.printDebugString("RefreshBoss")
	}
}

func (this *WorldBossManager) PlayerOffline(uid uint64) {
	if playerBoss, ok := this.challengePlayerList[uid]; ok {
		playerBoss.leaveNotify(uid)
	}
}

func (this *WorldBossManager) Update(ms uint64) {
	switch this.initStartUp {
	case INIT_STATE_NONE:
		if GetWorldBossList(this) {
			this.initStartUp = INIT_STATE_INIT
			util.InfoF("load from db worldboss len=%v", len(this.bossList))
		} else {
			this.initStartUp = INIT_STATE_NONE
			return
		}
	case INIT_STATE_INIT:
		if !this.initRefresh() {
			return
		}
	}

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

	for _, boss := range this.bossList {
		boss.broadcastBossHp()
		if boss.finish {
			//不从列表中删除，客户端实现需要
			//delete(this.bossList, boss.bossUid)
			continue
		}
		if !boss.checkTimeValid(ms) {
			boss.SwitchState(int32(BOSS_STATE_TIME_OUT), nil)
		}

		//处理boss的定时掉血。
		if boss.GetState() != BOSS_STATE_TIME_OUT && boss.GetState() != BOSS_STATE_DIED {
			boss.updateBossHp(ms)
		}
	}

	//判断是否需要重新刷新boss
	this.refreshBoss()             //普通世界boss
	this.refreshBossChangePlay(ms) //活动世界boss
}

//DB中加载获取boss状态信息
func (this *WorldBossManager) AddBossFromDB(stateInfo *serverproto.WorldBossStateInfo) bool {
	var summonId int32 = 0
	if stateInfo.SummonBossType == model.SummonBossType_Normal {
		cfgData, ok := model.ConvertWorldBossList[stateInfo.BossId]
		if !ok {
			return false
		}
		summonId = cfgData.SummonId
	} else {
		cfgData, ok := model.ConvertWorldBossChangePlayList[stateInfo.BossId]
		if !ok {
			return false
		}
		summonId = cfgData.SummonId
	}

	npcCfgData, ok1 := serverproto.NpcCfgLoader[summonId]
	if !ok1 {
		return false
	}

	playerBoss := newPlayerBoss(this)
	playerBoss.bossUid = uint64(stateInfo.BossId)
	playerBoss.summonBossId = summonId
	playerBoss.summonBossType = stateInfo.SummonBossType
	playerBoss.summonTime = stateInfo.SummonTime
	playerBoss.durationTime = uint64(stateInfo.DurationTime) * 1000
	playerBoss.summonBossIdx = stateInfo.SummonIdx
	playerBoss.SetTotalHp(stateInfo.Hp)
	playerBoss.maxHp = int32(npcCfgData.Hp)
	playerBoss.lastHPReduceTime = 0
	if playerBoss.totalHp < playerBoss.maxHp {
		playerBoss.lastHPReduceTime = util.GetTimeMilliseconds()
	}
	//add challenge uid
	for idx := 0; idx < len(stateInfo.UidList); idx++ {
		playerBoss.allChallengeList.Add(stateInfo.UidList[idx])
	}

	nowTime := util.GetTimeMilliseconds()
	endTime := stateInfo.SummonTime + uint64(stateInfo.DurationTime)*1000
	if endTime <= nowTime {
		playerBoss.SwitchState(int32(BOSS_STATE_TIME_OUT), true) //表示来自db
	} else {

		if playerBoss.totalHp <= 0 {
			playerBoss.SwitchState(int32(BOSS_STATE_DIED), true) //表示来自db
		} else {
			playerBoss.SwitchState(int32(BOSS_STATE_FIGHTING), nil)
		}
	}

	this.bossList[playerBoss.bossUid] = playerBoss

	util.DebugF("msg=AddBossFromDB bossid=%v summonidx=%v", playerBoss.bossUid, playerBoss.summonBossIdx)
	return true
}

const SystemMessageType_WorldBoss = 6 //召喚世界BOSS通知
func (this *WorldBossManager) AddBossFromRefresh(bossData *model.ConvertWorldBossData, summonIdx int32) bool {
	var summonId int32 = 0
	if bossData.SummonType == model.SummonBossType_Normal {
		cfgData, ok := serverproto.WorldBossCfgLoader[bossData.Id]
		if !ok {
			util.InfoF("AddBossFromRefresh WorldBossCfgLoader not find boss=%v ", bossData.Id)
			return false
		}

		summonId = cfgData.SummonId
	} else {
		cfgData, ok := serverproto.WorldBossChangePlayCfgLoader[bossData.Id]
		if !ok {
			util.InfoF("AddBossFromRefresh WorldBossChangePlayCfgLoader not find boss=%v ", bossData.Id)
			return false
		}

		summonId = cfgData.SummonId
	}

	npcCfgData, ok1 := serverproto.NpcCfgLoader[summonId]
	if !ok1 {
		util.InfoF("AddBossFromRefresh npc data not find summonid=%v ", summonId)
		return false
	}
	summonHp := int32(npcCfgData.Hp)

	playerBoss := newPlayerBoss(this)
	playerBoss.bossUid = uint64(bossData.Id)
	playerBoss.summonBossId = summonId
	playerBoss.summonTime = util.GetTimeMilliseconds()
	playerBoss.durationTime = uint64(bossData.DurationTime) * 1000
	playerBoss.summonBossIdx = summonIdx
	playerBoss.SetTotalHp(summonHp)
	playerBoss.lastHPReduceTime = 0
	playerBoss.summonBossType = bossData.SummonType

	playerBoss.SwitchState(int32(BOSS_STATE_FIGHTING), nil)

	this.bossList[playerBoss.bossUid] = playerBoss

	//add to db
	UpdateWorldBossList(playerBoss)

	util.DebugF("msg=AddBossFromRefresh bossid=%v summonidx=%v", bossData.Id, summonIdx)

	//发送给所有game服务器
	ssMsgNtf := &serverproto.SSSystemMessageNtf{}
	ssMsg := &serverproto.SystemMessage{
		Type:     SystemMessageType_WorldBoss,
		ParamId:  []int32{int32(playerBoss.bossUid), bossData.SummonType},
		SendTime: util.GetTimeMilliseconds(),
	}
	ssMsgNtf.SysMsg = append(ssMsgNtf.SysMsg, ssMsg)
	SendToAllGame(ssMsgNtf)

	return true
}

func (this *WorldBossManager) PlayerChallengeSummonBoss(uid, challengeBossUid uint64, clientId model.ClientID,
	fightInfo *serverproto.FightRoleInfo) serverproto.ErrorCode {
	//当前玩家是否正在挑战boss
	if bossInfo, ok := this.challengePlayerList[uid]; ok {
		if bossInfo.finish {
			delete(this.challengePlayerList, uid)
		} else {
			bossInfo.leaveNotify(uid)
			//util.InfoF("PlayerChallengeSummonBoss already in other boss=%v uid=%v", bossInfo, uid)
			//return serverproto.ErrorCode_ERROR_AOI_BOSS_CHALLENGING
		}
	}

	//查找是否存在Boss
	bossInfo, ok := this.bossList[challengeBossUid]
	if !ok {
		return serverproto.ErrorCode_ERROR_AOI_BOSS_NOT_FOUND
	}

	ret := bossInfo.canChallenge(uid)
	if ret != serverproto.ErrorCode_ERROR_OK {
		return ret
	}

	//添加挑战玩家信息
	bossInfo.addChallengePlayer(uid, clientId, fightInfo)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *WorldBossManager) DoSummonHp(uid, bossUid uint64, damageHp int32) {
	bossInfo, ok := this.challengePlayerList[uid]
	if !ok {
		util.InfoF("DoSummonHp boss not find uId=%v boss=%v damageHp=%v", uid, bossUid, damageHp)
		return
	}

	if bossInfo.bossUid != bossUid {
		util.InfoF("DoSummonHp bossId invalid uid=%v boss=%v dobossid=%v", uid, bossInfo.bossUid, bossUid)
		return
	}

	bossInfo.ProcessBattle(damageHp)
}

func (this *WorldBossManager) GetWorldBossInfo(bossUid uint64) *serverproto.WorldBossContentInfo {
	bossInfo, ok1 := this.bossList[bossUid]
	if !ok1 {
		return nil
	}

	info := &serverproto.WorldBossContentInfo{
		BossId:         int32(bossInfo.bossUid),
		CfgId:          bossInfo.summonBossId,
		FighterNum:     int32(len(bossInfo.challengeList)),
		ExpireTime:     bossInfo.summonTime + bossInfo.durationTime,
		TotalHp:        bossInfo.maxHp,
		CurHp:          bossInfo.totalHp,
		BossSummonType: bossInfo.summonBossType,
	}

	return info
}

func (this *WorldBossManager) getBossRefreshInfo(posIdx int32) *RefreshBossInfo {
	if data, ok := this.refreshBossInfoList[posIdx]; ok {
		return data
	}
	return nil
}

func (this *WorldBossManager) getBossRefreshInfoChangePlay(bossId int32) *RefreshBossInfo {
	if data, ok := this.refreshBossInfoActivityList[bossId]; ok {
		refreshTime := uint64(data.refreshTime.Unix()) * 1000
		if data.bossData.BossEndTimeStmp > refreshTime {
			return data
		}
	}
	return nil
}

func (this *WorldBossManager) GetWorldBossList() *serverproto.SCPlayerWorldBossListAck {
	if len(this.bossList) <= 0 {
		var tmpAckMsg = &serverproto.SCPlayerWorldBossListAck{}
		//if len(tmpAckMsg.WorldBossList) > 0 {
		//	return tmpAckMsg
		//}
		//普通世界boss
		for _, val := range this.refreshBossInfoList {
			npcCfgData, ok1 := serverproto.NpcCfgLoader[val.bossData.SummonId]
			if !ok1 {
				util.InfoF("NpcCfgLoader npc data not find summonid=%v ", val.bossData.SummonId)
				continue
			}

			info := &serverproto.WorldBossContentInfo{
				BossId:          int32(val.bossData.Id),
				CfgId:           val.bossData.SummonId,
				FighterNum:      0,
				ExpireTime:      0,
				NextRefreshTime: uint64(val.refreshTime.Unix()) * 1000,
				TotalHp:         int32(npcCfgData.Hp),
				CurHp:           int32(npcCfgData.Hp),
			}
			tmpAckMsg.WorldBossList = append(tmpAckMsg.WorldBossList, info)
		}
		//变身类活动世界boss
		nowTime := util.GetCurrentTimeNow()
		for _, val := range this.refreshBossInfoActivityList {
			npcCfgData, ok1 := serverproto.NpcCfgLoader[val.bossData.SummonId]
			if !ok1 {
				util.InfoF("NpcCfgLoader npc data not find summonid=%v ", val.bossData.SummonId)
				continue
			}
			if nowTime.Before(val.bossData.BossBeginTime) || nowTime.After(val.bossData.BossEndTime) {
				continue
			}

			info := &serverproto.WorldBossContentInfo{
				BossId:          int32(val.bossData.Id),
				CfgId:           val.bossData.SummonId,
				FighterNum:      0,
				ExpireTime:      0,
				NextRefreshTime: uint64(val.refreshTime.Unix()) * 1000,
				TotalHp:         int32(npcCfgData.Hp),
				CurHp:           int32(npcCfgData.Hp),
				BossSummonType:  val.bossData.SummonType,
			}
			tmpAckMsg.WorldBossList = append(tmpAckMsg.WorldBossList, info)
		}
		return tmpAckMsg
	} else {
		ackMsg := &serverproto.SCPlayerWorldBossListAck{}
		nowTime := util.GetTimeMilliseconds()
		hasBossList := set.New(set.NonThreadSafe)
		hasChangePlayBossList := set.New(set.NonThreadSafe)
		for _, bossInfo := range this.bossList {
			if bossInfo.summonBossType <= 0 {
				//pos
				hasBossList.Add(int32(bossInfo.bossUid) % model.WorldBossListNum)
			} else {
				hasChangePlayBossList.Add(int32(bossInfo.bossUid))
			}
			info := &serverproto.WorldBossContentInfo{
				BossId:        int32(bossInfo.bossUid),
				BossSummonIdx: bossInfo.summonBossIdx,
				CfgId:         bossInfo.summonBossId,
				FighterNum:    int32(len(bossInfo.challengeList)),
				//ExpireTime:     bossInfo.summonTime + bossInfo.durationTime,
				TotalHp:        bossInfo.maxHp,
				CurHp:          bossInfo.totalHp,
				BossSummonType: bossInfo.summonBossType,
			}

			expireTime := bossInfo.summonTime + bossInfo.durationTime
			if bossInfo.summonBossType == model.SummonBossType_ChangePlay {
				changBossDataInfo, ok := model.ConvertWorldBossChangePlayList[int32(bossInfo.bossUid)]
				if ok {
					if expireTime > changBossDataInfo.BossEndTimeStmp {
						expireTime = changBossDataInfo.BossEndTimeStmp
					}
				}
			}
			info.ExpireTime = expireTime

			if nowTime > expireTime || bossInfo.totalHp <= 0 {
				info.FighterNum = 0
				info.ExpireTime = 0

				switch bossInfo.summonBossType {
				case model.SummonBossType_Normal:
					bossRefreshInfo := this.getBossRefreshInfo(info.BossId % model.WorldBossListNum)
					if bossRefreshInfo != nil {
						info.NextRefreshTime = uint64(bossRefreshInfo.refreshTime.Unix()) * 1000
					}
				case model.SummonBossType_ChangePlay:
					bossRefreshInfo := this.getBossRefreshInfoChangePlay(info.BossId)
					if bossRefreshInfo != nil {
						info.NextRefreshTime = uint64(bossRefreshInfo.refreshTime.Unix()) * 1000
					} else {
						continue
					}
				}
			}
			ackMsg.WorldBossList = append(ackMsg.WorldBossList, info)
		}

		for _, val := range this.refreshBossInfoList {
			if hasBossList.Has(val.posId) {
				continue
			}
			npcCfgData, ok1 := serverproto.NpcCfgLoader[val.bossData.SummonId]
			if !ok1 {
				util.InfoF("NpcCfgLoader npc data not find summonid=%v ", val.bossData.SummonId)
				continue
			}

			info := &serverproto.WorldBossContentInfo{
				BossId:          int32(val.bossData.Id),
				CfgId:           val.bossData.SummonId,
				FighterNum:      0,
				ExpireTime:      0,
				NextRefreshTime: uint64(val.refreshTime.Unix()) * 1000,
				TotalHp:         int32(npcCfgData.Hp),
				CurHp:           int32(npcCfgData.Hp),
			}
			ackMsg.WorldBossList = append(ackMsg.WorldBossList, info)
		}

		nowTime1 := util.GetCurrentTimeNow()
		for _, val := range this.refreshBossInfoActivityList {
			if hasChangePlayBossList.Has(val.bossData.Id) {
				continue
			}
			npcCfgData, ok1 := serverproto.NpcCfgLoader[val.bossData.SummonId]
			if !ok1 {
				util.InfoF("NpcCfgLoader npc data not find summonid=%v ", val.bossData.SummonId)
				continue
			}
			if nowTime1.Before(val.bossData.BossBeginTime) || nowTime1.After(val.bossData.BossEndTime) {
				continue
			}

			info := &serverproto.WorldBossContentInfo{
				BossId:          int32(val.bossData.Id),
				CfgId:           val.bossData.SummonId,
				FighterNum:      0,
				ExpireTime:      0,
				NextRefreshTime: uint64(val.refreshTime.Unix()) * 1000,
				TotalHp:         int32(npcCfgData.Hp),
				CurHp:           int32(npcCfgData.Hp),
				BossSummonType:  val.bossData.SummonType,
			}
			ackMsg.WorldBossList = append(ackMsg.WorldBossList, info)
		}

		return ackMsg
	}
}