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

package model

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

func (this *Role) ActivitiesExchange(msg *serverproto.CSActivitiesExchangeReq) {
	if this.roleActivity != nil {
		ret := this.roleActivity.ActivitiesExchange(msg, nil)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCActivitiesExchangeAck{
				ActivityId: msg.ActivityId,
				RewardIdx:  msg.RewardIdx,
				Error:      int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) ActivitiesReward(activityId, param, rewardNum int32) {
	if this.roleActivity != nil {
		ret := this.roleActivity.ActivitiesReward(activityId, param, rewardNum)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCActivitiesRewardAck{
				ActivityId: activityId,
				Error:      int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) SetCollectionNotice(activityId int32, CollectId int32, notice bool) {

	ackMsg := &serverproto.SCActivitiesWordNoticeSetAck{
		ActivityId: activityId,
		Error:      int32(serverproto.ErrorCode_ERROR_FAIL),
		CollectId:  CollectId,
		NoNotice:   notice,
	}
	if this.roleActivity != nil {
		ret := this.roleActivity.SetCollectNotice(activityId, CollectId, notice)
		ackMsg.Error = int32(ret)
	}

	this.ReplayGate(ackMsg, true)
}

func (this *Role) ActivitiesScoreReward(activityId, boxId int32) {
	if this.roleActivity != nil {
		ret := this.roleActivity.ActivitiesScoreReward(activityId, boxId)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCActivitiesScoreRewardAck{
				ActivityId: activityId,
				Error:      int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) ActivitiesFirstChargeReward() {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivitiesFirstChargeReward()
	if ret != serverproto.ErrorCode_ERROR_OK {
		ackMsg := &serverproto.SCActivitiesFirstChargeRewardAck{
			Error: int32(ret),
		}
		this.ReplayGate(ackMsg, true)
	}
}

func (this *Role) ActivitiesLikability(activityId int32, itemId, likabilityLevel int32) {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivitiesLikability(activityId, itemId, likabilityLevel)
	if ret != serverproto.ErrorCode_ERROR_OK {
		ackMsg := &serverproto.SCActivitiesLikabilityRewardAck{
			Error: int32(ret),
		}
		this.ReplayGate(ackMsg, true)
	}
}

// 活动转盘
func (this *Role) ActivityWheelRefresh(activityId int32) {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivityWheelRefresh(activityId)
	ackMsg := &serverproto.SCActivityWheelRefreshAck{
		Error: int32(ret),
	}
	this.ReplayGate(ackMsg, true)
}
func (this *Role) ActivityWheelOpenReward(activityId int32) {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivityWheelOpen(activityId)
	ackMsg := &serverproto.SCActivityWheelOpenRewardAck{
		Error: int32(ret),
	}
	this.ReplayGate(ackMsg, true)
}
func (this *Role) ActivityWheelReward(activityId int32, rewardAll bool) {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivityWheelReward(activityId, rewardAll)
	if ret != serverproto.ErrorCode_ERROR_OK {
		ackMsg := &serverproto.SCActivityWheelRewardAck{
			Error:     int32(ret),
			RewardAll: rewardAll,
		}
		this.ReplayGate(ackMsg, true)
	}
}
func (this *Role) ActivityWheelClose(activityId int32) {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivityWheelClose(activityId)
	ackMsg := &serverproto.SCActivityWheelCloseRewardAck{
		Error: int32(ret),
	}
	this.ReplayGate(ackMsg, true)
}

// 活动召唤
func (this *Role) ActivitySummon(activityId, summonCount int32) {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivitySummon(activityId, summonCount)
	if ret != serverproto.ErrorCode_ERROR_OK {
		ackMsg := &serverproto.SCActivitySummonAck{
			Error: int32(ret),
		}
		this.ReplayGate(ackMsg, true)
	}
}

// 活动签到
func (this *Role) ActivitySignIn(activityId int32) {
	if this.roleActivity == nil {
		return
	}
	ackMsg := &serverproto.SCActivitySignInAck{
		ActivityId: activityId,
	}
	ret := this.roleActivity.ActivitySignIn(activityId, ackMsg)
	ackMsg.Error = int32(ret)
	this.ReplayGate(ackMsg, true)
}

// 砸蛋活动
// drawType(蛋种类)
func (this *Role) ActivitySmashEggs(activityId, drawType, drawCount int32) {
	if this.roleActivity == nil {
		return
	}
	ret := this.roleActivity.ActivitySmashEggs(activityId, drawType, drawCount)
	if ret != serverproto.ErrorCode_ERROR_OK {
		ackMsg := &serverproto.SCActivitySmashEggsAck{
			Error: int32(ret),
		}
		this.ReplayGate(ackMsg, true)
	}
}
func (this *Role) ActivitySmashEggsMsg(activityId, drawType int32) {
	if this.roleActivity == nil {
		return
	}
	this.roleActivity.ActivitySmashEggsMsg(activityId, drawType)
}

// 活动逻辑模块
type RoleActivityOuter interface {
	GetSignUpInfo()
	OnSignUp()
}

type RoleActivity struct {
	SaveObject
	signInfo *serverproto.SignUp

	////精彩活动
	//updateTimer   util.DurationTimer
	curDayEndTime uint64
	//连续登录活动 | 14日目标任务
	activityDataList   map[int32]*serverproto.ActivitiesDetailData
	activitiesTaskList map[int32]map[uint32]*serverproto.TaskData

	//根据枚举类型对任务做区分[ActivitiesId][[serverproto.TaskType, taslidlist]]
	taskTypeList map[int32]map[int32]set.Interface
	initTaskType bool

	changeTaskList     map[int32]set.Interface //uint32
	openActivitiesList []int32                 //已经开启的精彩活动(相对玩家创建角色时间)
	registerDayTime    time.Time
	delActivityList    set.Interface //int32 save过程使用
	hasDelActivityList []int32       //删除的活动(过期或者其他原因导致活动已经删除，并记录次数)

	//充值相关
	//首充数据
	firstChargeTime       uint64
	firstChargeRewardStat int32
	superUnlockChargeList []*serverproto.ActivitiesUnlockRechargeData //超值礼包数据
	unlockChargeHasList   map[int32]*serverproto.KeyValueType         //ProductID

	//集字活动

}

func newRoleActivity(r *Role) *RoleActivity {
	roleActivity := &RoleActivity{
		SaveObject: SaveObject{
			role: r,
		},
		changeTaskList:      map[int32]set.Interface{},
		delActivityList:     set.New(set.NonThreadSafe),
		taskTypeList:        map[int32]map[int32]set.Interface{},
		activityDataList:    map[int32]*serverproto.ActivitiesDetailData{},
		activitiesTaskList:  map[int32]map[uint32]*serverproto.TaskData{},
		unlockChargeHasList: map[int32]*serverproto.KeyValueType{},
	}

	roleActivity.signInfo = &serverproto.SignUp{
		SignRound: 1,
		CurDay:    0,
		CurSignInfo: &serverproto.CurRoundSign{
			LastSign: 0,
		},
	}

	return roleActivity
}

func (this *RoleActivity) Load(msg interface{}) bool {
	proRole := msg.(*serverproto.Role)

	if proRole.RoleActivity != nil {
		if proRole.RoleActivity.SignInfo != nil {
			this.signInfo = proRole.RoleActivity.SignInfo
		}

		if len(ActivitiesMag.SmashEggsMsgList) <= 0 {
			ActivitiesMag.SmashEggsMsgList = proRole.RoleActivity.ActMsgList
		}

		//充值
		this.firstChargeTime = proRole.RoleActivity.FirstChargeTime
		this.firstChargeRewardStat = proRole.RoleActivity.FirstChargeRewardState
		this.superUnlockChargeList = proRole.RoleActivity.UnlockChargeList
		this.hasDelActivityList = proRole.RoleActivity.ExpiredActivityList
		for idx := 0; idx < len(proRole.RoleActivity.UnlockChargeHasList); idx++ {
			tmpVal := proRole.RoleActivity.UnlockChargeHasList[idx]
			this.unlockChargeHasList[tmpVal.Key] = tmpVal
		}
		nowTime := util.GetTimeMilliseconds()
		//限时礼包过期时间处理
		if this.refreshDiscountData(nowTime) {
			this.SetDirty(true)
		}

		////精彩活动 activities
		//当前天结束时间戳
		this.curDayEndTime = util.GetLatest5Hour()
		for idx := 0; idx < len(proRole.RoleActivity.ActivityDataList); idx++ {
			tmpData := proRole.RoleActivity.ActivityDataList[idx]
			this.activityDataList[tmpData.ActivitiesId] = tmpData
		}
		for _, tmpData := range this.activityDataList {
			convertData, ok := model.ConvertActivitiesList[tmpData.ActivitiesId]
			if !ok {
				this.delActivityList.Add(tmpData.ActivitiesId)
				delete(this.activityDataList, tmpData.ActivitiesId)
				this.addHasDelActivityList(tmpData.ActivitiesId, "Load convertData not find")
				this.SetDirty(true)
				continue
			}

			if convertData.ActivityType == int32(serverproto.EActivityType_EActivityType_Likability) {
				if tmpData.LikabilityData == nil {
					tmpData.LikabilityData = &serverproto.ActivitiesLikabilityData{
						Level: 1,
					}
				}
			}

			//初始化任务列表
			if tmpData.FortnightDays != nil {
				tmpTaskList, ok := this.activitiesTaskList[tmpData.ActivitiesId]
				if !ok {
					tmpTaskList = map[uint32]*serverproto.TaskData{}
					this.activitiesTaskList[tmpData.ActivitiesId] = tmpTaskList
				}
				for idx := 0; idx < len(tmpData.FortnightDays.TaskList); idx++ {
					tmpTask := tmpData.FortnightDays.TaskList[idx]
					_, ok := model.ConvertActivitiesTaskList[int32(tmpTask.TaskId)]
					if !ok {
						continue
					}
					tmpTaskList[tmpTask.TaskId] = tmpTask
				}
			}
			//初始化国王悬赏任务列表
			if len(tmpData.KingTask) > 0 {
				tmpTaskList, ok := this.activitiesTaskList[tmpData.ActivitiesId]
				if !ok {
					tmpTaskList = map[uint32]*serverproto.TaskData{}
					this.activitiesTaskList[tmpData.ActivitiesId] = tmpTaskList
				}
				for idx := 0; idx < len(tmpData.KingTask); idx++ {
					tmpTask := tmpData.KingTask[idx]
					_, ok := model.ConvertActivitiesTaskList[int32(tmpTask.TaskId)]
					if !ok {
						continue
					}
					tmpTaskList[tmpTask.TaskId] = tmpTask
				}
			}
			//BT任务列表
			if len(tmpData.BtZhenjiaRechargeTaskList) > 0 {
				this.loadActivityTaskData(tmpData.ActivitiesId, tmpData.BtZhenjiaRechargeTaskList)
			}
			if tmpData.BtRocoinData != nil {
				this.loadActivityTaskData(tmpData.ActivitiesId, tmpData.BtRocoinData.DailyTaskList)
				this.loadActivityTaskData(tmpData.ActivitiesId, tmpData.BtRocoinData.WeekTaskList)
			}

			//特殊处理嘉年华活动时间bug， 使用活动类型判断
			if tmpData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_Acitivty_Shop) {
				tmpData.StartTime = uint64(convertData.CalStartTime.UnixNano() / 1e6)
				tmpData.EndTime = convertData.CalEndTimeMs
			} else if tmpData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_Daily_Cum_Recharge) {
				// 特殊处理 每日充值类型的活动！ 开始时间改为服务器启动时间
				tmpData.StartTime = service.GetServiceStartupTime()
			}

			//判断活动过期
			if convertData.TimeType > 0 && tmpData.EndTime <= nowTime && tmpData.EndTime > 0 {
				//领取活动奖励
				this.getAllActivityReward(tmpData)

				this.delActivityList.Add(tmpData.ActivitiesId)
				delete(this.activityDataList, tmpData.ActivitiesId)
				this.addHasDelActivityList(tmpData.ActivitiesId, "Load Time Invalid")
				this.SetDirty(true)
				continue
			}

			util.DebugF("uid=%v OpenNewActivities ok[init] activity id=%v endtime=%v", this.role.GetUUid(), convertData.Id, tmpData.EndTime)
		}
		//判断是否开启新活动
		for _, convertData := range ActivitiesMag.OpenedList {
			this.OpenNewActivities(convertData, nowTime, false)
		}
		//相对创建角色时间
		for _, convertData := range ActivitiesMag.RoleActivitiesList {
			this.OpenNewActivities(convertData, nowTime, false)
		}
		//根据玩家开启系统决定活动开启时间
		for _, convertData := range ActivitiesMag.RoleSystemActList {
			this.OpenNewActivities(convertData, nowTime, false)
		}
		//过期后的活动是否强制开启(之前没有开启过，只针对相对开服时间开启的活动类型,立即开启)
		for _, convertData := range ActivitiesMag.ExpiredActivitiesList {
			this.OpenNewActivities(convertData, nowTime, false)
		}
	}
	return true
}

// load时初始化任务类型数据
func (this *RoleActivity) loadActivityTaskData(activityId int32, taskDataList []*serverproto.TaskData) {
	if len(taskDataList) <= 0 {
		return
	}

	tmpTaskList, ok := this.activitiesTaskList[activityId]
	if !ok {
		tmpTaskList = map[uint32]*serverproto.TaskData{}
		this.activitiesTaskList[activityId] = tmpTaskList
	}
	for idx := 0; idx < len(taskDataList); idx++ {
		tmpTask := taskDataList[idx]
		_, ok := model.ConvertActivitiesTaskList[int32(tmpTask.TaskId)]
		if !ok {
			continue
		}
		tmpTaskList[tmpTask.TaskId] = tmpTask
	}
}
func (this *RoleActivity) addHasDelActivityList(activityId int32, param string) {
	for idx := 0; idx < len(this.hasDelActivityList); idx++ {
		if this.hasDelActivityList[idx] == activityId {
			return
		}
	}

	util.InfoF("uid=%v addHasDelActivityList activityId=%v param=%v", this.role.GetUUid(), activityId, param)
	this.hasDelActivityList = append(this.hasDelActivityList, activityId)
	this.SetDirty(true)
}

func (this *RoleActivity) hasDelActivityByID(activityId int32) bool {
	//判断是否已经开启过该活动
	for idx := 0; idx < len(this.hasDelActivityList); idx++ {
		if this.hasDelActivityList[idx] == activityId {
			return true
		}
	}
	return false
}

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

	//base
	saveMsg := &serverproto.SSActivityDataSaveReq{
		RoleActivity: &serverproto.RoleActivity{
			SignInfo:               this.signInfo,
			FirstChargeTime:        this.firstChargeTime,
			FirstChargeRewardState: this.firstChargeRewardStat,
			UnlockChargeList:       this.superUnlockChargeList,
		},
	}
	for _, val := range this.unlockChargeHasList {
		saveMsg.RoleActivity.UnlockChargeHasList = append(saveMsg.RoleActivity.UnlockChargeHasList, val)
	}

	//change task | del task
	for actId, taskList := range this.changeTaskList {
		if this.delActivityList.Has(actId) {
			continue
		}

		activityInfo := this.getActivityData(actId)
		if activityInfo == nil {
			this.delActivityList.Add(actId)
			this.addHasDelActivityList(actId, "Save")
			continue
		}

		saveDetail := &serverproto.ActivityDataSaveDetail{
			ActivitiesId: actId,
		}

		for {
			if taskList.Size() <= 0 {
				break
			}
			taskId := taskList.Pop().(uint32)
			//活动本身数据
			if taskId == 0 {
				saveDetail.ActivityData = &serverproto.ActivitiesDetailData{
					ActivitiesId:    activityInfo.ActivitiesId,
					ActivitiesType:  activityInfo.ActivitiesType,
					StartTime:       activityInfo.StartTime,
					EndTime:         activityInfo.EndTime,
					CurDay:          activityInfo.CurDay,
					LoginRewardList: activityInfo.LoginRewardList,
					ParamTime:       activityInfo.ParamTime,
					RewardState:     activityInfo.RewardState,
					CollectionList:  activityInfo.CollectionList,
					//FightingTarget:  activityInfo.FightingTarget,
					ExchangeList: activityInfo.ExchangeList,
					//BtZhenjiaRechargeTaskList: activityInfo.BtZhenjiaRechargeTaskList,
				}
				if activityInfo.FortnightDays != nil {
					saveDetail.ActivityData.FortnightDays = &serverproto.ActivitiesFortnightDays{
						TaskScore:       activityInfo.FortnightDays.TaskScore,
						TaskScoreReward: activityInfo.FortnightDays.TaskScoreReward,
					}
				}
				if activityInfo.WheelData != nil {
					saveDetail.ActivityData.WheelData = activityInfo.WheelData
				}
				if activityInfo.SignData != nil {
					saveDetail.ActivityData.SignData = activityInfo.SignData
				}

				if activityInfo.LikabilityData != nil {
					saveDetail.ActivityData.LikabilityData = activityInfo.LikabilityData
				}
				if activityInfo.BtRocoinData != nil {
					saveDetail.ActivityData.BtRocoinData = &serverproto.ActivityBTROCoin{
						WeekDayEndTime: activityInfo.BtRocoinData.WeekDayEndTime,
					}
				}
			} else {
				taskInfo := this.getTaskData(actId, taskId)
				if taskInfo == nil {
					saveDetail.DelTaskList = append(saveDetail.DelTaskList, taskId)
				} else {
					saveDetail.ChangeTaskList = append(saveDetail.ChangeTaskList, taskInfo)
				}
			}
		}
		saveMsg.ChangeActivityList = append(saveMsg.ChangeActivityList, saveDetail)
	}
	//del activity
	for {
		if this.delActivityList.Size() <= 0 {
			break
		}
		val := this.delActivityList.Pop()
		saveMsg.DelActivityList = append(saveMsg.DelActivityList, val.(int32))
	}

	saveMsg.RoleActivity.ExpiredActivityList = this.hasDelActivityList
	this.role.SendDb(saveMsg)
}

func (this *RoleActivity) ActivityHDRuneGoodsAdd(activityId int32) uint64 {
	for _, val := range this.activityDataList {
		if cfgData, ok := model.ConvertActivitiesList[val.ActivitiesId]; ok {
			if cfgData.Id == activityId {
				return val.EndTime
			}
		}
	}
	return 0
}

// 活动道具掉落
func (this *RoleActivity) ActivityHDItemCheck(configId int32, cfgItemData *serverproto.ItemCfg) int32 {
	for _, val := range this.activityDataList {
		if cfgData, ok := model.ConvertActivitiesList[val.ActivitiesId]; ok {
			if cfgData.HDItemList.Has(configId) {
				if cfgItemData.ItemTime == Item_Time_Type_Likability {
					//特殊标记表示无结束时间
					return -1
				} else {
					return int32(val.EndTime / 1000)
				}
			}
		}
	}
	return 0
}

// 检查是否需要切换循环
func (this *RoleActivity) CheckNewCircle() bool {
	//判定是否是同一轮大循环
	if this.signInfo.SignRound == 0 {
		this.signInfo.SignRound = 1
		this.SetDirty(true)
		return false
	}
	globalCfg, ok := serverproto.GlobalCfgLoader[int32(serverproto.GlobalType_Global_SignUp_Version)]
	if !ok {
		util.InfoF("uid=%v signup version not found", this.role.GetUUid())
		return false
	}
	//同一轮大循环
	if this.signInfo.SignRound == globalCfg.IVal {
		return false
	}

	//重置所有数据
	this.signInfo.SignRound = globalCfg.IVal
	this.signInfo.CurDay = 0
	this.signInfo.CurSignInfo.LastSign = 0
	this.SetDirty(true)

	return true
}

// 检查是否新的周期
func (this *RoleActivity) ChangeSignUpInfo() bool {
	//重置小周期数据
	var nextBeginDay int32
	nextBegin := this.signInfo.CurDay + 1
	_, ok := model.ConvertSignUpData[nextBegin]
	if !ok {
		nextBegin = this.signInfo.CurDay - 30 + 1
		_, ok2 := model.ConvertSignUpData[nextBegin]
		if !ok2 {
			util.ErrorF("uid=%vConvertSignUpData config error. nextBegin:%v", this.role.GetUUid(), nextBegin)
			return false
		} else {
			nextBeginDay = nextBegin
		}
	} else {
		nextBeginDay = nextBegin
	}
	this.signInfo.CurDay = nextBeginDay
	return true
}

// 请求签到
func (this *RoleActivity) SignUp(ackMsg *serverproto.SCSignUpAck) serverproto.ErrorCode {
	//今日是否签到
	if this.signInfo.CurSignInfo.LastSign != 0 && this.signInfo.CurSignInfo.LastSign > int64(util.GetCurrentTime()) {
		return serverproto.ErrorCode_ERROR_ACTIVITY_SIGNUP_REPEATEAD
	}
	//签到//累积签到//找不到下一个可签到的天，不让他今天签到
	bRet := this.ChangeSignUpInfo()
	if bRet == false {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	this.signInfo.CurSignInfo.LastSign = int64(util.GetLatest5Hour())

	data, ok := model.ConvertSignUpData[this.signInfo.CurDay]
	if ok {
		var addItemList = map[int32]int32{}
		if len(data.DaySign) > 0 {
			for _, data := range data.DaySign {
				if !CheckHDItemAdd(data.Key, this.role) {
					continue
				}
				addItemList[data.Key] += data.Value
				ackMsg.DayList = append(ackMsg.DayList, &serverproto.KeyValueType{
					Key:   data.Key,
					Value: data.Value,
				})
			}
		}
		if len(data.AccuSign) > 0 {
			for _, data := range data.AccuSign {
				if !CheckHDItemAdd(data.Key, this.role) {
					continue
				}

				addItemList[data.Key] += data.Value
				ackMsg.AccuList = append(ackMsg.AccuList, &serverproto.KeyValueType{
					Key:   data.Key,
					Value: data.Value,
				})
			}
		}
		if data.VipLevel != 0 && this.role.GetRoleBase().roleBase.VipLevel >= data.VipLevel {
			vipRate := this.role.GetRoleBase().GetVipData(model.Vip_System_SignReward)
			if vipRate > 1 && len(data.DaySign) > 0 {
				for _, data := range data.DaySign {
					if !CheckHDItemAdd(data.Key, this.role) {
						continue
					}

					addItemList[data.Key] += data.Value
					ackMsg.DoubleList = append(ackMsg.DoubleList, &serverproto.KeyValueType{
						Key:   data.Key,
						Value: data.Value * (vipRate - 1),
					})
				}
			}
		}
		this.role.AddItemList(addItemList, AddFrom_SignUp, true)
	}
	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK
}

// 获得下一次签到天
func (this *RoleActivity) GetCurSignDay() int32 {
	nextBegin := this.signInfo.CurDay + 1
	_, ok := model.ConvertSignUpData[nextBegin]
	if !ok {
		nextBegin = this.signInfo.CurDay - 30 + 1
		_, ok2 := model.ConvertSignUpData[nextBegin]
		if !ok2 { //一般不会有问题。都是从这天走过来的。除非策划乱搞表。
			util.ErrorF("uid=%v ConvertSignUpData config error nextbegin=%v", this.role.GetUUid(), nextBegin)
			return 0
		}
	}
	return nextBegin
}

// gm命令
func (this *RoleActivity) SetSignDay(day int32, sec int32) {
	if this.signInfo != nil {
		this.signInfo.CurDay = day
		if sec != -1 {
			this.signInfo.CurSignInfo.LastSign = int64(sec)
		}
		this.SetDirty(true)
	}
}

// //精彩活动
func (this *RoleActivity) DailyReset(notify bool) {
	nowTime := util.GetTimeMilliseconds()

	this.curDayEndTime = util.GetLatest5Hour()
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}

	//判断是否开启新活动
	addActivityNtfMsg := &serverproto.SCActivitiesOpenListNtf{}
	for _, convertData := range ActivitiesMag.OpenedList {
		ret, detailInfo := this.OpenNewActivities(convertData, nowTime, notify)
		if ret {
			tmpData := &serverproto.ActivitiesData{
				Id:      convertData.Id,
				Type:    convertData.ActivityType,
				Bg:      convertData.BG,
				EndTime: detailInfo.EndTime,
			}
			addActivityNtfMsg.ActivityList = append(addActivityNtfMsg.ActivityList, tmpData)
		}
	}
	//相对创建角色时间
	for _, convertData := range ActivitiesMag.RoleActivitiesList {
		ret, detailInfo := this.OpenNewActivities(convertData, nowTime, notify)
		if ret {
			tmpData := &serverproto.ActivitiesData{
				Id:      convertData.Id,
				Type:    convertData.ActivityType,
				Bg:      convertData.BG,
				EndTime: detailInfo.EndTime,
			}
			addActivityNtfMsg.ActivityList = append(addActivityNtfMsg.ActivityList, tmpData)
		}
	}

	for _, val := range this.activityDataList {
		//跨天 跨周后活动是否过期，需要获取奖励(这边处理在线，离线上线时已经处理)
		if val.EndTime > 0 && nowTime >= val.EndTime {
			this.getAllActivityReward(val)

			this.delActivityList.Add(val.ActivitiesId)
			delete(this.activityDataList, val.ActivitiesId)
			this.addHasDelActivityList(val.ActivitiesId, "DailyReset")
			this.SetDirty(true)
			continue
		}

		if val.StartTime > nowTime || val.StartTime <= 0 {
			continue
		}
		tmpCurDay := util.GetDurationDay2(val.StartTime, nowTime)
		switch val.ActivitiesType {
		case int32(serverproto.EActivityType_EActivityType_14_Days_Login): //14日登陆活动
			if val.CurDay < tmpCurDay {
				val.CurDay = tmpCurDay
				val.LoginRewardList = append(val.LoginRewardList, &serverproto.KeyValueType{Key: tmpCurDay})
				this.SetDirty(true)
			}
		case int32(serverproto.EActivityType_EActivityType_14_Days_Task): //14日任务
			sIdx := val.CurDay + 1
			eIdx := tmpCurDay
			////跨周任务奖励获取
			//oldCurWeek := this.getWeekNumber(val.CurDay)
			//tmpCurWeek := this.getWeekNumber(tmpCurDay)
			//if tmpCurWeek > oldCurWeek {
			//	//this.getAllActivityReward(val)
			//	sIdx = tmpCurWeek*7 - 6
			//}
			// 跨天添加新任务处理
			for idx := sIdx; idx <= eIdx; idx++ {
				dayVal, ok := model.ConvertActivitiesFortnightDaysList[idx]
				if !ok {
					continue
				}
				for k := 0; k < len(dayVal.TaskList); k++ {
					this.addDayTask(val.ActivitiesId, dayVal.TaskList[k],
						dayVal.Days, false, idx)
				}
				for k := 0; k < len(dayVal.DailyTaskList); k++ {
					this.addDayTask(val.ActivitiesId, dayVal.DailyTaskList[k],
						dayVal.Days, true, idx)
				}
			}
			val.CurDay = tmpCurDay
			this.SetDirty(true)
		case int32(serverproto.EActivityType_EActivityType_Daily_Cum_Recharge): //每日累计充值
			//未领取的奖励隔天重置时通过邮件发送
			this.getAllActivityReward(val)

			val.CurDay = tmpCurDay
			val.RewardState = 0
			this.SetDirty(true)
		case int32(serverproto.EActivityType_EActivityType_King):
			this.getAllActivityKingTaskReward(val, model.TASK_TYPE_TODAY)
			this.ResetTodayTask(val, nowTime)
		case int32(serverproto.EActivityType_EActivityType_Pet_Exchange):
			if val.CurDay < tmpCurDay {
				val.CurDay = tmpCurDay
				if len(val.ExchangeList) <= 0 {
					continue
				}
				cfgData, ok := model.ConvertExchangeReset[val.ActivitiesId]
				if !ok || len(cfgData.Id) <= 0 {
					continue
				}
				for _, idx := range cfgData.Id {
					for i := 0; i < len(val.ExchangeList); i++ {
						if idx == val.ExchangeList[i].Id {
							val.ExchangeList[i].ExchangeNum = 0
							break
						}
					}
				}
				this.SetDirty(true)
			}
		case int32(serverproto.EActivityType_EActivityType_BT_ROCoinRecharge):
			fallthrough
		case int32(serverproto.EActivityType_EActivityType_BT_ZhenJiaRecharge):
			//未领取的奖励隔天重置时通过邮件发送
			this.getAllActivityReward(val)
			val.CurDay = tmpCurDay
			this.resetBTTasks(val)
			this.SetDirty(true)
		default:
			val.CurDay = tmpCurDay
			this.SetDirty(true)
		}
		this.addChangeActivity(val.ActivitiesId, 0)

		if notify {
			tmpDetailData := &serverproto.ActivitiesDetailData{}
			this.copyActivityDetailData(val, tmpDetailData)
			ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, tmpDetailData)
		}
	}

	if notify {
		if len(ntfMsg.ActivityDataList) > 0 {
			this.role.ReplayGate(ntfMsg, true)
		}
		if len(addActivityNtfMsg.ActivityList) > 0 {
			this.role.ReplayGate(addActivityNtfMsg, true)
		}
	}
}

func (this *RoleActivity) StartupNtf() {

	for key, val := range this.activityDataList {
		if cfgData, ok := model.ConvertActivitiesList[val.ActivitiesId]; ok {
			if cfgData.CalEndTimeMs == 0 {
				// 重新计算开始时间和结束时间
				StartTime, EndTime := this.recalActivityTime(cfgData)
				this.activityDataList[key].StartTime = StartTime
				this.activityDataList[key].EndTime = EndTime
			} else {
				this.activityDataList[key].StartTime = uint64(cfgData.CalStartTime.UnixMilli())
				this.activityDataList[key].EndTime = uint64(cfgData.CalEndTime.UnixMilli())
			}

		}
	}

	ntfMsg := &serverproto.SCActivitiesStartupNtf{
		CurDayEndTime:          this.curDayEndTime,
		FirstChargeTime:        this.firstChargeTime,
		FirstChargeRewardState: this.firstChargeRewardStat,
		UnlockChargeList:       this.superUnlockChargeList,
	}

	for _, val := range this.activityDataList {
		tmpDetailData := &serverproto.ActivitiesDetailData{}
		this.copyActivityDetailData(val, tmpDetailData)
		ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, tmpDetailData)

		openData := &serverproto.ActivitiesData{
			Id:      val.ActivitiesId,
			Type:    val.ActivitiesType,
			EndTime: val.EndTime,
		}
		cfgData, ok := model.ConvertActivitiesList[val.ActivitiesId]
		if ok {
			openData.Bg = cfgData.BG
		}
		ntfMsg.OpenActivityList = append(ntfMsg.OpenActivityList, openData)
	}

	//util.DebugF("uid=%v StartupNtf msg=%v", this.role.GetUUid(), ntfMsg)
	this.role.ReplayGate(ntfMsg, true)
}

func (this *RoleActivity) recalActivityTime(convertData *model.ConvertActivitiesData) (uint64, uint64) {

	if this.registerDayTime.IsZero() {
		this.registerDayTime = util.GetDayByTimeStr2(this.role.RegisterTime)
	}

	tmpSTime1 := util.GetTimeByUint64(this.role.RegisterTime)
	if convertData.StartDay >= 1 {
		tmpSTime1 = tmpSTime1.AddDate(0, 0, convertData.StartDay-1)
	}
	//根据当前时间是否是5点之前确定是否是第一天
	//根据创建角色时间endday-startday + 1(持续时间)
	endDay := convertData.EndDay
	if tmpSTime1.Hour() < 5 {
		endDay -= 1
	}
	//tempSTime := util.GetTimeByStr(tmpSTime1.Format(util.DATE_FORMAT1) + " " + convertData.StartTimeStr) //开始时间
	tempSTime := tmpSTime1
	tmpSTime2 := this.registerDayTime
	if convertData.EndDay >= 1 {
		tmpSTime2 = tmpSTime2.AddDate(0, 0, endDay)
	}
	tempETime := util.GetTimeByStr(tmpSTime2.Format(util.DATE_FORMAT1) + " " + convertData.EndTimeStr) //结束时间

	StartTime := uint64(tempSTime.UnixNano() / 1e6)
	EndTime := uint64(tempETime.UnixNano() / 1e6)

	util.InfoF("StartTime:%v EndTime:%v", StartTime, EndTime)
	return StartTime, EndTime

}

func (this *RoleActivity) copyActivityDetailData(src, dst *serverproto.ActivitiesDetailData) {
	dst.ActivitiesId = src.ActivitiesId
	dst.ActivitiesType = src.ActivitiesType
	dst.StartTime = src.StartTime
	dst.EndTime = src.EndTime
	dst.CurDay = src.CurDay
	dst.LoginRewardList = src.LoginRewardList
	dst.ParamTime = src.ParamTime
	dst.RewardState = src.RewardState

	dst.CollectionList = src.CollectionList
	dst.ExchangeList = src.ExchangeList
	dst.KingTask = src.KingTask
	dst.SignData = src.SignData
	//if src.FightingTarget <= 0 {
	//	roleBase := this.role.GetRoleBase()
	//	if roleBase != nil && roleBase.RoleData() != nil{
	//		src.FightingTarget = roleBase.RoleData().FightPower
	//	}
	//}
	//dst.FightingTarget = src.FightingTarget
	if src.FortnightDays != nil {
		dst.FortnightDays = &serverproto.ActivitiesFortnightDays{}
		dst.FortnightDays.TaskScore = src.FortnightDays.TaskScore
		dst.FortnightDays.TaskScoreReward = src.FortnightDays.TaskScoreReward
	}

	if src.WheelData != nil {
		dst.WheelData = src.WheelData
	}

	//任务数据
	if src.ActivitiesType == int32(serverproto.EActivityType_EActivityType_14_Days_Task) {
		tmpTaskList, ok := this.activitiesTaskList[src.ActivitiesId]
		if ok {
			if dst.FortnightDays == nil {
				dst.FortnightDays = &serverproto.ActivitiesFortnightDays{}
			}
			for _, tmpTask := range tmpTaskList {
				dst.FortnightDays.TaskList = append(dst.FortnightDays.TaskList, tmpTask)
			}
		}
	}

	dst.LikabilityData = src.LikabilityData

	// bt
	dst.BtRocoinData = src.BtRocoinData
	dst.BtZhenjiaRechargeTaskList = src.BtZhenjiaRechargeTaskList
}

// 开启新活动
func (this *RoleActivity) OpenNewActivities(convertData *model.ConvertActivitiesData, ms uint64, notify bool) (bool, *serverproto.ActivitiesDetailData) {
	tmpActivityData, bFind := this.activityDataList[convertData.Id]
	if bFind {
		util.DebugF("uid=%v OpenNewActivities failed has activity id=%v", this.role.GetUUid(), convertData.Id)
		return false, nil
	}

	//判断是否超过最后开启时间的活动
	if convertData.TerminalOpenTimeMs > 0 && ms >= convertData.TerminalOpenTimeMs {
		return false, nil
	}

	//开启活动
	tmpActivityData = &serverproto.ActivitiesDetailData{
		ActivitiesId:   convertData.Id,
		ActivitiesType: convertData.ActivityType,
	}
	//根据角色创建时间
	if convertData.TimeType == model.ActivitiesTime_Type_Role {
		if this.registerDayTime.IsZero() {
			this.registerDayTime = util.GetDayByTimeStr2(this.role.RegisterTime)
		}
		//tmpSTime1 := this.registerDayTime
		tmpSTime1 := util.GetTimeByUint64(this.role.RegisterTime)
		if convertData.StartDay >= 1 {
			tmpSTime1 = tmpSTime1.AddDate(0, 0, convertData.StartDay-1)
		}
		//根据当前时间是否是5点之前确定是否是第一天
		//根据创建角色时间endday-startday + 1(持续时间)
		endDay := convertData.EndDay
		if tmpSTime1.Hour() < 5 {
			endDay -= 1
		}
		//tempSTime := util.GetTimeByStr(tmpSTime1.Format(util.DATE_FORMAT1) + " " + convertData.StartTimeStr) //开始时间
		tempSTime := tmpSTime1
		tmpSTime2 := this.registerDayTime
		if convertData.EndDay >= 1 {
			tmpSTime2 = tmpSTime2.AddDate(0, 0, endDay)
		}
		tempETime := util.GetTimeByStr(tmpSTime2.Format(util.DATE_FORMAT1) + " " + convertData.EndTimeStr) //结束时间

		tmpActivityData.StartTime = uint64(tempSTime.UnixNano() / 1e6)
		tmpActivityData.EndTime = uint64(tempETime.UnixNano() / 1e6)
	} else if convertData.TimeType == model.ActivitiesTime_Type_System {
		//判断开启条件是否成立，并且是否有相同类型活动(相同移除之前的活动)
		if !this.checkOpenNewActivitiesCondition(convertData) {
			util.InfoF("uid=%v OpenNewActivities failed activity end id=%v levelid=%v", this.role.GetUUid(), convertData.Id,
				this.role.GetRoleBattle().GetLevelId())
			return false, nil
		}
		tmpActivityData.StartTime = util.GetTimeMilliseconds()
	} else if convertData.TimeType == model.ActivitiesTime_Type_Server && convertData.ExpiredActivities {
		//过期后的活动是否强制开启(之前没有开启过，只针对相对开服时间开启的活动类型，立即开启)
		//判断是否已经开启过该活动
		if this.hasDelActivityByID(convertData.Id) {
			util.DebugF("uid=%v OpenNewActivities failed has opened activity id=%v", this.role.GetUUid(), convertData.Id)
			return false, nil
		}
		nowTime := util.GetTimeByUint64(ms)
		tmpSTime1 := nowTime
		tempSTime := tmpSTime1
		tmpSTime2 := nowTime
		if convertData.EndDay >= 1 {
			tmpSTime2 = tmpSTime2.AddDate(0, 0, convertData.EndDay-convertData.StartDay)
		}
		tempETime := util.GetTimeByStr(tmpSTime2.Format(util.DATE_FORMAT1) + " " + convertData.EndTimeStr) //结束时间
		tmpActivityData.StartTime = uint64(tempSTime.UnixNano() / 1e6)
		tmpActivityData.EndTime = uint64(tempETime.UnixNano() / 1e6)
	} else {
		if convertData.CalEndTimeMs > 0 {
			tmpActivityData.StartTime = uint64(convertData.CalStartTime.UnixNano() / 1e6)
			tmpActivityData.EndTime = convertData.CalEndTimeMs
		} else {
			if tmpActivityData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_Daily_Cum_Recharge) {
				tmpActivityData.StartTime = service.GetServiceStartupTime()
			} else {
				//永久开放活动
				tmpActivityData.StartTime = util.GetTimeMilliseconds()
			}
		}
	}

	if tmpActivityData.EndTime > 0 && (ms >= tmpActivityData.EndTime || ms < tmpActivityData.StartTime) {
		util.DebugF("uid=%v OpenNewActivities failed activity end id=%v", this.role.GetUUid(), convertData.Id)
		return false, nil
	}

	switch convertData.ActivityType {
	//14日目标任务
	case int32(serverproto.EActivityType_EActivityType_14_Days_Task):
		this.open14DaysTask(tmpActivityData, convertData)
	//14日登陆奖励
	case int32(serverproto.EActivityType_EActivityType_14_Days_Login):
		tmpCurDay := util.GetDurationDay2(tmpActivityData.StartTime, ms)
		tmpActivityData.CurDay = tmpCurDay
		tmpActivityData.LoginRewardList = append(tmpActivityData.LoginRewardList,
			&serverproto.KeyValueType{Key: tmpCurDay})
	case int32(serverproto.EActivityType_EActivityType_100Recharge):
		if tmpActivityData.ParamTime > 0 {
			tmpCurDay := util.GetDurationDay2(tmpActivityData.ParamTime, ms)
			tmpActivityData.CurDay = tmpCurDay
		}
	case int32(serverproto.EActivityType_EActivityType_Likability):
		tmpActivityData.LikabilityData = &serverproto.ActivitiesLikabilityData{
			Level: 1,
		}
	case int32(serverproto.EActivityType_EActivityType_Daily_Cum_Recharge):
		tmpActivityData.CurDay = util.GetDurationDay2(tmpActivityData.StartTime, ms)
	case int32(serverproto.EActivityType_EActivityType_King):
		this.InitKingGrowthTask(tmpActivityData)
		this.ResetTodayTask(tmpActivityData, ms)
	//活动转盘
	case int32(serverproto.EActivityType_EActivityType_Wheel):
		this.activityWheelInit(tmpActivityData)
	case int32(serverproto.EActivityType_EActivityType_SignIn):
		tmpActivityData.SignData = &serverproto.ActivitySignIn{}
		tmpActivityData.SignData.NextSignTime = util.GetLatest5Hour() - 24*3600*1000

	// bt服RO币每日累计充值
	case int32(serverproto.EActivityType_EActivityType_BT_ROCoinRecharge):
		tmpActivityData.CurDay = util.GetDurationDay2(tmpActivityData.StartTime, ms)
		tmpActivityData.BtRocoinData = &serverproto.ActivityBTROCoin{
			WeekDayEndTime: util.GetLatest5Hour() + 6*DayMS,
		}
		this.resetBTTasks(tmpActivityData)
	// bt服真假累计充值活动
	case int32(serverproto.EActivityType_EActivityType_BT_ZhenJiaRecharge):
		tmpActivityData.CurDay = util.GetDurationDay2(tmpActivityData.StartTime, ms)
		this.resetBTTasks(tmpActivityData)
	}
	this.activityDataList[convertData.Id] = tmpActivityData
	this.addChangeActivity(convertData.Id, 0)
	this.SetDirty(true)

	//之前该活动已经过期，后续有重新开启了该活动
	if this.delActivityList.Has(convertData.Id) {
		this.delActivityList.Remove(convertData.Id)
		this.addHasDelActivityList(convertData.Id, "OpenNewActivities")
	}

	util.DebugF("uid=%v OpenNewActivities ok activity id=%v", this.role.GetUUid(), convertData.Id)
	return true, tmpActivityData
}

