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

package model

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

//精彩活动管理
type ActivitiesManager struct {
	updateTimer util.ServerTimer //更新定时器
	initStartUp bool

	OpenedList   map[int32]*model.ConvertActivitiesData
	unopenedList map[int32]*model.ConvertActivitiesData

	RoleActivitiesList map[int32]*model.ConvertActivitiesData //相对角色创建时间
	RoleSystemActList  map[int32]*model.ConvertActivitiesData //根据玩家开启系统决定活动开启时间
	//过期后的活动是否强制开启(之前没有开启过，只针对相对开服时间开启的活动类型，立即开启)
	ExpiredActivitiesList map[int32]*model.ConvertActivitiesData

	//砸蛋大奖记录
	SmashEggsMsgList []*serverproto.SystemMessage
}

func newActivitiesMag() *ActivitiesManager {
	mag := &ActivitiesManager{
		OpenedList:            map[int32]*model.ConvertActivitiesData{},
		unopenedList:          map[int32]*model.ConvertActivitiesData{},
		RoleActivitiesList:    map[int32]*model.ConvertActivitiesData{},
		RoleSystemActList:     map[int32]*model.ConvertActivitiesData{},
		ExpiredActivitiesList: map[int32]*model.ConvertActivitiesData{},
	}
	mag.updateTimer = util.NewDurationTimer(util.GetCurrentTime(), 5000)
	return mag
}

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

	nowTimeDate := util.GetTimeByUint64(ms)
	for _, val := range model.ConvertActivitiesList {
		//根据合服标记判断是否需要加入活动队列中（合服活动）
		if val.ServiceMark > 0 && !this.isCombineServiceActivity(val.Id) {
			continue
		}

		switch val.TimeType {
		case model.ActivitiesTime_Type_Global: //绝对时间
			val.CalStartTime = val.StartTime
			val.CalEndTime = val.EndTime
			val.CalEndTimeMs = uint64(val.CalEndTime.UnixNano() / 1e6)
		case model.ActivitiesTime_Type_Server: //相对开服时间
			//当前天凌晨开服要到5点后才算开服的第一天为开始时间
			//根据开服时间endday-startday(持续时间)
			//startUpDayTime1 := util.GetTimeByUint64(startUptime)
			startUpDayTime2 := util.GetDayByTimeStr2(startUptime)
			tmpSTime1 := startUpDayTime2
			if val.StartDay > 1 {
				tmpSTime1 = tmpSTime1.AddDate(0, 0, val.StartDay-1)
			}
			tempSTime := util.GetTimeByStr(tmpSTime1.Format(util.DATE_FORMAT1) + " " + val.StartTimeStr) //开始时间
			tmpSTime2 := startUpDayTime2
			if val.EndDay > 1 {
				tmpSTime2 = tmpSTime2.AddDate(0, 0, val.EndDay-1)
			}
			tempETime := util.GetTimeByStr(tmpSTime2.Format(util.DATE_FORMAT1) + " " + val.EndTimeStr) //结束时间
			//util.DebugF("id=%v stime=%v etime=%v proc", val.Id, tempSTime, tempETime)

			val.CalStartTime = tempSTime
			val.CalEndTime = tempETime
			val.CalEndTimeMs = uint64(val.CalEndTime.UnixNano() / 1e6)

		case model.ActivitiesTime_Type_Role: //相对创建角色时间
			this.RoleActivitiesList[val.Id] = val
		case model.ActivitiesTime_Type_System: //根据玩家开启系统决定活动开启时间
			this.RoleSystemActList[val.Id] = val
		}

		if val.TimeType != model.ActivitiesTime_Type_Role &&
			val.TimeType != model.ActivitiesTime_Type_System {
			//永久活动时间/过期需要重新开启
			if val.TimeType == model.ActivitiesTime_Type_None {
				this.OpenedList[val.Id] = val

				util.DebugF("id=%v stime=%v etime=%v open", val.Id, val.CalStartTime, val.CalEndTime)
				continue
			}

			//活动结束
			if nowTimeDate.After(val.CalEndTime) {
				//过期需要重新开启的活动放到ExpiredActivitiesList列表中
				if val.ExpiredActivities {
					this.ExpiredActivitiesList[val.Id] = val
				}
				continue
			}
			//未开启活动
			if nowTimeDate.Before(val.CalStartTime) {
				this.unopenedList[val.Id] = val
				continue
			}
			this.OpenedList[val.Id] = val

			util.DebugF("id=%v stime=%v etime=%v open", val.Id, val.CalStartTime, val.CalEndTime)
		}
	}
}
func (this *ActivitiesManager) Update(ms uint64) {
	if !this.initStartUp {
		startUpTime := service.GetServiceStartupTime()
		if startUpTime > 0 {
			this.init(ms, startUpTime)
		}
	}

	if this.initStartUp && this.updateTimer.IsStart() && this.updateTimer.IsExpired(ms) {
		nowTimeDate := util.GetTimeByUint64(ms)

		if len(this.unopenedList) > 0 {
			//新开启活动
			var newOpenList []*model.ConvertActivitiesData
			for _, val := range this.unopenedList {
				//判断是否超过最后开启时间的活动
				if val.TerminalOpenTimeStr != "" &&
					nowTimeDate.After(val.TerminalOpenTime) {
					delete(this.unopenedList, val.Id)
					continue
				}
				if nowTimeDate.After(val.CalEndTime) {
					delete(this.unopenedList, val.Id)
					continue
				}
				if nowTimeDate.After(val.CalStartTime) {
					delete(this.unopenedList, val.Id)
					this.OpenedList[val.Id] = val
					newOpenList = append(newOpenList, val)
				}
			}
			if len(newOpenList) > 0 {
				this.DoActivitiesOpenNtf(newOpenList, ms)
			}
		}
	}
}