func (this *RoleActivity) InitKingGrowthTask(activities *serverproto.ActivitiesDetailData) {
	activities.KingTask = activities.KingTask[:0]
	// 配置默认第一条读取全部成长任务
	db := model.GetKingTaskData(activities.ActivitiesId, 1)
	if db == nil {
		util.ErrorF("InitKingTask error")
		return
	}
	for _, taskId := range db.TaskIds {
		task := this.addDayTask(activities.ActivitiesId, uint32(taskId), 0, false, 1)
		if task == nil {
			continue
		}
		task.TaskType = model.TASK_TYPE_GROWUP
		activities.KingTask = append(activities.KingTask, task)
	}
}

// 重置国王的悬赏 今天挑战任务
func (this *RoleActivity) ResetTodayTask(activities *serverproto.ActivitiesDetailData, curTime uint64) {
	diffDay := util.GetDurationDay2(activities.StartTime, curTime)
	db := model.GetKingTaskData(activities.ActivitiesId, diffDay)
	if db == nil {
		util.ErrorF(" ResetTodayTask error, diffDay %v", diffDay)
		return
	}
	// 删除今日挑战任务
	for i := 0; i < len(activities.KingTask); {
		if activities.KingTask[i].TaskType != model.TASK_TYPE_TODAY {
			i++
			continue
		}
		this.delKingTask(activities, activities.KingTask[i].TaskId)
		activities.KingTask = append(activities.KingTask[:i], activities.KingTask[i+1:]...)
	}
	for _, taskId := range db.DailyTaskIds {
		dbTask, ok := model.ConvertActivitiesTaskList[int32(taskId)]
		if !ok {
			continue
		}
		task := this.addDayTask(activities.ActivitiesId, uint32(dbTask.TaskId), 0, true, 1)
		if task == nil {
			continue
		}
		task.TaskType = model.TASK_TYPE_TODAY
		activities.KingTask = append(activities.KingTask, task)
	}
	//this.addChangeActivity(activities.ActivitiesId, 0)
	this.SetDirty(true)
}