//获取开放的精彩活动列表
func (this *ActivitiesManager) GetOpenList(openList *[]*serverproto.ActivitiesData) {
	nowTime := util.GetCurrentTimeNow()
	for _, val := range this.OpenedList {
		if nowTime.After(val.CalStartTime) && nowTime.Before(val.CalEndTime) {
			tmpData := &serverproto.ActivitiesData{
				Id:      val.Id,
				Type:    val.ActivityType,
				Bg:      val.BG,
				EndTime: val.CalEndTimeMs,
			}
			*openList = append(*openList, tmpData)
		} else {
			delete(this.OpenedList, val.Id)
		}
	}
}

//活动开启服务器主动通知
func (this *ActivitiesManager) DoActivitiesOpenNtf(newOpenList []*model.ConvertActivitiesData, ms uint64) {
	ntfMsg := &serverproto.SCActivitiesOpenListNtf{}
	for idx := 0; idx < len(newOpenList); idx++ {
		tmpData := &serverproto.ActivitiesData{
			Id:      newOpenList[idx].Id,
			Type:    newOpenList[idx].ActivityType,
			Bg:      newOpenList[idx].BG,
			EndTime: newOpenList[idx].CalEndTimeMs,
		}
		ntfMsg.ActivityList = append(ntfMsg.ActivityList, tmpData)
	}

	curDayEndTime := util.GetLatest5Hour()
	for _, chRole := range RoleMag.channelRoleList {
		if chRole.GetState() != ROLE_STATE_ONLINE {
			continue
		}

		ntfDetailMsg := &serverproto.SCActivitiesChangeNtf{
			CurDayEndTime: curDayEndTime,
		}
		for idx := 0; idx < len(newOpenList); idx++ {
			ret, detailInfo := chRole.(*Role).GetRoleActivity().OpenNewActivities(newOpenList[idx], ms, false)
			if ret {
				ntfDetailMsg.ActivityDataList = append(ntfDetailMsg.ActivityDataList, detailInfo)
			}
		}
		chRole.ReplayGate(ntfMsg, true)

		chRole.ReplayGate(ntfDetailMsg, true)
	}
}

//当前合服后的服务器是否开启该合服活动
func (this *ActivitiesManager) isCombineServiceActivity(activityId int32) bool {
	//合服后的逻辑区服ID
	combineServiceZone := service.GetServiceConfig().Node.Zone
	cfgData, ok := serverproto.ServiceRecordCfgLoader[int32(combineServiceZone)]
	if !ok {
		return false
	}

	for idx := 0; idx < len(cfgData.ActivitiesId); idx++ {
		openActivityId, _ := model.Str2Num(cfgData.ActivitiesId[idx])
		if openActivityId == int(activityId) {
			return true
		}
	}
	return false
}