func (this *RoleActivity) OnlineProcess() {
	//for _, val := range this.activityDataList {
	//	if val.FightingTarget <= 0 {
	//		continue
	//	}
	//	for _, data := range val.KingTask {
	//		for _, progress := range data.Progress {
	//			if progress.Key != int32(serverproto.TaskType_Eve_Fight_value){continue}
	//		}
	//	}
	//	val.FightingTarget = 0
	//	val.FightingTarget = this.role.roleBattleAttr.curTotalFightPower
	//}
}

func (this *RoleActivity) checkOpenNewActivitiesCondition(convertData *model.ConvertActivitiesData) bool {
	if convertData != nil && convertData.ActivityType == int32(serverproto.EActivityType_EActivityType_100Recharge) {
		//开启首充同时开启 百元大礼包
		for idx := 0; idx < len(model.ConvertActFirstRecharge.OpenConditionList); idx++ {
			condition := model.ConvertActFirstRecharge.OpenConditionList[idx]
			switch condition.Key {
			//累计充值达到指定数值
			case int32(serverproto.TaskType_Level_Battle_Count):
				if this.role.GetRoleBattle().GetLevelId() >= condition.Value && this.firstChargeTime > 0 {
					//判断是否触发过
					for idx := 0; idx < len(this.hasDelActivityList); idx++ {
						if this.hasDelActivityList[idx] == convertData.Id {
							return false
						}
					}

					return true
				}
			}
		}
	}

	return false
}

func (this *RoleActivity) getWeekNumber(tmpDay int32) int32 {
	return int32(math.Ceil(float64(tmpDay) / 7))
}

func (this *RoleActivity) open14DaysTask(activityData *serverproto.ActivitiesDetailData,
	convertData *model.ConvertActivitiesData) {
	tmpCurDay := util.GetDurationDay2(activityData.StartTime, util.GetTimeMilliseconds())
	tmpCurWeek := this.getWeekNumber(tmpCurDay)
	//开启活动
	sIdx := tmpCurWeek*7 - 6
	for idx := sIdx; idx <= tmpCurDay; idx++ {
		dayVal, ok := model.ConvertActivitiesFortnightDaysList[idx]
		if !ok {
			continue
		}
		for k := 0; k < len(dayVal.TaskList); k++ {
			this.addDayTask(convertData.Id, dayVal.TaskList[k], dayVal.Days, false, tmpCurDay)
		}
		if idx == tmpCurDay {
			for k := 0; k < len(dayVal.DailyTaskList); k++ {
				this.addDayTask(convertData.Id, dayVal.DailyTaskList[k], dayVal.Days, true, tmpCurDay)
			}
		}
	}
	activityData.CurDay = tmpCurDay
	this.addChangeActivity(convertData.Id, 0)
	this.SetDirty(true)
}

func (this *RoleActivity) getAllActivityReward(activityData *serverproto.ActivitiesDetailData) {
	switch activityData.ActivitiesType {
	case int32(serverproto.EActivityType_EActivityType_14_Days_Login):
		this.getAllActivityReward14DaysLogin(activityData)
	case int32(serverproto.EActivityType_EActivityType_14_Days_Task):
		this.getAllActivityReward14DaysTask(activityData)
	case int32(serverproto.EActivityType_EActivityType_King):
		this.getAllActivityKingTaskReward(activityData)
		this.delAllKingTask(activityData)
		//activityData.KingTask = activityData.KingTask[:0]
	case int32(serverproto.EActivityType_EActivityType_Daily_Cum_Recharge):
		this.getAllActivityRewardCurRecharge(activityData)
	case int32(serverproto.EActivityType_EActivityType_BT_ROCoinRecharge):
		this.getAllActivityRewardBTRoCoinRecharge(activityData)
	case int32(serverproto.EActivityType_EActivityType_BT_ZhenJiaRecharge):
		this.getAllActivityRewardBTZhenJiaRecharge(activityData)
	}
}
func (this *RoleActivity) getAllActivityRewardCurRecharge(activityData *serverproto.ActivitiesDetailData) {
	var addItemList = map[int32]int32{}

	day := activityData.CurDay
	tmpRewardState := activityData.RewardState
	for {
		cfgData := model.GetActTiredRechargeDb(tmpRewardState+1, day)
		if cfgData == nil {
			break
		}
		if this.role.GetDayRecharge() < float32(cfgData.Amount) {
			break
		}
		tmpRewardState++

		for idx := 0; idx < len(cfgData.Rewards); idx++ {
			item := cfgData.Rewards[idx]
			if !CheckHDItemAdd(item.Key, this.role) {
				continue
			}
			addItemList[item.Key] += item.Value
		}
	}

	if len(addItemList) > 0 {
		//发送邮件奖励
		this.role.AddMail(model.GlobalMailIdActivitiesCurRechargeReward, serverproto.MailType_MailType_Activities,
			addItemList, []int32{activityData.ActivitiesId}, "", "")
	}
}

func (this *RoleActivity) delKingTask(activityData *serverproto.ActivitiesDetailData, taskId uint32) {
	this.addChangeActivity(activityData.ActivitiesId, taskId)
	tasks, ok := this.activitiesTaskList[activityData.ActivitiesId]
	if ok {
		delete(tasks, taskId)
	}
	this.SetDirty(true)
}

func (this *RoleActivity) delAllKingTask(activityData *serverproto.ActivitiesDetailData) {
	for _, task := range activityData.KingTask {
		this.delKingTask(activityData, task.TaskId)
	}
	this.SetDirty(true)
}

func (this *RoleActivity) getAllActivityKingTaskReward(activityData *serverproto.ActivitiesDetailData, taskTypes ...int32) {
	var addItemList = map[int32]int32{}
	for _, data := range activityData.KingTask {
		if data.State != TASK_REWARD_STATE_COMPLETED {
			continue
		}
		if len(taskTypes) > 0 {
			award := false
			for _, taskType := range taskTypes {
				if data.TaskType != taskType {
					continue
				}
				award = true
			}
			if !award {
				continue
			}
		}
		convertData, ok := model.ConvertActivitiesTaskList[int32(data.TaskId)]
		if !ok {
			continue
		}
		for k, v := range convertData.RewardList {
			addItemList[k] += v
		}
	}
	if len(addItemList) > 0 {
		//发送邮件奖励
		this.role.AddMail(model.GlobalMailIdActivitiesReward, serverproto.MailType_MailType_Activities,
			addItemList, []int32{activityData.ActivitiesId}, "", "")
	}
}

func (this *RoleActivity) getAllActivityReward14DaysLogin(activityData *serverproto.ActivitiesDetailData) {
	var addItemList = map[int32]int32{}

	for idx := 0; idx < len(activityData.LoginRewardList); idx++ {
		tmpVal := activityData.LoginRewardList[idx]
		if tmpVal.Value > 0 {
			continue
		}
		tmpParamId := activityData.ActivitiesId*1000 + tmpVal.Key
		if rewardVal, ok := model.ConvertActivitiesFOList[tmpParamId]; ok {
			for key, val := range rewardVal {
				addItemList[key] += val
			}
		}
	}

	if len(addItemList) > 0 {
		//发送邮件奖励
		this.role.AddMail(model.GlobalMailIdActivitiesReward, serverproto.MailType_MailType_Activities,
			addItemList, []int32{activityData.ActivitiesId}, "", "")
	}
}

func (this *RoleActivity) getAllActivityReward14DaysTask(activityData *serverproto.ActivitiesDetailData) {
	var addItemList = map[int32]int32{}
	//获取任务奖励
	tmpTaskList, ok := this.activitiesTaskList[activityData.ActivitiesId]
	if ok {
		for _, val := range tmpTaskList {
			this.addChangeActivity(activityData.ActivitiesId, val.TaskId)
			if val.State == TASK_REWARD_STATE_COMPLETED {
				convertData, ok := model.ConvertActivitiesTaskList[int32(val.TaskId)]
				if !ok {
					continue
				}
				for k, v := range convertData.RewardList {
					addItemList[k] += v
				}
				if activityData.FortnightDays == nil {
					activityData.FortnightDays = &serverproto.ActivitiesFortnightDays{}
				}
				activityData.FortnightDays.TaskScore += convertData.TaskScore
				if convertData.TaskScore > 0 {
					this.addChangeActivity(activityData.ActivitiesId, 0)
					this.SetDirty(true)
				}
			}
			delete(tmpTaskList, val.TaskId)

			this.taskTypeList[activityData.ActivitiesId] = map[int32]set.Interface{}
		}
	}

	//获取积分宝箱奖励
	for _, weekBoxCfgData := range model.ConvertActivitiesFortnightDaysScoreList {
		for idx := 0; idx < len(weekBoxCfgData); idx++ {
			if activityData.FortnightDays == nil ||
				activityData.FortnightDays.TaskScoreReward&(1<<uint32(weekBoxCfgData[idx].RewardIdx)) > 0 {
				continue
			}
			if weekBoxCfgData[idx].Score <= activityData.FortnightDays.TaskScore {
				for k, v := range weekBoxCfgData[idx].RewardList {
					addItemList[k] += v
				}
			}
		}
	}

	if len(addItemList) > 0 {
		//发送邮件奖励
		this.role.AddMail(model.GlobalMailIdActivitiesReward, serverproto.MailType_MailType_Activities,
			addItemList, []int32{activityData.ActivitiesId}, "", "")
	}

	if activityData.FortnightDays != nil {
		activityData.FortnightDays.TaskScore = 0
		activityData.FortnightDays.TaskScoreReward = 0
		activityData.FortnightDays.TaskList = activityData.FortnightDays.TaskList[:0]

		this.addChangeActivity(activityData.ActivitiesId, 0)
		this.SetDirty(true)
	}
}

// isDaily=false表示成长任务 true表示每日挑战任务
func (this *RoleActivity) addDayTask(activitiesId int32, taskId uint32, day int32, isDaily bool, tmpCurDay int32) *serverproto.TaskData {
	convertData, ok := model.ConvertActivitiesTaskList[int32(taskId)]
	if !ok {
		return nil
	}

	tmpTaskList, ok := this.activitiesTaskList[activitiesId]
	if !ok {
		tmpTaskList = map[uint32]*serverproto.TaskData{}
		this.activitiesTaskList[activitiesId] = tmpTaskList
	}

	taskDataInfo := &serverproto.TaskData{
		TaskId: taskId,
		State:  TASK_REWARD_STATE_NONE,
	}
	if isDaily {
		taskDataInfo.BeginTime = uint64(day)
	}

	for taskType, _ := range convertData.ConditionList {
		if taskType == int32(serverproto.TaskType_Eve_Fight_value) {
			addProgress := &serverproto.TaskProgressType{
				Key:   taskType,
				Value: 0,
			}
			roleBase := this.role.GetRoleBase()
			if roleBase != nil && roleBase.RoleData() != nil {
				addProgress.Total = uint32(roleBase.RoleData().FightPower)
			}
			taskDataInfo.Progress = append(taskDataInfo.Progress, addProgress)
		}
	}
	this.addChangeActivity(activitiesId, taskId)
	tmpTaskList[taskDataInfo.TaskId] = taskDataInfo
	this.addTaskType(activitiesId, convertData)

	this.SetDirty(true)

	//当前的挑战任务进度处理
	if tmpCurDay == day || !isDaily {
		TaskConditionCheck(this.role, taskDataInfo, serverproto.TaskType_NONE, convertData.ConditionList, 0, false)
	}
	return taskDataInfo
}

func (this *RoleActivity) addChangeActivity(activitiesId int32, taskId uint32) {
	//taskId == 0表示活动本身数据变更
	tmpChangeList, ok := this.changeTaskList[activitiesId]
	if !ok {
		tmpChangeList = set.New(set.NonThreadSafe)
		tmpChangeList.Add(taskId)

		this.changeTaskList[activitiesId] = tmpChangeList
	} else {
		tmpChangeList.Add(taskId)
	}
	this.SetDirty(true)
}

func (this *RoleActivity) TaskCheck(taskType serverproto.TaskType, count int32) {
	this.initTaskTypeList()

	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	//充值类活动处理
	this.taskCheckRecharge(ntfMsg)

	//任务类型
	for activitiesId, valList := range this.taskTypeList {
		typeList, ok := valList[int32(taskType)]
		if !ok || typeList.Size() <= 0 {
			continue
		}

		activityData, ok := this.activityDataList[activitiesId]
		if !ok {
			continue
		}

		var tmpNtfData *serverproto.ActivitiesDetailData = nil
		//tmpNtfData := &serverproto.ActivitiesDetailData{
		//	ActivitiesType: activityData.ActivitiesType,
		//	ActivitiesId:   activityData.ActivitiesId,
		//	CurDay:         activityData.CurDay,
		//	StartTime:      activityData.StartTime,
		//	EndTime:        activityData.EndTime,
		//}

		for _, val := range typeList.List() {
			tmpTaskId := val.(uint32)
			taskInfo := this.getTaskData(activityData.ActivitiesId, tmpTaskId)
			if taskInfo == nil {
				typeList.Remove(tmpTaskId)
				continue
			}
			convertData, ok := model.ConvertActivitiesTaskList[int32(tmpTaskId)]
			if !ok {
				typeList.Remove(tmpTaskId)
				continue
			}

			//判断是否是今天挑战任务，只能完成当天任务
			if taskInfo.BeginTime > 0 && taskInfo.BeginTime != uint64(activityData.CurDay) {
				continue
			}

			ret := TaskConditionCheck(this.role, taskInfo, taskType, convertData.ConditionList, count, false)
			if ret {
				if tmpNtfData == nil {
					tmpNtfData = &serverproto.ActivitiesDetailData{
						ActivitiesType: activityData.ActivitiesType,
						ActivitiesId:   activityData.ActivitiesId,
						CurDay:         activityData.CurDay,
						StartTime:      activityData.StartTime,
						EndTime:        activityData.EndTime,
					}
				}
				this.addChangeActivity(activityData.ActivitiesId, tmpTaskId)
				if activityData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_14_Days_Task) {
					if tmpNtfData.FortnightDays == nil {
						tmpNtfData.FortnightDays = &serverproto.ActivitiesFortnightDays{}
					}
					if activityData.FortnightDays != nil {
						tmpNtfData.FortnightDays.TaskScore = activityData.FortnightDays.TaskScore
						tmpNtfData.FortnightDays.TaskScoreReward = activityData.FortnightDays.TaskScoreReward
					}
					tmpNtfData.FortnightDays.TaskList = append(tmpNtfData.FortnightDays.TaskList, taskInfo)
				} else if activityData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_BT_ZhenJiaRecharge) {
					// BT task data
					tmpNtfData.BtZhenjiaRechargeTaskList = append(activityData.BtZhenjiaRechargeTaskList, taskInfo)
				} else if activityData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_BT_ROCoinRecharge) {
					// BT task data
					if tmpNtfData.BtRocoinData == nil {
						tmpNtfData.BtRocoinData = &serverproto.ActivityBTROCoin{
							WeekDayEndTime: activityData.BtRocoinData.WeekDayEndTime,
						}
					}
					if taskInfo.TaskType == int32(model.BTTaskRefreshType_Day) {
						tmpNtfData.BtRocoinData.DailyTaskList = append(tmpNtfData.BtRocoinData.DailyTaskList, taskInfo)
					} else {
						tmpNtfData.BtRocoinData.WeekTaskList = append(tmpNtfData.BtRocoinData.WeekTaskList, taskInfo)
					}
				}
				this.SetDirty(true)
			}
		}
		if tmpNtfData != nil {
			if tmpNtfData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_King) {
				if len(activityData.KingTask) > 0 {
					tmpNtfData.KingTask = activityData.KingTask
					//tmpNtfData.FightingTarget = activityData.FightingTarget
				}
			}
			ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, tmpNtfData)
		}
	}

	if len(ntfMsg.ActivityDataList) > 0 {
		this.role.ReplayGate(ntfMsg, true)
		util.InfoF("uid=%v TaskCheck changelist=%v", this.role.GetUUid(), ntfMsg)
	}
}

// 充值类活动处理
func (this *RoleActivity) taskCheckRecharge(ntfMsg *serverproto.SCActivitiesChangeNtf) {
	//百元礼包处理
	for _, val := range this.activityDataList {
		if val.ActivitiesType == int32(serverproto.EActivityType_EActivityType_100Recharge) {
			if val.ParamTime > 0 {
				break
			}
			if this.role.GetTotalRecharge() >= model.ConvertAct100Recharge.RechargeAmount {
				val.ParamTime = util.GetTimeMilliseconds()
				this.SetDirty(true)
				ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, val)
			}
			break
		}
	}
}

func (this *RoleActivity) initTaskTypeList() {
	if this.initTaskType {
		return
	}
	if len(this.activitiesTaskList) > 0 {
		this.initTaskType = true
	}

	for activitiesId, actTaskList := range this.activitiesTaskList {
		for _, val := range actTaskList {
			convertData, ok := model.ConvertActivitiesTaskList[int32(val.TaskId)]
			if !ok {
				this.addChangeActivity(activitiesId, val.TaskId)
				delete(actTaskList, val.TaskId)
				this.delTaskType(activitiesId, convertData)
				continue
			}
			this.addTaskType(activitiesId, convertData)
		}
	}
}

func (this *RoleActivity) addTaskType(activitiesId int32, convertData *model.ConvertActivitiesTaskData) {
	tmpTaskType, ok := this.taskTypeList[activitiesId]
	if !ok {
		tmpTaskType = map[int32]set.Interface{}
		this.taskTypeList[activitiesId] = tmpTaskType
	}
	for key := range convertData.ConditionList {
		if _, ok := tmpTaskType[key]; !ok {
			tmpTaskType[key] = set.New(set.NonThreadSafe)
		}
		tmpTaskType[key].Add(uint32(convertData.TaskId))
	}
}
func (this *RoleActivity) delTaskType(activitiesId int32, convertData *model.ConvertActivitiesTaskData) {
	tmpTaskType, ok := this.taskTypeList[activitiesId]
	if ok {
		for key := range convertData.ConditionList {
			if _, ok := tmpTaskType[key]; ok {
				tmpTaskType[key].Remove(uint32(convertData.TaskId))
			}
		}
	}
}

func (this *RoleActivity) getTaskData(activitiesId int32, taskId uint32) *serverproto.TaskData {
	tmpData, ok := this.activitiesTaskList[activitiesId]
	if ok {
		if taskInfo, ok := tmpData[taskId]; ok {
			return taskInfo
		}
	}

	return nil
}

func (this *RoleActivity) getActivityData(activityId int32) *serverproto.ActivitiesDetailData {
	activityData, ok := this.activityDataList[activityId]
	if ok {
		if util.GetTimeMilliseconds() >= activityData.EndTime && activityData.EndTime > 0 {
			return nil
		}
		return activityData
	}
	return nil
}

func (this *RoleActivity) getActivityByType(ActivityType int32) (rets []*serverproto.ActivitiesDetailData) {
	for _, data := range this.activityDataList {
		if data.ActivitiesType != ActivityType {
			continue
		}
		if util.GetTimeMilliseconds() >= data.EndTime && data.EndTime > 0 {
			continue
		}
		rets = append(rets, data)
	}
	return
}

// 精彩活动奖励获取
func (this *RoleActivity) ActivitiesReward(activityId int32, param int32, rewardNum int32) serverproto.ErrorCode {
	cfgData, ok := model.ConvertActivitiesList[activityId]
	if !ok {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	switch (serverproto.EActivityType)(cfgData.ActivityType) {
	case serverproto.EActivityType_EActivityType_14_Days_Login: //14日登录
		return this.activitiesReward14DaysLogin(activityId, param)

	case serverproto.EActivityType_EActivityType_14_Days_Task: //14日目标任务
		return this.activitiesReward14DaysTask(activityId, param)

	case serverproto.EActivityType_EActivityType_100Recharge: //百元礼包
		return this.activitiesReward100Recharge(activityId)

	case serverproto.EActivityType_EActivityType_Daily_Cum_Recharge: //每日累充活动
		return this.activitiesRewardDailyCumRecharge(activityId)

	case serverproto.EActivityType_EActivityType_ExChange: //集字活动
		return this.activitiesRewardCollection(activityId, param, nil, rewardNum)

	case serverproto.EActivityType_EActivityType_King: // 国王的盛宴任务
		return this.activitiesRewardKingTask(activityId, param, rewardNum)

	case serverproto.EActivityType_EActivityType_BT_ROCoinRecharge: // bt RO币累计活动
		return this.activitiesRewardBTRoCoinRecharge(activityId, param)
	case serverproto.EActivityType_EActivityType_BT_ZhenJiaRecharge: // 真/假每日累计充值活动
		return this.activitiesRewardBTZhenJiaRecharge(activityId, param)

	default:
		return serverproto.ErrorCode_ERROR_FAIL
	}

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) activitiesReward14DaysLogin(activityId, param int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	if param >= 100 || param <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	//已经获取当天奖励
	bFindIdx := -1
	for idx := 0; idx < len(activityData.LoginRewardList); idx++ {
		if activityData.LoginRewardList[idx].Key != param {
			continue
		}
		if activityData.LoginRewardList[idx].Value > 0 {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_HAS_REWARD
		}
		bFindIdx = idx
		break
	}
	if param > activityData.CurDay {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT_CUR_DAY_REWARD
	}

	tmpParamId := activityId*1000 + param
	if rewardVal, ok := model.ConvertActivitiesFOList[tmpParamId]; ok {
		ret := this.role.CanAddItemList(rewardVal)
		if ret != serverproto.ErrorCode_ERROR_OK {
			return ret
		}

		if bFindIdx > -1 {
			activityData.LoginRewardList[bFindIdx].Value = 1
		} else {
			//消耗资源补签
			if !this.role.GetRoleBag().CanDelItem(int32(serverproto.ResType_Res_Rmb), model.GlobalActivities14DaysLogin) {
				return this.role.GetResNotice(int32(serverproto.ResType_Res_Rmb))
			}
			this.role.DelItem(int32(serverproto.ResType_Res_Rmb), model.GlobalActivities14DaysLogin, AddItemST{AddFrom: AddFrom_Activities})

			activityData.LoginRewardList = append(activityData.LoginRewardList, &serverproto.KeyValueType{Key: param, Value: 1})
		}
		this.role.AddItemList(rewardVal, AddFrom_Activities, true)
		this.addChangeActivity(activityId, 0)
		this.SetDirty(true)

		//通知数据变更
		ntfMsg := &serverproto.SCActivitiesChangeNtf{
			CurDayEndTime: this.curDayEndTime,
		}
		ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
		this.role.ReplayGate(ntfMsg, true)

		//ack奖励处理
		ackMsg := &serverproto.SCActivitiesRewardAck{
			Error:      int32(serverproto.ErrorCode_ERROR_OK),
			ActivityId: activityData.ActivitiesId,
		}
		for key, val := range rewardVal {
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: key, Value: val})
		}
		this.role.ReplayGate(ackMsg, true)

		return serverproto.ErrorCode_ERROR_OK
	} else {
		//无奖励数据
		return serverproto.ErrorCode_ERROR_FAIL
	}
}

func (this *RoleActivity) checkTaskInfo(taskInfo *serverproto.TaskData) bool {
	convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
	if !ok {
		return false
	}

	return TaskConditionCheck(this.role, taskInfo, 0, convertData.ConditionList, 0, true)
}

func (this *RoleActivity) activitiesRewardKingTask(activityId, taskId int32, taskType int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	taskInfo := this.getTaskData(activityId, uint32(taskId))
	if taskInfo == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	if taskInfo.State == TASK_REWARD_STATE_REWARD {
		return serverproto.ErrorCode_ERROR_TASK_REWARDED
	}
	//应对玩家任务条件调整
	if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
		if this.checkTaskInfo(taskInfo) {
			if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
				return serverproto.ErrorCode_ERROR_TASK_REWARDED
			}
		} else {
			return serverproto.ErrorCode_ERROR_TASK_REWARDED
		}
	}

	convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
	if !ok {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	ret := this.role.CanAddItemList(convertData.RewardList)
	if ret != serverproto.ErrorCode_ERROR_OK {
		return ret
	}
	this.role.AddItemList(convertData.RewardList, AddFrom_Activities, true)

	//任务状态修改
	taskInfo.State = TASK_REWARD_STATE_REWARD
	this.addChangeActivity(activityId, taskInfo.TaskId)
	this.addChangeActivity(activityId, 0)
	this.SetDirty(true)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	detailData := &serverproto.ActivitiesDetailData{
		ActivitiesId:   activityId,
		ActivitiesType: activityData.ActivitiesType,
		StartTime:      activityData.StartTime,
		EndTime:        activityData.EndTime,
		KingTask:       activityData.KingTask,
	}
	//detailData.FortnightDays.TaskList = append(detailData.FortnightDays.TaskList, taskInfo)
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, detailData)
	this.role.ReplayGate(ntfMsg, true)

	//ack奖励处理
	ackMsg := &serverproto.SCActivitiesRewardAck{
		Error:      int32(serverproto.ErrorCode_ERROR_OK),
		ActivityId: activityId,
	}
	for key, val := range convertData.RewardList {
		ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: key, Value: val})
	}
	this.role.ReplayGate(ackMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) activitiesReward14DaysTask(activityId, param int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	if param <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	taskInfo := this.getTaskData(activityId, uint32(param))
	if taskInfo == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	if taskInfo.State == TASK_REWARD_STATE_REWARD {
		return serverproto.ErrorCode_ERROR_TASK_REWARDED
	}
	//应对玩家任务条件调整
	if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
		if this.checkTaskInfo(taskInfo) {
			if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
				return serverproto.ErrorCode_ERROR_TASK_REWARDED
			}
		} else {
			return serverproto.ErrorCode_ERROR_TASK_REWARDED
		}
	}

	convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
	if !ok {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	ret := this.role.CanAddItemList(convertData.RewardList)
	if ret != serverproto.ErrorCode_ERROR_OK {
		return ret
	}
	this.role.AddItemList(convertData.RewardList, AddFrom_Activities, true)

	//任务状态修改
	taskInfo.State = TASK_REWARD_STATE_REWARD
	//累计任务积分
	if activityData.FortnightDays == nil {
		activityData.FortnightDays = &serverproto.ActivitiesFortnightDays{}
	}
	activityData.FortnightDays.TaskScore += convertData.TaskScore
	this.addChangeActivity(activityId, taskInfo.TaskId)
	this.addChangeActivity(activityId, 0)
	this.SetDirty(true)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	detailData := &serverproto.ActivitiesDetailData{
		ActivitiesId:   activityId,
		ActivitiesType: activityData.ActivitiesType,
		StartTime:      activityData.StartTime,
		EndTime:        activityData.EndTime,
		CurDay:         activityData.CurDay,
		FortnightDays: &serverproto.ActivitiesFortnightDays{
			TaskScore:       activityData.FortnightDays.TaskScore,
			TaskScoreReward: activityData.FortnightDays.TaskScoreReward,
		},
	}
	detailData.FortnightDays.TaskList = append(detailData.FortnightDays.TaskList, taskInfo)
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, detailData)
	this.role.ReplayGate(ntfMsg, true)

	//ack奖励处理
	ackMsg := &serverproto.SCActivitiesRewardAck{
		Error:      int32(serverproto.ErrorCode_ERROR_OK),
		ActivityId: activityId,
	}
	for key, val := range convertData.RewardList {
		ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: key, Value: val})
	}
	this.role.ReplayGate(ackMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

// 宝箱奖励获取
func (this *RoleActivity) ActivitiesScoreReward(activityId, boxId int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	if activityData.ActivitiesType != int32(serverproto.EActivityType_EActivityType_14_Days_Task) ||
		activityData.FortnightDays == nil || activityData.FortnightDays.TaskScore <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if boxId <= 0 || boxId > 30 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	if activityData.FortnightDays.TaskScoreReward&(1<<uint32(boxId)) > 0 {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_BOX_REWARD_HAS
	}

	//获取奖励
	ackMsg := &serverproto.SCActivitiesScoreRewardAck{
		Error:      int32(serverproto.ErrorCode_ERROR_OK),
		ActivityId: activityId,
	}
	addItemList := map[int32]int32{}
	for _, weekBoxCfgData := range model.ConvertActivitiesFortnightDaysScoreList {
		for idx := 0; idx < len(weekBoxCfgData); idx++ {
			if weekBoxCfgData[idx].RewardIdx == boxId {
				if weekBoxCfgData[idx].Score <= activityData.FortnightDays.TaskScore {
					for k, v := range weekBoxCfgData[idx].RewardList {
						ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: k, Value: v})
						addItemList[k] += v
					}
				}
				break
			}
		}
	}

	if len(addItemList) <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	ret := this.role.CanAddItemList(addItemList)
	if ret != serverproto.ErrorCode_ERROR_OK {
		return ret
	}
	this.role.AddItemList(addItemList, AddFrom_Activities, true)
	util.InfoF("uid=%v ActivitiesScoreReward rewardlist=%v", this.role.GetUUid(), addItemList)

	activityData.FortnightDays.TaskScoreReward |= 1 << uint32(boxId)
	this.addChangeActivity(activityId, 0)
	this.SetDirty(true)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	detailData := &serverproto.ActivitiesDetailData{
		ActivitiesId:   activityId,
		ActivitiesType: activityData.ActivitiesType,
		StartTime:      activityData.StartTime,
		EndTime:        activityData.EndTime,
		CurDay:         activityData.CurDay,
		FortnightDays: &serverproto.ActivitiesFortnightDays{
			TaskScore:       activityData.FortnightDays.TaskScore,
			TaskScoreReward: activityData.FortnightDays.TaskScoreReward,
		},
	}
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, detailData)
	this.role.ReplayGate(ntfMsg, true)

	this.role.ReplayGate(ackMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

// /充值活动相关
// 首充
func (this *RoleActivity) FirstChargeUnlockState() bool {
	bOk := false
	// 开启的同时开启百元大礼包活动
	//conditionList := model.ConvertActFirstRecharge.OpenConditionStrList
	levelUnlock := this.role.GetRoleBase().checkUnLockState(0, model.ConvertActFirstRecharge.OpenConditionList)
	if this.firstChargeTime == 0 && this.firstChargeRewardStat == 0 && levelUnlock == serverproto.ErrorCode_ERROR_OK &&
		this.role.GetTotalRecharge() >= model.ConvertActFirstRecharge.RechargeAmount {
		this.firstChargeTime = util.GetTimeMilliseconds()
		this.SetDirty(true)
		bOk = true

		firstChargeNtfMsg := &serverproto.SCActivitiesFirstChargeChangeNtf{
			FirstChargeTime:        this.firstChargeTime,
			FirstChargeRewardState: this.firstChargeRewardStat,
		}
		this.role.ReplayGate(firstChargeNtfMsg, true)
	}

	//根据玩家开启系统决定活动开启
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	openListNtfMsg := &serverproto.SCActivitiesOpenListNtf{}
	for _, convertData := range ActivitiesMag.RoleSystemActList {
		ret, detailInfo := this.OpenNewActivities(convertData, util.GetTimeMilliseconds(), false)
		if ret {
			tmpData := &serverproto.ActivitiesData{
				Id:   convertData.Id,
				Type: convertData.ActivityType,
				Bg:   convertData.BG,
			}
			openListNtfMsg.ActivityList = append(openListNtfMsg.ActivityList, tmpData)
			ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, detailInfo)
		}
	}
	if len(openListNtfMsg.ActivityList) > 0 {
		this.role.ReplayGate(openListNtfMsg, true)
	}
	if len(ntfMsg.ActivityDataList) > 0 {
		this.role.ReplayGate(ntfMsg, true)
	}

	return bOk
}

// 超值礼包开启(利用任务类型触发)
type SuperChargeUnlockST struct {
	oldValue       int32
	rewardCardList map[int32]int32
}

func (this *RoleActivity) SuperChargeUnlockCheck(unlockType serverproto.UnlockChargeType, st *SuperChargeUnlockST) {
	oldValue := st.oldValue

	nowTime := util.GetTimeMilliseconds()
	bAdd := false
	typeSuperList, ok := model.ConvertActDiscountsRechargeList[int32(unlockType)]
	if !ok {
		return
	}
	for idx := 0; idx < len(typeSuperList); idx++ {
		cfgData := typeSuperList[idx]
		//for _, cfgData := range typeSuperList {
		//if cfgData.OpenCondition.Key != int32(unlockType) {
		//	continue
		//}
		//已经触发的并超过触发次数则不再触发
		tmpVal, ok := this.unlockChargeHasList[cfgData.ProductId]
		//tmpVal, ok := this.unlockChargeHasList[cfgData.Id]
		if ok && tmpVal.Value >= cfgData.UnlockCount {
			continue
		}

		val := cfgData.OpenCondition.ValueList[0]
		var curVal int32 = 0
		switch unlockType {
		case serverproto.UnlockChargeType_UChargeType_BattleLevel: //通关指定关卡，触发此类的超值礼包
			curVal = this.role.GetRoleBattle().GetLevelId()
			//优化处理，列表中为有序列表
			if curVal < val {
				break
			}
		case serverproto.UnlockChargeType_UChargeType_ClimbTowerLevel: //试炼之塔到达指定的层数，触发此类超值礼包
			curVal = this.role.GetRoleTower().GetCurTower()
		case serverproto.UnlockChargeType_UChargeType_BaseLevel: //主角等级达到指定等级，触发此类的超值礼包
			curVal = this.role.GetRoleLevel()
		case serverproto.UnlockChargeType_UChargeType_SkillLevelUp: //技能升级	资源不够
			val1 := cfgData.OpenCondition.ValueList[1]
			if this.role.GetRoleLevel() >= val && this.role.GetRoleBase().GetCruise() < val1 {
				//是否需要根据累计充值来触发
				if cfgData.Recharge > 0 {
					rechargeTap := this.role.GetTotalRechargeTap()
					if rechargeTap <= 0 || rechargeTap != cfgData.Recharge {
						continue
					}
				}

				//解锁特定超值礼包
				unlockData := &serverproto.ActivitiesUnlockRechargeData{
					ActivitiesId: cfgData.Id,
					StartTime:    nowTime,
					EndTime:      nowTime + cfgData.DurationTime,
				}
				this.superUnlockChargeList = append(this.superUnlockChargeList, unlockData)
				bAdd = true
				if tmpVal == nil {
					tmpVal = &serverproto.KeyValueType{Key: cfgData.ProductId, Value: 1}
				} else {
					tmpVal.Value++
				}
				this.unlockChargeHasList[tmpVal.Key] = tmpVal
				continue
			}
		case serverproto.UnlockChargeType_UChargeType_SKillAdvance: //所有英雄技能进阶次数
			curVal = this.role.GetRoleSkill().GetAllHeroSkillAdvanceNum()
		case serverproto.UnlockChargeType_UChargeType_DrawCardMVP: //抽卡	获得MVP
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_DrawPetMVP: //抽宠	获得MVP
			curVal = oldValue
			if val != oldValue {
				curVal = 0
			}
		case serverproto.UnlockChargeType_UChargeType_DrawCardQualityNum: //抽到5个蓝色卡片时触发
			if len(cfgData.OpenCondition.ValueList) >= 2 {
				val = cfgData.OpenCondition.ValueList[1]
				cardQuality := cfgData.OpenCondition.ValueList[0]
				for k, v := range st.rewardCardList {
					cardCfg, ok2 := serverproto.CardCfgLoader[k]
					if !ok2 {
						continue
					}
					if cardCfg.CardType == cardQuality {
						curVal += v
					}
				}
			} else {
				util.ErrorF("uid=%v SuperChargeUnlockCheck unlockType=%v", this.role.GetUUid(), unlockType)
				return
			}

		case serverproto.UnlockChargeType_UChargeType_DrawCardSpecial: //抽卡保底
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_DrawPetSpecial: //抽宠物保底
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_DrawSkillEquipSpecial: //抽神器保底
			curVal = oldValue
			if val != oldValue {
				curVal = 0
			}
		case serverproto.UnlockChargeType_UChargeType_HeroStrength: //伙伴突破
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_HeroLevel: //伙伴等级
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_PayAmount: //单次充值金额
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_ZenyOnceCost: //银币一次性消耗	资源不够
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_ShopNormalRMBCost: //普通商店	金币消耗数量
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_ArenaShopCost: //英灵殿商店	功勋消耗数量
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_GuildShopCost: //公会商店	公会币消耗数量
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_SpecialShopRMB: //黑市商店	金币消耗数量
			fallthrough
		case serverproto.UnlockChargeType_UChargeType_PetShopCost: //宠物商店	分解石消耗数量
			curVal = oldValue
		}

		if curVal > 0 && curVal >= val {
			//是否需要根据累计充值来触发
			if cfgData.Recharge > 0 {
				rechargeTap := this.role.GetTotalRechargeTap()
				if rechargeTap <= 0 || rechargeTap != cfgData.Recharge {
					continue
				}
			}

			//条件优先级触发类型
			//解锁特定超值礼包
			unlockData := &serverproto.ActivitiesUnlockRechargeData{
				ActivitiesId: cfgData.Id,
				StartTime:    nowTime,
				EndTime:      nowTime + cfgData.DurationTime,
			}
			this.superUnlockChargeList = append(this.superUnlockChargeList, unlockData)
			bAdd = true
			if tmpVal == nil {
				tmpVal = &serverproto.KeyValueType{Key: cfgData.ProductId, Value: 1}
			} else {
				tmpVal.Value++
			}
			this.unlockChargeHasList[tmpVal.Key] = tmpVal

			util.InfoF("uid=%v SuperChargeUnlockCheck unlock cfg=%v totalRecharge=%v", this.role.GetUUid(),
				cfgData.Id, this.role.GetTotalRecharge())
		}
	}

	if bAdd {
		this.SetDirty(true)

		ntfMsg := &serverproto.SCActivitiesDiscountsNtf{
			DiscountDataList: this.superUnlockChargeList,
		}
		this.role.ReplayGate(ntfMsg, true)
	}
}

// 获取首充奖励
func (this *RoleActivity) ActivitiesFirstChargeReward() serverproto.ErrorCode {
	if this.firstChargeTime <= 0 || model.ConvertActFirstRecharge == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_REWARD_NOT
	}
	ackMsg := &serverproto.SCActivitiesFirstChargeRewardAck{}
	nowTime := util.GetTimeMilliseconds()
	diffDay := util.GetDurationDay2(this.firstChargeTime, nowTime)
	var maxDiffDay int32 = 3
	if diffDay < maxDiffDay {
		maxDiffDay = diffDay
	}
	for idx := 1; idx <= int(maxDiffDay); idx++ {
		if this.firstChargeRewardStat&(1<<uint32(idx)) > 0 {
			continue
		}
		this.firstChargeRewardStat |= 1 << uint32(idx)
		switch idx {
		case 1:
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, model.ConvertActFirstRecharge.Day1Reward...)
		case 2:
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, model.ConvertActFirstRecharge.Day2Reward...)
		case 3:
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, model.ConvertActFirstRecharge.Day3Reward...)
		}
	}

	//奖励领取完毕，活动消失(首充和百元奖励都领取完毕)
	this.checkFirstChargeAnd100RechargeEnd(0, nil)

	if len(ackMsg.RewardItemList) > 0 {
		ntfMsg := &serverproto.SCActivitiesFirstChargeChangeNtf{
			FirstChargeRewardState: this.firstChargeRewardStat,
			FirstChargeTime:        this.firstChargeTime,
		}
		this.role.ReplayGate(ntfMsg, true)

		var addItemList = map[int32]int32{}
		for idx := 0; idx < len(ackMsg.RewardItemList); idx++ {
			item := ackMsg.RewardItemList[idx]
			addItemList[item.Key] += item.Value
		}
		this.role.AddItemList(addItemList, AddFrom_Activities, true)
		this.role.ReplayGate(ackMsg, true)

		this.SetDirty(true)
		return serverproto.ErrorCode_ERROR_OK
	}
	return serverproto.ErrorCode_ERROR_ACTIVITIES_REWARD_NOT
}

func (this *RoleActivity) ActivitiesLikability(activityId int32, itemId, likabilityItemLevel int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT_LIKE
	}
	if activityData.ActivitiesType != int32(serverproto.EActivityType_EActivityType_Likability) {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT_LIKE
	}

	actCfgData, ok := model.ConvertActivitiesList[activityId]
	if !ok {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT_LIKE
	}
	if !actCfgData.HDItemList.Has(itemId) {
		util.InfoF("uid=%v ActivitiesLikability itemId=%v not correct", this.role.GetUUid(), itemId)
		return serverproto.ErrorCode_ERROR_FAIL
	}
	cfgActivityData, ok := model.ConvertActLikabilityItemList[activityId]
	if !ok {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	cfgData, ok := cfgActivityData[itemId]
	if !ok {
		util.InfoF("uid=%v ActivitiesLikability itemId=%v not correct", this.role.GetUUid(), itemId)
		return serverproto.ErrorCode_ERROR_FAIL
	}
	if likabilityItemLevel <= 0 || int(likabilityItemLevel) > len(cfgData.LikabilityList) {
		util.InfoF("uid=%v ActivitiesLikability likabilityLevel=%v not correct", this.role.GetUUid(), likabilityItemLevel)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	if activityData.LikabilityData == nil {
		activityData.LikabilityData = &serverproto.ActivitiesLikabilityData{
			Level: 1,
		}
		this.addChangeActivity(activityId, 0)
		this.SetDirty(true)
	}
	likeCfgActivityData, ok := model.ConvertActLikabilityList[activityId]
	if !ok {
		util.ErrorF("uid=%v ActivitiesLikability ConvertActLikability level=%v not correct", this.role.GetUUid(), activityData.LikabilityData.Level)
		return serverproto.ErrorCode_ERROR_FAIL
	}
	likeCfgData, ok := likeCfgActivityData[activityData.LikabilityData.Level]
	if !ok {
		util.ErrorF("uid=%v ActivitiesLikability ConvertActLikability level=%v not correct", this.role.GetUUid(), activityData.LikabilityData.Level)
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//好感度等级已达上限
	if uint32(likeCfgData.LikeValMax) <= activityData.LikabilityData.Param {
		_, ok := likeCfgActivityData[activityData.LikabilityData.Level+1]
		if !ok {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_LIKE_LEVEL_LIMIT
		}
	}

	//消耗道具判断
	addKv := cfgData.LikabilityList[likabilityItemLevel-1]
	if !this.role.GetRoleBag().CanDelItem(addKv.Key, addKv.ValueList[0]) {
		return serverproto.ErrorCode_ERROR_RES_NOT_ENOUGH
	}

	oldLikeLevel := activityData.LikabilityData.Level
	oldLikeVal := int32(activityData.LikabilityData.Param)
	newLikeVal := oldLikeVal + addKv.ValueList[1]
	rewardList := map[int32]int32{}
	retLikeLevel, retLikeVal := this.activitiesLikabilityAddVal(likeCfgActivityData, oldLikeLevel, oldLikeVal, newLikeVal, rewardList)
	if len(rewardList) > 0 {
		ret := this.role.CanAddItemList(rewardList)
		if ret != serverproto.ErrorCode_ERROR_OK {
			return ret
		}
		this.role.AddItemList(rewardList, AddFrom_Activities, true)
	}
	this.role.DelItem(addKv.Key, addKv.ValueList[0], AddItemST{AddFrom: AddFrom_Activities, Notify: true})

	activityData.LikabilityData.Level = retLikeLevel
	activityData.LikabilityData.Param = uint32(retLikeVal)
	this.addChangeActivity(activityId, 0)
	this.SetDirty(true)

	util.InfoF("uid=%v ActivitiesLikability activityId=%v itemId=%v newLevel=%v newVal=%v oldLevel=%v oldVal=%v",
		this.role.GetUUid(), activityId, itemId, retLikeLevel, retLikeVal, oldLikeLevel, oldLikeVal)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
	this.role.ReplayGate(ntfMsg, true)

	if len(rewardList) > 0 {
		ackMsg := &serverproto.SCActivitiesLikabilityRewardAck{
			Error: int32(serverproto.ErrorCode_ERROR_OK),
		}
		for k, v := range rewardList {
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: k, Value: v})
		}
		this.role.ReplayGate(ackMsg, true)
	}

	//系统播报
	if addKv.ValueList[2] > 0 {
		this.role.AddSystemMessage(SystemmessageType_Likability,
			AddSystemMsg{ParamId: activityId,
				ParamList: []int32{addKv.Key, addKv.ValueList[0]}})
	}

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) activitiesLikabilityAddVal(likeCfgActivityData map[int32]*model.ConvertActLikabilityData,
	curLikeLevel int32, oldLikeVal, newLikeVal int32, rewardList map[int32]int32) (retLikeLevel, retLikeVal int32) {
	retLikeLevel = curLikeLevel
	retLikeVal = oldLikeVal

	likeCfgData, ok := likeCfgActivityData[curLikeLevel]
	if !ok {
		return
	}
	for idx := 0; idx < len(likeCfgData.RewardList); idx++ {
		if likeCfgData.RewardList[idx].Key <= oldLikeVal {
			continue
		}
		if likeCfgData.RewardList[idx].Key <= newLikeVal {
			rewardList[likeCfgData.RewardList[idx].ValueList[0]] += likeCfgData.RewardList[idx].ValueList[1]
		}
	}
	if likeCfgData.LikeValMax <= newLikeVal {
		_, ok := likeCfgActivityData[curLikeLevel+1]
		if !ok {
			retLikeVal = newLikeVal
		} else {
			newLikeVal = newLikeVal - likeCfgData.LikeValMax
			retLikeLevel, retLikeVal = this.activitiesLikabilityAddVal(likeCfgActivityData, curLikeLevel+1, 0, newLikeVal, rewardList)
		}
	} else {
		retLikeVal = newLikeVal
	}

	return
}

func (this *RoleActivity) activitiesReward100Recharge(activityId int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil || model.ConvertAct100Recharge == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	if this.role.GetTotalRecharge() < model.ConvertAct100Recharge.RechargeAmount ||
		activityData.ParamTime <= 0 {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_REWARD_NOT
	}

	nowTime := util.GetTimeMilliseconds()
	diffDay := util.GetDurationDay2(activityData.ParamTime, nowTime)
	var maxDiffDay int32 = 3
	if diffDay < maxDiffDay {
		maxDiffDay = diffDay
	}

	//ack奖励处理
	ackMsg := &serverproto.SCActivitiesRewardAck{
		Error:      int32(serverproto.ErrorCode_ERROR_OK),
		ActivityId: activityId,
	}
	rewardDay := 0
	for idx := 1; idx <= int(maxDiffDay); idx++ {
		if activityData.RewardState&(1<<uint32(idx)) > 0 {
			rewardDay++
			continue
		}
		activityData.RewardState |= 1 << uint32(idx)
		rewardDay++

		switch idx {
		case 1:
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, model.ConvertAct100Recharge.Day1Reward...)
		case 2:
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, model.ConvertAct100Recharge.Day2Reward...)
		case 3:
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, model.ConvertAct100Recharge.Day3Reward...)
		}
	}

	//奖励领取完毕，活动消失(首充和百元奖励都领取完毕)
	this.checkFirstChargeAnd100RechargeEnd(rewardDay, activityData)

	if len(ackMsg.RewardItemList) > 0 {
		this.addChangeActivity(activityId, 0)

		//通知数据变更
		ntfMsg := &serverproto.SCActivitiesChangeNtf{
			CurDayEndTime: this.curDayEndTime,
		}
		ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
		this.role.ReplayGate(ntfMsg, true)

		var addItemList = map[int32]int32{}
		for idx := 0; idx < len(ackMsg.RewardItemList); idx++ {
			item := ackMsg.RewardItemList[idx]
			addItemList[item.Key] += item.Value
		}
		this.role.AddItemList(addItemList, AddFrom_Activities, true)
		this.role.ReplayGate(ackMsg, true)

		this.SetDirty(true)
		return serverproto.ErrorCode_ERROR_OK
	}
	return serverproto.ErrorCode_ERROR_ACTIVITIES_REWARD_NOT
}

func (this *RoleActivity) checkFirstChargeAnd100RechargeEnd(reward100Count int, reward100Data *serverproto.ActivitiesDetailData) {
	firstRewardCount := 0
	for idx := 1; idx <= 3; idx++ {
		if this.firstChargeRewardStat&(1<<uint32(idx)) > 0 {
			firstRewardCount++
			continue
		}
	}

	bNotify := false
	if reward100Data == nil {
		reward100Count = 0
		for _, val := range this.activityDataList {
			if val.ActivitiesType == int32(serverproto.EActivityType_EActivityType_100Recharge) {
				for idx := 1; idx <= 3; idx++ {
					if val.RewardState&(1<<uint32(idx)) > 0 {
						reward100Count++
						continue
					}
				}

				bNotify = true
				reward100Data = val
				break
			}
		}
	}

	//奖励领取完毕，活动消失(首充和百元奖励都领取完毕)
	if firstRewardCount == reward100Count && firstRewardCount == 3 {
		this.SetDirty(true)
		if reward100Data != nil {
			reward100Data.EndTime = util.GetTimeMilliseconds()

			this.addChangeActivity(reward100Data.ActivitiesId, 0)
		}

		if bNotify {
			//通知数据变更
			ntfMsg := &serverproto.SCActivitiesChangeNtf{
				CurDayEndTime: this.curDayEndTime,
			}
			ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, reward100Data)
			this.role.ReplayGate(ntfMsg, true)
		}
	}
}

func (this *RoleActivity) activitiesRewardDailyCumRecharge(activityId int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	if this.role.GetDayRecharge() <= 0 {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_REWARD_NOT
	}
	day := activityData.CurDay
	cfgData := model.GetActTiredRechargeDb(activityData.RewardState+1, day)
	if cfgData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_REWARD_NOT
	}
	if this.role.GetDayRecharge() < float32(cfgData.Amount) {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_REWARD_NOT
	}

	activityData.RewardState++
	this.addChangeActivity(activityId, 0)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
	this.role.ReplayGate(ntfMsg, true)
	//ack奖励处理
	ackMsg := &serverproto.SCActivitiesRewardAck{
		Error:      int32(serverproto.ErrorCode_ERROR_OK),
		ActivityId: activityId,
		//RewardItemList: model.ConvertActTiredRecharge[cfgData.Id],
	}
	var addItemList = map[int32]int32{}
	for idx := 0; idx < len(cfgData.Rewards); idx++ {
		item := cfgData.Rewards[idx]
		if !CheckHDItemAdd(item.Key, this.role) {
			continue
		}
		addItemList[item.Key] += item.Value
		ackMsg.RewardItemList = append(ackMsg.RewardItemList, item)
	}
	this.role.AddItemList(addItemList, AddFrom_Activities, true)
	this.role.ReplayGate(ackMsg, true)

	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK
}

// exchangeNum 兑换次数
func (this *RoleActivity) activitiesRewardCollection(activityId, rewardIdx int32, msg *serverproto.SSActivitiesCollectionServerDataAck, exchangeNum int32) serverproto.ErrorCode {
	if exchangeNum <= 0 {
		exchangeNum = 1
	}
	cfgData, ok := model.ConvertActCollection[rewardIdx]
	if !ok || cfgData.ActivitiesId != activityId {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	var collectData *serverproto.ActivitiesCollectionData = nil
	activityData := this.getActivityData(activityId)
	if activityData != nil {
		for idx := 0; idx < len(activityData.CollectionList); idx++ {
			if activityData.CollectionList[idx].Id == cfgData.Id {
				collectData = activityData.CollectionList[idx]
				break
			}
		}
		if collectData != nil {
			if collectData.RewardNum >= cfgData.RewardNum || collectData.RewardNum+exchangeNum > cfgData.RewardNum {
				return serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_NUM_LIMIT
			}
		}

		if !this.collectionRewardCheck(cfgData, uint64(exchangeNum)) {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_REWARD_NOT
		}

		//获取全局数据
		if msg == nil && cfgData.ServerRewardNum > 0 {
			ssMsg := &serverproto.SSActivitiesCollectionServerDataReq{
				ActivityId:     activityId,
				RewardIdx:      cfgData.Id,
				ServerLimitNum: cfgData.ServerRewardNum,
			}
			this.role.SendRank(ssMsg)
			return serverproto.ErrorCode_ERROR_OK
		}

		var delItemList = map[int32]int32{}
		for k, v := range cfgData.ExchangeConditionList {
			delItemList[k] += v * exchangeNum
		}
		this.role.DelItemList(delItemList, AddItemST{AddFrom: AddFrom_Activities})

		if collectData == nil {
			collectData = &serverproto.ActivitiesCollectionData{
				Id:        cfgData.Id,
				RewardNum: exchangeNum,
			}
			activityData.CollectionList = append(activityData.CollectionList, collectData)
		} else {
			collectData.RewardNum += exchangeNum
		}

		//ack奖励处理
		ackMsg := &serverproto.SCActivitiesRewardAck{
			Error:      int32(serverproto.ErrorCode_ERROR_OK),
			ActivityId: activityId,
		}
		var addItemList = map[int32]int32{}
		for idx := 0; idx < len(cfgData.RewardList); idx++ {
			item := cfgData.RewardList[idx]
			addItemList[item.Key] += item.Value * exchangeNum
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{
				Key:   item.Key,
				Value: item.Value * exchangeNum,
			})
		}
		this.addChangeActivity(activityId, 0)
		this.role.AddItemList(addItemList, AddFrom_Activities, true)
		this.SetDirty(true)

		//通知数据变更
		ntfMsg := &serverproto.SCActivitiesChangeNtf{
			CurDayEndTime: this.curDayEndTime,
		}
		ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
		this.role.ReplayGate(ntfMsg, true)
		this.role.ReplayGate(ackMsg, true)

		//通知服务器清空全局数据(之前是全局的后面改成非全局的)
		if cfgData.ServerRewardNum == 0 {
			ssMsg := &serverproto.SSActivitiesCollectionServerDataReq{
				ActivityId: activityId,
				RewardIdx:  cfgData.Id,
			}
			this.role.SendRank(ssMsg)
		}

		//通知全服玩家
		if cfgData.ServerRewardNum > 0 {
			this.role.AddSystemMessage(SystemmessageType_ActCollection,
				AddSystemMsg{ParamId: activityId, ParamCount: rewardIdx})

			if len(msg.DataList) > 0 {
				ssNtfMsg := &serverproto.SSActivitiesCollectionServerDataNtf{
					ActivityId:   activityId,
					RewardIdx:    rewardIdx,
					ServerCurNum: msg.DataList[0].Value,
				}
				this.role.SendSocial(ssNtfMsg)
			}
		}
	} else if msg != nil {
		var addItemList = map[int32]int32{}
		for idx := 0; idx < len(cfgData.RewardList); idx++ {
			item := cfgData.RewardList[idx]
			addItemList[item.Key] += item.Value
		}

		var delItemList = map[int32]int32{}
		for k, v := range cfgData.ExchangeConditionList {
			delItemList[k] += v * exchangeNum
		}
		this.role.DelItemList(delItemList, AddItemST{AddFrom: AddFrom_Activities})
		this.role.AddItemList(addItemList, AddFrom_Activities, true)

		//ack奖励处理
		ackMsg := &serverproto.SCActivitiesRewardAck{
			Error:          int32(serverproto.ErrorCode_ERROR_OK),
			ActivityId:     activityId,
			RewardItemList: cfgData.RewardList,
		}
		this.role.ReplayGate(ackMsg, true)
	}

	return serverproto.ErrorCode_ERROR_OK
}

// 集字奖励条件判断
func (this *RoleActivity) collectionRewardCheck(cfgData *model.ConvertActCollectionData, exchangeNum uint64) bool {
	for key, val := range cfgData.ExchangeConditionList {
		if key <= 0 || val <= 0 {
			continue
		}
		if this.role.GetResNum(key) < uint64(val)*exchangeNum {
			return false
		}
	}
	return true
}

// 全局数据奖励处理
func (this *RoleActivity) OnCollectionRewardByServer(msg *serverproto.SSActivitiesCollectionServerDataAck) {
	if msg.RewardIdx > 0 {
		cfgData, ok := model.ConvertActCollection[msg.RewardIdx]
		if !ok || cfgData.ActivitiesId != msg.ActivityId {
			ackMsg := &serverproto.SCActivitiesRewardAck{
				Error:      int32(serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_REWARD_NOT),
				ActivityId: msg.ActivityId,
			}
			this.role.ReplayGate(ackMsg, true)
			return
		}

		if len(msg.DataList) > 0 {
			if msg.DataList[0].Value > cfgData.ServerRewardNum {
				ackMsg := &serverproto.SCActivitiesRewardAck{
					Error:      int32(serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_NUM_LIMIT),
					ActivityId: msg.ActivityId,
				}
				this.role.ReplayGate(ackMsg, true)
				return
			}
		} else {
			ackMsg := &serverproto.SCActivitiesRewardAck{
				Error:      msg.Error,
				ActivityId: msg.ActivityId,
			}
			this.role.ReplayGate(ackMsg, true)
			return
		}

		//活动过期也需要获取奖励
		this.activitiesRewardCollection(msg.ActivityId, msg.RewardIdx, msg, 1)
	} else {
		ackMsg := &serverproto.SCActivitiesCollectionServerDataAck{
			Error:      msg.Error,
			ActivityId: msg.ActivityId,
			DataList:   msg.DataList,
		}
		this.role.ReplayGate(ackMsg, true)
	}
}

// 获取超值礼包商品信息
func (this *RoleActivity) PayInfoGetDiscount(payRewardInfo *serverproto.PayOrderSaveInfo) bool {
	if len(this.superUnlockChargeList) <= 0 {
		return false
	}
	nowTime := util.GetTimeMilliseconds()
	bChange := false
	for idx := 0; idx < len(this.superUnlockChargeList); {
		unlockData := this.superUnlockChargeList[idx]
		if unlockData.EndTime <= nowTime {
			this.superUnlockChargeList = append(this.superUnlockChargeList[:idx], this.superUnlockChargeList[idx+1:]...)
			bChange = true
			continue
		}

		if unlockData.ActivitiesId == payRewardInfo.GoodsId {
			cfgData, ok := model.ConvertActDiscountsRecharge[unlockData.ActivitiesId]
			if !ok {
				break
			}

			payRewardInfo.Count = 1
			payRewardInfo.GoodsId = unlockData.ActivitiesId
			payRewardInfo.Amount = cfgData.Amount
			payRewardInfo.GoodsName = cfgData.Name
			payRewardInfo.RewardList = cfgData.RewardList
			break
		}
		idx++
	}

	if bChange {
		this.SetDirty(true)
		ntfMsg := &serverproto.SCActivitiesDiscountsNtf{
			DiscountDataList: this.superUnlockChargeList,
		}
		this.role.ReplayGate(ntfMsg, true)
	}

	if payRewardInfo.Count > 0 {
		return true
	}
	return false
}

func (this *RoleActivity) OnPayInfoGetDiscount(payRewardInfo *serverproto.PayOrderSaveInfo) {
	bFind := false
	for idx := 0; idx < len(this.superUnlockChargeList); idx++ {
		if this.superUnlockChargeList[idx].ActivitiesId == payRewardInfo.GoodsId {
			this.superUnlockChargeList = append(this.superUnlockChargeList[:idx], this.superUnlockChargeList[idx+1:]...)
			bFind = true
			break
		}
	}

	if bFind {
		this.SetDirty(true)

		ntfMsg := &serverproto.SCActivitiesDiscountsNtf{
			DiscountDataList: this.superUnlockChargeList,
		}
		this.role.ReplayGate(ntfMsg, true)
	}
}

func (this *RoleActivity) refreshDiscountData(nowTime uint64) bool {
	bChange := false
	for idx := 0; idx < len(this.superUnlockChargeList); {
		unlockData := this.superUnlockChargeList[idx]
		if unlockData.EndTime <= nowTime {
			this.superUnlockChargeList = append(this.superUnlockChargeList[:idx], this.superUnlockChargeList[idx+1:]...)
			this.SetDirty(true)
			bChange = true
			continue
		}
		idx++
	}

	return bChange
}

func (this *RoleActivity) OnRewardByServer(msg *serverproto.SSActivitiesCollectionServerDataAck) {
	activityType := this.GetActivityType(msg.ActivityId)
	if activityType == int32(serverproto.EActivityType_EActivityType_Pet_Exchange) {
		this.OnExchangeRewardByServer(msg)
	} else {
		this.OnCollectionRewardByServer(msg)
	}
}

func (this *RoleActivity) GetActivityType(activityId int32) int32 {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return 0
	}
	return activityData.ActivitiesType
}

// 兑换奖励
func (this *RoleActivity) OnExchangeRewardByServer(msg *serverproto.SSActivitiesCollectionServerDataAck) {
	if msg.RewardIdx > 0 {
		cfgData, ok := model.ConvertExchange[msg.RewardIdx]
		if !ok || cfgData.ActivitiesId != msg.ActivityId {
			ackMsg := &serverproto.SCActivitiesExchangeAck{
				Error:      int32(serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_REWARD_NOT),
				ActivityId: msg.ActivityId,
				RewardIdx:  msg.RewardIdx,
			}
			this.role.ReplayGate(ackMsg, true)
			return
		}

		if len(msg.DataList) > 0 {
			if msg.DataList[0].Value > cfgData.ServerRewardNum {
				ackMsg := &serverproto.SCActivitiesExchangeAck{
					Error:      int32(serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_NUM_LIMIT),
					ActivityId: msg.ActivityId,
					RewardIdx:  msg.RewardIdx,
				}
				this.role.ReplayGate(ackMsg, true)
				//全服兑换次数用尽
				util.ErrorF("uid=%v check exchange failed, server num run out petId:=%v", this.role.GetUUid(), msg.DataList[0].Value, cfgData.ServerRewardNum)
				return
			}
		} else {
			ackMsg := &serverproto.SCActivitiesExchangeAck{
				Error:      msg.Error,
				ActivityId: msg.ActivityId,
				RewardIdx:  msg.RewardIdx,
			}
			this.role.ReplayGate(ackMsg, true)
			return
		}

		util.InfoF("uid=%v exchange pet begin", this.role.GetUUid())
		//活动过期也需要获取奖励
		ret := this.ActivitiesExchange(nil, msg)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCActivitiesExchangeAck{
				ActivityId: msg.ActivityId,
				RewardIdx:  msg.RewardIdx,
				Error:      int32(ret),
			}
			this.role.ReplayGate(ackMsg, true)
		}
	} else {
		ackMsg := &serverproto.SCActivitiesCollectionServerDataAck{
			Error:      msg.Error,
			ActivityId: msg.ActivityId,
			DataList:   msg.DataList,
		}
		this.role.ReplayGate(ackMsg, true)
	}
}

func (this *RoleActivity) CheckPetCondition(condType int32, condition *model.ExchangePetCondition, petList *serverproto.ExchangeInfo, delPetData []*serverproto.KeyValueType) serverproto.ErrorCode {
	if petList == nil || condition == nil || len(petList.CostItem) <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	for _, data := range petList.CostItem {
		petData := this.role.GetRolePet().getPet(uint32(data.Key))
		if petData == nil {
			util.ErrorF("uid=%v check exchange failed, pet not found petId:=%v", this.role.GetUUid(), data.Key)
			return serverproto.ErrorCode_ERROR_FAIL
		}
		petCfg, ok := serverproto.PetCfgLoader[petData.ConfigId]
		if !ok {
			util.ErrorF("uid=%v check exchange failed, pet config not found petId:=%v, configId;=%v", this.role.GetUUid(), data.Key, petData.ConfigId)
			return serverproto.ErrorCode_ERROR_FAIL
		}

		totalSkillLevel := int32(0)
		//宠物品质
		if condType == model.Exchange_Type_Common {
			if petCfg.Quality != condition.Id {
				util.ErrorF("uid=%v check exchange quality failed petId:=%v, configId;=%v", this.role.GetUUid(), data.Key, petData.ConfigId)
				return serverproto.ErrorCode_ERROR_FAIL
			}
		} else if condType == model.Exchange_Type_Special {
			if petCfg.Id != condition.Id {
				util.ErrorF("uid=%v check exchange config_id failed petId:=%v, configId;=%v", this.role.GetUUid(), data.Key, petData.ConfigId)
				return serverproto.ErrorCode_ERROR_FAIL
			}
		}

		//宠物等级不满足
		if petData.Level < condition.Level {
			util.ErrorF("uid=%v check exchange level failed petId:=%v, configId;=%v leve:%v needlevel:=%V", this.role.GetUUid(), data.Key, petData.ConfigId, petData.Level, condition.Level)
			return serverproto.ErrorCode_ERROR_FAIL
		}
		for _, skill := range petData.SkillList {
			totalSkillLevel += skill.Level
		}
		if totalSkillLevel < condition.SkillLevel {
			util.ErrorF("uid=%v check exchange skillLevel failed petId:=%v, configId;=%v leve:%v needlevel:=%V", this.role.GetUUid(), data.Key, petData.ConfigId, totalSkillLevel, condition.SkillLevel)
			return serverproto.ErrorCode_ERROR_FAIL
		}

		delPetData = append(delPetData, &serverproto.KeyValueType{
			Key:   data.Key,
			Value: petData.ConfigId,
		})
	}

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) petExchangeCheck(usePetList []*serverproto.ExchangeInfo, cfgData *model.ConvertExchangeData) serverproto.ErrorCode {
	if usePetList == nil || cfgData == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	delPetData := []*serverproto.KeyValueType{}
	//遍历每个条件，
	for _, condition := range cfgData.ConditionPet {
		bRet := serverproto.ErrorCode_ERROR_FAIL
		for _, data := range usePetList {
			if condition.ConditionId == data.ConditionId {
				if condition.CondType == model.Exchange_Type_Special {
					bRet = this.CheckPetCondition(model.Exchange_Type_Special, condition, data, delPetData)
				} else if condition.CondType == model.Exchange_Type_Common {
					bRet = this.CheckPetCondition(model.Exchange_Type_Common, condition, data, delPetData)
				}
				break
			}
		}
		if bRet != serverproto.ErrorCode_ERROR_OK {
			return bRet
		}
	}
	//检查是否有重复的宠物
	petList := make(map[uint32]int32)
	for _, pet := range usePetList {
		for _, data := range pet.CostItem {
			//如果发现一个PET用了两次，说明调用了外挂了
			count := petList[uint32(data.Key)]
			if count >= 2 {
				return serverproto.ErrorCode_ERROR_FAIL
			}
			petList[uint32(data.Key)] += 1
		}
	}

	util.InfoF("uid=%v check pet condition ok petListInfo = %v", this.role.GetUUid(), delPetData)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) CheckCardCondition(condType int32, condition *model.ExchangeCardCondition, petList *serverproto.ExchangeInfo) serverproto.ErrorCode {
	if petList == nil || condition == nil || len(petList.CostItem) <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	totalCardNum := int32(0)
	for _, data := range petList.CostItem {
		if condType == model.Exchange_Type_Common {
			cardCfg, ok := serverproto.CardCfgLoader[data.Key]
			if !ok {
				return serverproto.ErrorCode_ERROR_FAIL
			}
			if cardCfg.CardType != condition.ItemQuality { //卡片品质对比
				util.ErrorF("uid=%v check exchange quality failed petId:=%v, configId;=%v", this.role.GetUUid(), data.Key, cardCfg.CardId)
				return serverproto.ErrorCode_ERROR_FAIL
			}
			/*
				if cardCfg.CardLevel != condition.ItemLevel { //卡片品质对比
					util.ErrorF("uid=%v check exchange quality failed petId:=%v, configId;=%v", this.role.GetUUid(), data.Key, cardCfg.CardId)
					return serverproto.ErrorCode_ERROR_FAIL
				}
			*/
			//选择库校验
			if len(condition.Scope) <= 0 {
				return serverproto.ErrorCode_ERROR_FAIL
			}
			_, ok2 := condition.Scope[data.Key]
			if !ok2 {
				return serverproto.ErrorCode_ERROR_FAIL
			}
			cardNum := this.role.GetRoleCard().GetCardNum(data.Key)
			if cardNum < data.Value {
				return serverproto.ErrorCode_ERROR_FAIL
			}
			totalCardNum += data.Value

		} else if condType == model.Exchange_Type_Special { //special的道具单独判定数量够不够。
			if condition.ItemType == int32(serverproto.ResType_Res_Card) {
				cardCfg, ok := serverproto.CardCfgLoader[data.Key]
				if !ok {
					return serverproto.ErrorCode_ERROR_FAIL
				}
				if cardCfg.CardId != condition.ItemId { //卡片ID对比
					util.ErrorF("uid=%v check exchange config_id failed petId:=%v, configId;=%v", this.role.GetUUid(), data.Key, cardCfg.CardId)
					return serverproto.ErrorCode_ERROR_FAIL
				}
				cardNum := this.role.GetRoleCard().GetCardNum(data.Key)
				if cardNum < data.Value || cardNum < condition.ItemCount {
					return serverproto.ErrorCode_ERROR_FAIL
				}
			} else if condition.ItemType == int32(serverproto.ResType_Res_Item) || condition.ItemType == int32(serverproto.ResType_Res_Gift) {
				resNum := this.role.GetResNum(condition.ItemId)
				if resNum < uint64(condition.ItemCount) || resNum < uint64(data.Value) {
					util.ErrorF("uid=%v check exchange config_id failed petId:=%v, configId;=%v", this.role.GetUUid(), data.Key, condition.ItemId)
					return serverproto.ErrorCode_ERROR_FAIL
				}
			}
		}
	}
	//common目前只支持卡片。
	if condType == model.Exchange_Type_Common && totalCardNum < condition.ItemCount {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) OtherExchangeCheck(useItemList []*serverproto.ExchangeInfo, cfgData *model.ConvertExchangeData) serverproto.ErrorCode {
	if useItemList == nil || cfgData == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	//	delPetData := []*serverproto.KeyValueType{}
	//遍历每个条件，
	for _, condition := range cfgData.ConditionCard {
		bRet := serverproto.ErrorCode_ERROR_FAIL
		for _, data := range useItemList {
			if condition.ConditionId == data.ConditionId {
				if condition.CondType == model.Exchange_Type_Special || condition.CondType == model.Exchange_Type_Common {
					bRet = this.CheckCardCondition(condition.CondType, condition, data)
				}
				break
			}
		}
		if bRet != serverproto.ErrorCode_ERROR_OK {
			return bRet
		}
	}
	util.InfoF("uid=%v check pet condition ok petListInfo", this.role.GetUUid())
	return serverproto.ErrorCode_ERROR_OK
}

// 扣除宠物兑换道具
func (this *RoleActivity) DelPetExchangeItem(useItemList []*serverproto.ExchangeInfo) serverproto.ErrorCode {
	if len(useItemList) <= 0 {
		util.ErrorF("uid=%v del pet error useItemList is nil:", this.role.GetUUid())
		return serverproto.ErrorCode_ERROR_FAIL
	}
	//删除消耗的宠物
	var delPetList []uint32
	for _, condition := range useItemList {
		for _, data := range condition.CostItem {
			costPet := this.role.GetRolePet().getPet(uint32(data.Key))
			//上阵宠物和契约宠物无法作为兑换材料
			if costPet == nil || costPet.HeroId > 0 || costPet.QiyueHeroId > 0 {
				util.ErrorF("uid=%v del pet error costPet:%v :", this.role.GetUUid(), costPet)
				return serverproto.ErrorCode_ERROR_FAIL
			}
			delPetList = append(delPetList, uint32(data.Key))
			this.role.GetRolePet().dbChangePetList.Add(uint32(data.Key))
		}
	}

	this.role.GetRolePet().delPetList(delPetList)
	this.role.GetRolePet().petChangeNtf(nil, delPetList, nil, true)
	//删除宠物后查看援助是否有变化
	for _, petId := range delPetList {
		if this.role.GetRolePet().isInAssist(petId, true) {
			this.role.GetRolePet().saveAssist()
		}
	}
	this.role.GetRolePet().SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK
}

// 扣除卡片兑换道具
func (this *RoleActivity) DelCardExchangeItem(useItemList []*serverproto.ExchangeInfo) serverproto.ErrorCode {
	if len(useItemList) <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	//删除消耗的道具
	costItemList := map[int32]int32{}
	for _, condition := range useItemList {
		for _, data := range condition.CostItem {
			itemCfg, ok := serverproto.ItemCfgLoader[data.Key]
			if !ok {
				continue
			}
			if itemCfg.ResType == 9 {
				this.role.GetRoleCard().ReduceCard(data.Key, data.Value, true)
			} else {
				costItemList[data.Key] += data.Value
			}
		}
	}
	if len(costItemList) > 0 {
		this.role.DelItemList(costItemList, AddItemST{AddFrom: AddFrom_Activities})
	}

	this.role.GetRolePet().SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) ActivitiesExchange(reqMsg *serverproto.CSActivitiesExchangeReq, msg *serverproto.SSActivitiesCollectionServerDataAck) serverproto.ErrorCode {
	if reqMsg == nil && msg == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	rewardIdx := int32(0)
	activityId := int32(0)
	var useItemList []*serverproto.ExchangeInfo
	if reqMsg != nil {
		rewardIdx = reqMsg.RewardIdx
		activityId = reqMsg.ActivityId
		useItemList = reqMsg.Data
	} else {
		rewardIdx = msg.RewardIdx
		activityId = msg.ActivityId
		useItemList = msg.PetData
	}

	cfgData, ok := model.ConvertExchange[rewardIdx]
	if !ok || cfgData.ActivitiesId != activityId {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	if cfgData.ActivitiesType == model.Exchange_Activity_Type_Pet && len(cfgData.ConditionPet) <= 0 ||
		cfgData.ActivitiesType == model.Exchange_Activity_Type_Card && len(cfgData.ConditionCard) <= 0 {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	var exchangeData *serverproto.ExchangeData = nil
	activityData := this.getActivityData(activityId)
	if activityData != nil {
		for idx := 0; idx < len(activityData.ExchangeList); idx++ {
			if activityData.ExchangeList[idx].Id == cfgData.Id {
				exchangeData = activityData.ExchangeList[idx]
				break
			}
		}
		if exchangeData != nil && exchangeData.ExchangeNum >= cfgData.RewardNum {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_NUM_LIMIT
		}

		//校验发过来的ID是否有重复//数量是否够//有重复说明有问题
		bRet := serverproto.ErrorCode_ERROR_FAIL
		if cfgData.ActivitiesType == model.Exchange_Activity_Type_Pet {
			bRet = this.petExchangeCheck(useItemList, cfgData)
		} else if cfgData.ActivitiesType == model.Exchange_Activity_Type_Card {
			bRet = this.OtherExchangeCheck(useItemList, cfgData)
		}
		if bRet != serverproto.ErrorCode_ERROR_OK {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_EXCHANGE_REWARD_NOT
		}

		//获取全局数据if msg == nil && cfgData.ServerRewardNum > 0 {
		if msg == nil && cfgData.ServerRewardNum > 0 {
			ssMsg := &serverproto.SSActivitiesCollectionServerDataReq{
				ActivityId:     activityId,
				RewardIdx:      cfgData.Id,
				ServerLimitNum: cfgData.ServerRewardNum,
				PetData:        useItemList,
			}
			this.role.SendRank(ssMsg)
			return serverproto.ErrorCode_ERROR_OK
		}

		//删除消耗的物品
		bRet = serverproto.ErrorCode_ERROR_FAIL
		if cfgData.ActivitiesType == model.Exchange_Activity_Type_Pet {
			bRet = this.DelPetExchangeItem(useItemList)
		} else if cfgData.ActivitiesType == model.Exchange_Activity_Type_Card {
			bRet = this.DelCardExchangeItem(useItemList)
		}
		if bRet != serverproto.ErrorCode_ERROR_OK {
			return bRet
		}

		//ack奖励处理
		ackMsg := &serverproto.SCActivitiesExchangeAck{
			Error:      int32(serverproto.ErrorCode_ERROR_OK),
			ActivityId: activityId,
			RewardIdx:  rewardIdx,
		}
		//兑换计数
		if exchangeData == nil {
			exchangeData = &serverproto.ExchangeData{
				Id:          cfgData.Id,
				ExchangeNum: 1,
			}
			activityData.ExchangeList = append(activityData.ExchangeList, exchangeData)
		} else {
			exchangeData.ExchangeNum += 1
		}
		ackMsg.ExchangeTime = exchangeData.ExchangeNum

		//奖励宠物
		var addItemList = map[int32]int32{}
		for _, reward := range cfgData.Reward {
			addItemList[reward.Key] += reward.Value
		}
		this.role.AddItemList(addItemList, AddFrom_Activities, true)
		this.addChangeActivity(activityId, 0)
		this.SetDirty(true)

		//通知数据变更
		ntfMsg := &serverproto.SCActivitiesChangeNtf{
			CurDayEndTime: this.curDayEndTime,
		}
		ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
		this.role.ReplayGate(ntfMsg, true)
		this.role.ReplayGate(ackMsg, true)

		//通知服务器清空全局数据(之前是全局的后面改成非全局的)
		if cfgData.ServerRewardNum == 0 {
			ssMsg := &serverproto.SSActivitiesCollectionServerDataReq{
				ActivityId: activityId,
				RewardIdx:  cfgData.Id,
			}
			this.role.SendRank(ssMsg)
		}

		//通知全服玩家
		if msg != nil && cfgData.ServerRewardNum > 0 {
			if len(msg.DataList) > 0 {
				ssNtfMsg := &serverproto.SSActivitiesCollectionServerDataNtf{
					ActivityId:   activityId,
					RewardIdx:    rewardIdx,
					ServerCurNum: msg.DataList[0].Value,
				}
				this.role.SendSocial(ssNtfMsg)
			}
		}

		if cfgData.BroadCast == 1 {
			this.role.AddSystemMessage(SystemmessageType_PetExchange,
				AddSystemMsg{ParamId: activityId, ParamCount: rewardIdx})
		}

		util.InfoF("uid=%v operator exchange pet success", this.role.GetUUid())
	} else if msg != nil { //活动数据找不到的情况下，有可能已经结束了，还在兑换的流程继续走下去。
		//删除道具单独封装
		//删除消耗的物品
		bRet := serverproto.ErrorCode_ERROR_FAIL
		if cfgData.ActivitiesType == model.Exchange_Activity_Type_Pet {
			bRet = this.DelPetExchangeItem(msg.PetData)
		} else if cfgData.ActivitiesType == model.Exchange_Activity_Type_Card {
			bRet = this.DelCardExchangeItem(msg.PetData)
		}
		if bRet != serverproto.ErrorCode_ERROR_OK {
			return bRet
		}

		//奖励宠物
		var addItemList = map[int32]int32{}
		for _, reward := range cfgData.Reward {
			addItemList[reward.Key] += reward.Value
		}
		this.role.AddItemList(addItemList, AddFrom_Activities, true)

		//ack奖励处理
		ackMsg := &serverproto.SCActivitiesExchangeAck{
			Error:      int32(serverproto.ErrorCode_ERROR_OK),
			ActivityId: msg.ActivityId,
			RewardIdx:  msg.RewardIdx,
		}
		this.role.ReplayGate(ackMsg, true)
		this.role.GetRolePet().SetDirty(true)
		util.InfoF("uid=%v operator exchange pet success", this.role.GetUUid())
	}

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) activityWheelInit(activityData *serverproto.ActivitiesDetailData) {
	if activityData.WheelData == nil {
		activityData.WheelData = &serverproto.ActivityWheelData{}
	}
	if len(activityData.WheelData.WheelRewardItemList) <= 0 {
		convertWheelData, ok := model.ConvertActivityPrizeWheelData[activityData.ActivitiesId]
		if !ok {
			util.ErrorF("uid=%v activityWheelInit cfgData not exist activityId=%v", this.role.GetUUid(), activityData.ActivitiesId)
			return
		}

		templateIdx := convertWheelData.GenWheelReward(&activityData.WheelData.WheelRewardItemList)
		activityData.WheelData.TemplateIdx = templateIdx
		util.InfoF("uid=%v activityWheelInit templateIdx=%v rewardList=%v", templateIdx, activityData.WheelData.WheelRewardItemList)
	}
}

// 活动转盘
func (this *RoleActivity) ActivityWheelRefresh(activityId int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	//数据不合法再次初始化
	if activityData.WheelData == nil {
		this.activityWheelInit(activityData)
		this.addChangeActivity(activityId, 0)
		this.SetDirty(true)
	}
	if activityData.WheelData.WheelOpen {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_OPEN
	}

	convertWheelData, ok := model.ConvertActivityPrizeWheelData[activityId]
	if !ok {
		util.ErrorF("uid=%v ActivityWheelRefresh cfgData not exist activityId=%v", this.role.GetUUid(), activityId)
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	var refreshCostMoney int32 = 0
	refreshLen := len(convertWheelData.RefreshCostMoney)
	if refreshLen > 0 {
		if activityData.WheelData.WheelRefreshNum >= int32(refreshLen) {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_REFRESH_LIMIT
		} else {
			refreshCostMoney = convertWheelData.RefreshCostMoney[int(activityData.WheelData.WheelRefreshNum)]
		}
	}
	if refreshCostMoney > 0 {
		if !this.role.roleBag.CanDelItem(int32(serverproto.ResType_Res_ROCoin), refreshCostMoney) {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_MONEY_NOT
		}
		this.role.DelItem(int32(serverproto.ResType_Res_ROCoin), refreshCostMoney, AddItemST{
			AddFrom: AddFrom_Activities,
		})
	}
	activityData.WheelData.WheelRefreshNum++
	//重新刷新转盘奖励
	activityData.WheelData.WheelRewardItemList = activityData.WheelData.WheelRewardItemList[:0]
	templateIdx := convertWheelData.GenWheelReward(&activityData.WheelData.WheelRewardItemList)
	activityData.WheelData.TemplateIdx = templateIdx
	this.SetDirty(true)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
	this.role.ReplayGate(ntfMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) ActivityWheelOpen(activityId int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil || activityData.WheelData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	if activityData.WheelData.WheelOpen {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_OPEN
	}
	activityData.WheelData.WheelRefreshNum = 0 //刷新次数重置
	activityData.WheelData.WheelNum = 0
	activityData.WheelData.WheelOpen = true

	this.addChangeActivity(activityId, 0)
	this.SetDirty(true)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
	this.role.ReplayGate(ntfMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

// rewardAll false:转一次  true:获取所有奖励
func (this *RoleActivity) ActivityWheelReward(activityId int32, rewardAll bool) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil || activityData.WheelData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	wheelData := activityData.WheelData

	convertWheelData, ok := model.ConvertActivityPrizeWheelData[activityId]
	if !ok {
		util.ErrorF("uid=%v ActivityWheelRefresh cfgData not exist activityId=%v", this.role.GetUUid(), activityId)
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	var addLogList []*serverproto.WheelLogData
	if rewardAll {
		for idx := 0; idx < len(wheelData.WheelRewardItemList); idx++ {
			if wheelData.WheelRewardItemList[idx].HasReward {
				return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_REWARDALL_NOT
			}
		}

		//消耗是否足够(道具，金币)
		tmpCostItem := convertWheelData.WheelAllCostItem
		if this.role.roleBag.CanDelItem(tmpCostItem.Key, tmpCostItem.Val) {
			this.role.DelItem(tmpCostItem.Key, tmpCostItem.Val, AddItemST{
				AddFrom: AddFrom_Activities,
			})
		} else if this.role.roleBag.CanDelItem(int32(serverproto.ResType_Res_ROCoin), tmpCostItem.Money) {
			this.role.DelItem(int32(serverproto.ResType_Res_ROCoin), tmpCostItem.Money, AddItemST{
				AddFrom: AddFrom_Activities,
			})
		} else {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_MONEY_NOT
		}

		//添加积分
		this.role.GetRoleCompetition().CompetitionAddScoreDuoBao(tmpCostItem.Score)
		wheelData.WheelNum = int32(len(wheelData.WheelRewardItemList))
		this.SetDirty(true)

		//获取奖励
		ackMsg := &serverproto.SCActivityWheelRewardAck{
			Error:     int32(serverproto.ErrorCode_ERROR_OK),
			RewardAll: rewardAll,
		}
		var logData *serverproto.WheelLogData = nil
		rewardList := map[int32]int32{}
		for idx := 0; idx < len(wheelData.WheelRewardItemList); idx++ {
			wheelData.WheelRewardItemList[idx].HasReward = true
			rewardList[wheelData.WheelRewardItemList[idx].ItemId] += wheelData.WheelRewardItemList[idx].ItemNum
			ackMsg.RewardList = append(ackMsg.RewardList, wheelData.WheelRewardItemList[idx])

			//大奖日志
			if wheelData.WheelRewardItemList[idx].RewardType == model.WheelRewardType_MVp {
				if logData == nil {
					logData = &serverproto.WheelLogData{
						LogTime:  util.GetTimeMilliseconds(),
						NickName: this.role.GetNickName(),
						Uid:      this.role.GetUUid(),
					}
				}
				logData.ItemList = append(logData.ItemList, &serverproto.KeyValueType{
					Key:   wheelData.WheelRewardItemList[idx].ItemId,
					Value: wheelData.WheelRewardItemList[idx].ItemNum,
				})
			}
		}
		this.role.AddItemList(rewardList, AddFrom_Activities, true)

		//大奖日志
		if logData != nil {
			addLogList = append(addLogList, logData)
			wheelData.LogList = append(wheelData.LogList, logData)
		}

		//通知数据变更
		ntfMsg := &serverproto.SCActivitiesChangeNtf{
			CurDayEndTime: this.curDayEndTime,
		}
		ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
		this.role.ReplayGate(ntfMsg, true)
		this.role.ReplayGate(ackMsg, true)
	} else {
		if wheelData.WheelNum >= int32(len(wheelData.WheelRewardItemList)) ||
			len(wheelData.WheelRewardItemList) <= 0 {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		var costItemList = map[int32]int32{}
		costItem := convertWheelData.WheelCostItem[int(wheelData.WheelNum)]
		curBagCostItemNum := int32(this.role.GetItemNum(costItem.Key))
		if curBagCostItemNum < costItem.Val {
			deltaMoney := (costItem.Val - curBagCostItemNum) * convertWheelData.ItemToMoney
			if !this.role.roleBag.CanDelItem(int32(serverproto.ResType_Res_ROCoin), deltaMoney) {
				return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_MONEY_NOT
			}
			costItemList[int32(serverproto.ResType_Res_ROCoin)] += deltaMoney
			costItemList[costItem.Key] += curBagCostItemNum
		} else {
			costItemList[costItem.Key] += costItem.Val
		}

		retCode, retRewardItem := this.wheelItem(wheelData, convertWheelData)
		if retCode == serverproto.ErrorCode_ERROR_OK {
			wheelData.WheelNum++
			wheelData.WheelIdx = retRewardItem.ItemIdx
			this.SetDirty(true)
			//消耗道具
			this.role.DelItemList(costItemList, AddItemST{
				AddFrom: AddFrom_Activities,
			})
			//抽奖奖励
			this.role.roleBag.AddItem(retRewardItem.ItemId, retRewardItem.ItemNum, AddItemST{
				AddFrom: AddFrom_Activities,
				Notify:  true,
			})

			util.InfoF("uid=%v retRewardItem=%v", this.role.GetUUid(), retRewardItem)

			//大奖日志
			if retRewardItem.RewardType == model.WheelRewardType_MVp {
				logData := &serverproto.WheelLogData{
					LogTime:  util.GetTimeMilliseconds(),
					NickName: this.role.GetNickName(),
					Uid:      this.role.GetUUid(),
				}
				logData.ItemList = append(logData.ItemList, &serverproto.KeyValueType{
					Key:   retRewardItem.ItemId,
					Value: retRewardItem.ItemNum,
				})
				addLogList = append(addLogList, logData)
				wheelData.LogList = append(wheelData.LogList, logData)
			}

			//通知数据变更
			ntfMsg := &serverproto.SCActivitiesChangeNtf{
				CurDayEndTime: this.curDayEndTime,
			}
			ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
			this.role.ReplayGate(ntfMsg, true)
			ackMsg := &serverproto.SCActivityWheelRewardAck{
				RewardAll: rewardAll,
			}
			ackMsg.RewardList = append(ackMsg.RewardList, retRewardItem)
			this.role.ReplayGate(ackMsg, true)
		}
	}
	this.addChangeActivity(activityId, 0)

	if len(addLogList) > 0 {
		//系统消息
		ssMsgNtf := &serverproto.SSSystemMessageNtf{}
		for idx := 0; idx < len(addLogList); idx++ {
			sysMsgData := &serverproto.SystemMessage{
				Type:     int32(SystemmessageType_ActivityWheel),
				NickName: this.role.GetNickName(),
				SendTime: util.GetTimeMilliseconds(),
				ParamId:  []int32{activityId},
			}
			for k := 0; k < len(addLogList[idx].ItemList); k++ {
				sysMsgData.ParamId = append(sysMsgData.ParamId, addLogList[idx].ItemList[k].Key)
				sysMsgData.ParamId = append(sysMsgData.ParamId, addLogList[idx].ItemList[k].Value)
			}
			ssMsgNtf.SysMsg = append(ssMsgNtf.SysMsg, sysMsgData)
		}
		this.role.SendSocial(ssMsgNtf)
	}

	return serverproto.ErrorCode_ERROR_OK
}

// 抽取其中一个道具
func (this *RoleActivity) wheelItem(wheelData *serverproto.ActivityWheelData, convertData *model.ConvertPrizeWheelInfo) (serverproto.ErrorCode, *serverproto.WheelRewardItemInfo) {
	var randRewardList []serverproto.KeyValueType //[weight,rewardidx]
	var rewardTotalWeight int32 = 0
	templateData := convertData.GetTemplateData(wheelData.TemplateIdx)
	if templateData == nil {
		return serverproto.ErrorCode_ERROR_FAIL, nil
	}
	for idx := 0; idx < len(wheelData.WheelRewardItemList); idx++ {
		if wheelData.WheelRewardItemList[idx].HasReward {
			continue
		}

		if wheelData.WheelRewardItemList[idx].RewardType == model.WheelRewardType_MVp {
			if wheelData.WheelNum >= int32(len(templateData.MvpFactorList)) {
				continue
			}
			rewardTotalWeight += templateData.MvpFactorList[wheelData.WheelNum]
		} else {
			rewardType := wheelData.WheelRewardItemList[idx].RewardType
			rewardTotalWeight += templateData.RewardFactorList[int(rewardType)]
		}

		randRewardList = append(randRewardList, serverproto.KeyValueType{
			Key:   rewardTotalWeight,
			Value: int32(idx),
		})
	}

	if rewardTotalWeight <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL, nil
	}

	var retRewardIdx = 0
	rand.Seed(int64(util.GetTimeMilliseconds()))
	randWeight := rand.Int31n(rewardTotalWeight) + 1 //[1,rewardTotalWeight]
	for idx := 0; idx < len(randRewardList); idx++ {
		retRewardIdx = int(randRewardList[idx].Value)
		if randRewardList[idx].Key >= randWeight {
			break
		}
	}

	wheelData.WheelRewardItemList[retRewardIdx].HasReward = true
	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK, wheelData.WheelRewardItemList[retRewardIdx]
}

func (this *RoleActivity) ActivityWheelClose(activityId int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil || activityData.WheelData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	convertWheelData, ok := model.ConvertActivityPrizeWheelData[activityId]
	if !ok {
		util.ErrorF("uid=%v ActivityWheelRefresh cfgData not exist activityId=%v", this.role.GetUUid(), activityId)
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	wheelData := activityData.WheelData

	if !wheelData.WheelOpen {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	if wheelData.WheelNum < convertWheelData.NoMVPRewardNum {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_WHEEL_CANNOT_CLOSE
	}

	wheelData.WheelOpen = false
	wheelData.WheelRefreshNum = 0
	wheelData.WheelNum = 0
	//重新刷新转盘奖励
	wheelData.WheelRewardItemList = wheelData.WheelRewardItemList[:0]
	templateIdx := convertWheelData.GenWheelReward(&wheelData.WheelRewardItemList)
	wheelData.TemplateIdx = templateIdx
	this.SetDirty(true)
	this.addChangeActivity(activityId, 0)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, activityData)
	this.role.ReplayGate(ntfMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) ActivitySummon(activityId, summonCount int32) serverproto.ErrorCode {
	retCode := serverproto.ErrorCode_ERROR_FAIL
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		retCode = serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
		return retCode
	}

	tmpAckMsg := &serverproto.SCDrawCardAck{}
	for key, data := range model.ConvertSummonList {
		if data.ActivitiesId == activityId {
			retCode = this.role.GetRoleDraw().DrawReq(key, summonCount, tmpAckMsg)
			break
		}
	}

	if retCode == serverproto.ErrorCode_ERROR_OK {
		ackMsg := &serverproto.SCActivitySummonAck{
			ActivityId: activityId,
			DrawCount:  tmpAckMsg.DrawCount,
			ItemList:   tmpAckMsg.ItemList,
			ExtraItem:  tmpAckMsg.ExtraItem,
			DrawTimes:  tmpAckMsg.DrawTimes,
			AddPoint:   tmpAckMsg.AddPoint,
		}
		this.role.ReplayGate(ackMsg, true)
	}

	return retCode
}

func (this *RoleActivity) ActivitySmashEggs(activityId, drawType, drawCount int32) (retCode serverproto.ErrorCode) {
	retCode = serverproto.ErrorCode_ERROR_FAIL
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		retCode = serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
		return
	}

	tmpAckMsg := &serverproto.SCDrawCardAck{}
	var cfgData *model.SummonCost = nil
	switch drawType {
	case DrawType_EggsGold: // 金蛋
		fallthrough
	case DrawType_EggsSpecial: // 彩蛋
		for key, data := range model.ConvertSummonList {
			if data.ActivitiesId == activityId && data.SummonType == drawType {
				cfgData = data
				retCode = this.role.GetRoleDraw().DrawReq(key, drawCount, tmpAckMsg)
				break
			}
		}
	default:
		return
	}

	if retCode == serverproto.ErrorCode_ERROR_OK {
		ackMsg := &serverproto.SCActivitySmashEggsAck{
			ActivityId: activityId,
			DrawCount:  tmpAckMsg.DrawCount,
			ItemList:   tmpAckMsg.ItemList,
			ExtraItem:  tmpAckMsg.ExtraItem,
			DrawTimes:  tmpAckMsg.DrawTimes,
			AddPoint:   tmpAckMsg.AddPoint,
			DrawType:   drawType,
		}

		// 砸蛋消息处理
		// 大奖处理 [activityId,AddFromType,itemId,itemNum,itemId,itemNum...]
		if cfgData != nil {
			bigRewardShow := map[int32]int{}
			for idx := 0; idx < len(cfgData.BigRewardShowList); idx++ {
				bigRewardShow[cfgData.BigRewardShowList[idx]] = 1
			}

			for idx := 0; idx < len(tmpAckMsg.ItemList); idx++ {
				tmpItem := tmpAckMsg.ItemList[idx]
				if findNum, ok := bigRewardShow[tmpItem.ItemId]; ok {
					if findNum > 1 {
						continue
					}
					bigRewardShow[tmpItem.ItemId]++

					sysParam := AddSystemMsg{
						ParamId:     activityId,
						AddFromType: drawType,
					}
					sysParam.ParamList = append(sysParam.ParamList, tmpAckMsg.ItemList[idx].ItemId, tmpAckMsg.ItemList[idx].ItemNum)
					addMsg := this.role.GenSystemMessage(SystemmessageType_SmashEggs, sysParam)
					this.activitySmashEggsAddSysMsg(activityData, drawType, addMsg)
					ackMsg.MsgList = append(ackMsg.MsgList, addMsg)
				}
			}
			for idx := 0; idx < len(tmpAckMsg.ExtraItem); idx++ {
				tmpItem := tmpAckMsg.ExtraItem[idx]
				findNum, ok := bigRewardShow[tmpItem.ItemId]
				if !ok || findNum > 1 { //未找到或者已经有提示
					continue
				}
				bigRewardShow[tmpItem.ItemId]++
				sysParam := AddSystemMsg{
					ParamId:     activityId,
					AddFromType: drawType,
				}
				sysParam.ParamList = append(sysParam.ParamList, tmpAckMsg.ExtraItem[idx].ItemId, tmpAckMsg.ExtraItem[idx].ItemNum)
				addMsg := this.role.GenSystemMessage(SystemmessageType_SmashEggs, sysParam)
				this.activitySmashEggsAddSysMsg(activityData, drawType, addMsg)
				ackMsg.MsgList = append(ackMsg.MsgList, addMsg)
			}
		}

		this.role.ReplayGate(ackMsg, true)
	}

	return
}
func (this *RoleActivity) activitySmashEggsAddSysMsg(activityData *serverproto.ActivitiesDetailData, drawType int32, addMsg *serverproto.SystemMessage) {
	firstIdx := -1
	findNum := 0
	for idx := 0; idx < len(ActivitiesMag.SmashEggsMsgList); idx++ {
		tmpMsg := ActivitiesMag.SmashEggsMsgList[idx]
		if len(tmpMsg.ParamId) >= 2 && tmpMsg.ParamId[1] == drawType {
			if firstIdx < 0 {
				firstIdx = idx
			}
			findNum++
		}
	}
	if findNum >= 10 {
		ActivitiesMag.SmashEggsMsgList = append(ActivitiesMag.SmashEggsMsgList[:firstIdx], ActivitiesMag.SmashEggsMsgList[firstIdx+1:]...)
	}
	ActivitiesMag.SmashEggsMsgList = append(ActivitiesMag.SmashEggsMsgList, addMsg)
	//this.SetDirty(true)
	//this.addChangeActivity(activityData.ActivitiesId, 0)
	saveMsgNtf := &serverproto.SSActivitySmashEggsMsgSaveNtf{
		ActMsgList: ActivitiesMag.SmashEggsMsgList,
	}
	this.role.SendDb(saveMsgNtf)
}

func (this *RoleActivity) ActivitySmashEggsMsg(activityId, drawType int32) {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return
	}

	ackMsg := &serverproto.SCActivitySmashEggsMsgAck{}
	switch drawType {
	case DrawType_EggsGold:
		fallthrough
	case DrawType_EggsSpecial:
		for idx := 0; idx < len(ActivitiesMag.SmashEggsMsgList); idx++ {
			tmpMsg := ActivitiesMag.SmashEggsMsgList[idx]
			if len(tmpMsg.ParamId) >= 2 {
				if tmpMsg.ParamId[1] == drawType {
					ackMsg.ActMsgList = append(ackMsg.ActMsgList, tmpMsg)
				}
			}
		}
	}

	this.role.ReplayGate(ackMsg, true)
}

func (this *RoleActivity) ActivitySignIn(activityId int32, ackMsg *serverproto.SCActivitySignInAck) serverproto.ErrorCode {
	if ackMsg == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	activityData := this.getActivityData(activityId)
	if activityData == nil || activityData.SignData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	/*
		if activityData.SignData == nil {
			activityData.SignData = &serverproto.ActivitySignIn{}
		}
	*/

	curTime := util.GetCurrentTime()
	if activityData.SignData.NextSignTime != 0 && curTime < activityData.SignData.NextSignTime {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//检查配置表
	signInInfo, ok := model.ConvertActivitySignIn[activityId]
	if !ok {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	signData, ok2 := signInInfo.SignData[activityData.SignData.SignDays+1]
	if !ok2 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	isDouble := false
	if signData.IsDouble == 1 {
		if signData.VipLevel <= this.role.GetRoleVipLevel() {
			isDouble = true
		}
	}
	//添加道具
	addItemList := map[int32]int32{}
	for key, value := range signData.RewardList {
		ackMsg.RewardList = append(ackMsg.RewardList, &serverproto.KeyValueType{
			Key:   key,
			Value: value,
		})
		addItemList[key] += value
		if isDouble == true {
			ackMsg.ExtRewardList = append(ackMsg.ExtRewardList, &serverproto.KeyValueType{
				Key:   key,
				Value: value,
			})
			addItemList[key] += value
		}
	}
	this.role.AddItemList(addItemList, AddFrom_ActivitySignIn, true)

	//设置最新的签到数据
	activityData.SignData.SignDays += 1
	ackMsg.SignDays = activityData.SignData.SignDays
	_, ok3 := signInInfo.SignData[activityData.SignData.SignDays+1]
	if !ok3 { //下一天的签到没有找到
		activityData.SignData.NextSignTime = 0
	} else {
		activityData.SignData.NextSignTime = util.GetLatest5Hour()
	}
	ackMsg.NextSignTime = activityData.SignData.NextSignTime
	this.SetDirty(true)
	this.addChangeActivity(activityId, 0)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) SetActivitySignDay(day, activityId int32) {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return
	}

	signInInfo, ok := model.ConvertActivitySignIn[activityId]
	if !ok {
		return
	}
	_, ok2 := signInInfo.SignData[day]
	if !ok2 {
		return
	}
	activityData.SignData.SignDays = day
	activityData.SignData.NextSignTime = util.GetLatest5Hour() - 24*3600*1000
	this.SetDirty(true)
	this.addChangeActivity(activityId, 0)
}

func (this *RoleActivity) SetCollectNotice(activityId, CollectId int32, notice bool) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	if activityData.ActivitiesType != int32(serverproto.EActivityType_EActivityType_ExChange) {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}

	bFind := false
	for _, data := range activityData.CollectionList {
		if data.Id != CollectId {
			continue
		}
		bFind = true
		data.NoNotice = notice
		this.SetDirty(true)
		this.addChangeActivity(activityId, 0)
		return serverproto.ErrorCode_ERROR_OK
	}

	if bFind == false {
		cfgData, ok := model.ConvertActCollection[CollectId]
		if !ok || cfgData.ActivitiesId != activityId {
			return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
		}

		collectData := &serverproto.ActivitiesCollectionData{
			Id:        cfgData.Id,
			RewardNum: 0,
			NoNotice:  notice,
		}
		activityData.CollectionList = append(activityData.CollectionList, collectData)
		this.SetDirty(true)
		this.addChangeActivity(activityId, 0)
		return serverproto.ErrorCode_ERROR_OK
	}

	return serverproto.ErrorCode_ERROR_FAIL
}

// bt RO币累计活动
func (this *RoleActivity) getAllActivityRewardBTRoCoinRecharge(activityData *serverproto.ActivitiesDetailData) {
	if activityData.BtRocoinData == nil {
		return
	}
	var addItemList = map[int32]int32{}
	// daily
	for idx := 0; idx < len(activityData.BtRocoinData.DailyTaskList); idx++ {
		taskInfo := activityData.BtRocoinData.DailyTaskList[idx]
		if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
			continue
		}
		convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
		if !ok {
			continue
		}
		for k, v := range convertData.RewardList {
			addItemList[k] += v
		}
		taskInfo.State = TASK_REWARD_STATE_REWARD
		this.addChangeActivity(activityData.ActivitiesId, taskInfo.TaskId)
		delete(this.activitiesTaskList[activityData.ActivitiesId], taskInfo.TaskId)
		this.delTaskType(activityData.ActivitiesId, convertData)
	}
	activityData.BtRocoinData.DailyTaskList = nil
	this.addChangeActivity(activityData.ActivitiesId, 0)
	this.SetDirty(true)

	// week
	nowTime := util.GetTimeMilliseconds()
	if nowTime >= activityData.BtRocoinData.WeekDayEndTime {
		for idx := 0; idx < len(activityData.BtRocoinData.WeekTaskList); idx++ {
			taskInfo := activityData.BtRocoinData.WeekTaskList[idx]
			if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
				continue
			}
			convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
			if !ok {
				continue
			}
			for k, v := range convertData.RewardList {
				addItemList[k] += v
			}

			taskInfo.State = TASK_REWARD_STATE_REWARD
			this.addChangeActivity(activityData.ActivitiesId, taskInfo.TaskId)
			delete(this.activitiesTaskList[activityData.ActivitiesId], taskInfo.TaskId)
			this.delTaskType(activityData.ActivitiesId, convertData)
		}
		activityData.BtRocoinData.WeekTaskList = nil
		this.addChangeActivity(activityData.ActivitiesId, 0)
		this.SetDirty(true)
	}
	if len(addItemList) > 0 {
		//发送邮件奖励
		this.role.AddMail(model.GlobalMailIdActivitiesCurRechargeReward, serverproto.MailType_MailType_Activities,
			addItemList, []int32{activityData.ActivitiesId}, "", "")
	}
}

func (this *RoleActivity) getAllActivityRewardBTZhenJiaRecharge(activityData *serverproto.ActivitiesDetailData) {
	if len(activityData.BtZhenjiaRechargeTaskList) <= 0 {
		return
	}
	var addItemList = map[int32]int32{}
	for idx := 0; idx < len(activityData.BtZhenjiaRechargeTaskList); idx++ {
		taskInfo := activityData.BtZhenjiaRechargeTaskList[idx]
		if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
			continue
		}
		convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
		if !ok {
			continue
		}
		for k, v := range convertData.RewardList {
			addItemList[k] += v
		}
		taskInfo.State = TASK_REWARD_STATE_REWARD
		this.addChangeActivity(activityData.ActivitiesId, taskInfo.TaskId)
		delete(this.activitiesTaskList[activityData.ActivitiesId], taskInfo.TaskId)
	}
	activityData.BtZhenjiaRechargeTaskList = nil
	this.SetDirty(true)

	if len(addItemList) > 0 {
		//发送邮件奖励
		this.role.AddMail(model.GlobalMailIdActivitiesCurRechargeReward, serverproto.MailType_MailType_Activities,
			addItemList, []int32{activityData.ActivitiesId}, "", "")
	}
}

// param=taskId
func (this *RoleActivity) activitiesRewardBTRoCoinRecharge(activityId int32, param int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	if param <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	taskInfo := this.getTaskData(activityId, uint32(param))
	if taskInfo == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	if taskInfo.State == TASK_REWARD_STATE_REWARD {
		return serverproto.ErrorCode_ERROR_TASK_REWARDED
	}
	//应对玩家任务条件调整
	if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
		if this.checkTaskInfo(taskInfo) {
			if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
				return serverproto.ErrorCode_ERROR_TASK_REWARDED
			}
		} else {
			return serverproto.ErrorCode_ERROR_TASK_REWARDED
		}
	}
	convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
	if !ok {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	ret := this.role.CanAddItemList(convertData.RewardList)
	if ret != serverproto.ErrorCode_ERROR_OK {
		return ret
	}
	this.role.AddItemList(convertData.RewardList, AddFrom_Activities, true)

	//任务状态修改
	taskInfo.State = TASK_REWARD_STATE_REWARD
	this.addChangeActivity(activityId, taskInfo.TaskId)
	this.addChangeActivity(activityId, 0)
	this.SetDirty(true)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	detailData := &serverproto.ActivitiesDetailData{
		ActivitiesId:   activityId,
		ActivitiesType: activityData.ActivitiesType,
		StartTime:      activityData.StartTime,
		EndTime:        activityData.EndTime,
		CurDay:         activityData.CurDay,
		BtRocoinData: &serverproto.ActivityBTROCoin{
			WeekDayEndTime: activityData.BtRocoinData.WeekDayEndTime,
		},
	}
	if taskInfo.TaskType == int32(model.BTTaskRefreshType_Day) {
		detailData.BtRocoinData.DailyTaskList = append(detailData.BtRocoinData.DailyTaskList, taskInfo)
	} else {
		detailData.BtRocoinData.WeekTaskList = append(detailData.BtRocoinData.WeekTaskList, taskInfo)
	}
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, detailData)
	this.role.ReplayGate(ntfMsg, true)

	//ack奖励处理
	ackMsg := &serverproto.SCActivitiesRewardAck{
		Error:      int32(serverproto.ErrorCode_ERROR_OK),
		ActivityId: activityId,
	}
	for key, val := range convertData.RewardList {
		ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: key, Value: val})
	}
	this.role.ReplayGate(ackMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

// param=taskId
func (this *RoleActivity) activitiesRewardBTZhenJiaRecharge(activityId int32, param int32) serverproto.ErrorCode {
	activityData := this.getActivityData(activityId)
	if activityData == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_NOT
	}
	if param <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	taskInfo := this.getTaskData(activityId, uint32(param))
	if taskInfo == nil {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	if taskInfo.State == TASK_REWARD_STATE_REWARD {
		return serverproto.ErrorCode_ERROR_TASK_REWARDED
	}
	//应对玩家任务条件调整
	if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
		if this.checkTaskInfo(taskInfo) {
			if taskInfo.State != TASK_REWARD_STATE_COMPLETED {
				return serverproto.ErrorCode_ERROR_TASK_REWARDED
			}
		} else {
			return serverproto.ErrorCode_ERROR_TASK_REWARDED
		}
	}
	convertData, ok := model.ConvertActivitiesTaskList[int32(taskInfo.TaskId)]
	if !ok {
		return serverproto.ErrorCode_ERROR_ACTIVITIES_TASK_NOT
	}
	ret := this.role.CanAddItemList(convertData.RewardList)
	if ret != serverproto.ErrorCode_ERROR_OK {
		return ret
	}
	this.role.AddItemList(convertData.RewardList, AddFrom_Activities, true)

	//任务状态修改
	taskInfo.State = TASK_REWARD_STATE_REWARD
	this.addChangeActivity(activityId, taskInfo.TaskId)
	this.addChangeActivity(activityId, 0)
	this.SetDirty(true)

	//通知数据变更
	ntfMsg := &serverproto.SCActivitiesChangeNtf{
		CurDayEndTime: this.curDayEndTime,
	}
	detailData := &serverproto.ActivitiesDetailData{
		ActivitiesId:   activityId,
		ActivitiesType: activityData.ActivitiesType,
		StartTime:      activityData.StartTime,
		EndTime:        activityData.EndTime,
		CurDay:         activityData.CurDay,
	}
	detailData.BtZhenjiaRechargeTaskList = append(detailData.BtZhenjiaRechargeTaskList, taskInfo)
	ntfMsg.ActivityDataList = append(ntfMsg.ActivityDataList, detailData)
	this.role.ReplayGate(ntfMsg, true)

	//ack奖励处理
	ackMsg := &serverproto.SCActivitiesRewardAck{
		Error:      int32(serverproto.ErrorCode_ERROR_OK),
		ActivityId: activityId,
	}
	for key, val := range convertData.RewardList {
		ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: key, Value: val})
	}
	this.role.ReplayGate(ackMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleActivity) resetBTTasks(detailData *serverproto.ActivitiesDetailData) {
	if detailData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_BT_ZhenJiaRecharge) {
		taskList := model.GetActBTRechargeDayDataList(detailData.ActivitiesId, detailData.CurDay)
		if len(taskList) <= 0 {
			return
		}
		var taskDataList []*serverproto.TaskData
		for idx := 0; idx < len(taskList); idx++ {
			taskData := this.addDayTask(detailData.ActivitiesId, uint32(taskList[idx]), 0, false, 0)
			if taskData != nil {
				taskData.TaskType = int32(model.BTTaskRefreshType_Day)
				taskDataList = append(taskDataList, taskData)
			}
		}
		if len(taskDataList) > 0 {
			detailData.BtZhenjiaRechargeTaskList = taskDataList
		}
		this.SetDirty(true)

	} else if detailData.ActivitiesType == int32(serverproto.EActivityType_EActivityType_BT_ROCoinRecharge) {
		// daily task
		dailyTaskList := model.GetActBTROCoinRechargeDayDataList(detailData.ActivitiesId, detailData.CurDay, model.BTTaskRefreshType_Day)
		if len(dailyTaskList) <= 0 {
			return
		}
		var taskDataList []*serverproto.TaskData
		for idx := 0; idx < len(dailyTaskList); idx++ {
			taskData := this.addDayTask(detailData.ActivitiesId, uint32(dailyTaskList[idx]), 0, false, 0)
			if taskData != nil {
				taskData.TaskType = int32(model.BTTaskRefreshType_Day)
				taskDataList = append(taskDataList, taskData)
			}
		}
		if len(taskDataList) > 0 {
			detailData.BtRocoinData.DailyTaskList = taskDataList
		}

		// week task
		if detailData.BtRocoinData != nil {
			nowTime := util.GetTimeMilliseconds()
			if nowTime >= detailData.BtRocoinData.WeekDayEndTime || len(detailData.BtRocoinData.WeekTaskList) <= 0 {
				weekTaskList := model.GetActBTROCoinRechargeDayDataList(detailData.ActivitiesId, detailData.CurDay, model.BTTaskRefreshType_Week)
				if len(weekTaskList) <= 0 {
					return
				}
				taskDataList = []*serverproto.TaskData{}
				for idx := 0; idx < len(weekTaskList); idx++ {
					taskData := this.addDayTask(detailData.ActivitiesId, uint32(weekTaskList[idx]), 0, false, 0)
					if taskData != nil {
						taskData.TaskType = int32(model.BTTaskRefreshType_Week)
						taskDataList = append(taskDataList, taskData)
					}
				}
				if len(taskDataList) > 0 {
					detailData.BtRocoinData.WeekTaskList = taskDataList
				}
				if len(detailData.BtRocoinData.WeekTaskList) > 0 {
					detailData.BtRocoinData.WeekDayEndTime = this.curDayEndTime + 6*DayMS
				}
			}
		}
		this.SetDirty(true)
	}
}