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

package model

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

func (this *Role) GetTaskReward(taskId uint32) {
	if this.roleTask != nil {
		ret := this.roleTask.GetTaskReward(taskId)
		if ret != serverproto.ErrorCode_ERROR_OK {
			this.ReplayGate(&serverproto.SCGetTaskRewardAck{Error: int32(ret)}, true)
		}
	}
}
func (this *Role) GetTaskScoreReward(rewardType, rewardIdx int32) {
	if this.roleTask != nil {
		ret := this.roleTask.GetTaskScoreReward(uint32(rewardType), uint32(rewardIdx))
		if ret != serverproto.ErrorCode_ERROR_OK {
			this.ReplayGate(&serverproto.SCGetTaskScoreRewardAck{Error: int32(ret)}, true)
		}
	}
}

const (
	TASK_REWARD_STATE_NONE      = 0 //未完成
	TASK_REWARD_STATE_COMPLETED = 1 //任务完成未领取奖励
	TASK_REWARD_STATE_REWARD    = 2 //已经领取奖励

	TASK_CONDITION_NONE   = 4
	TASK_CONDITION_CHANGE = 5
	TASK_CONDITION_OK     = 6
)

type ConditionInfo struct {
	HeroId   int32  //伙伴ID
	TaskId   uint32 //条件列表ID
	CondInfo *serverproto.TaskData
}

type RoleTask struct {
	SaveObject

	loadTaskData *serverproto.RoleTask
	jobCondition []*serverproto.ChangeJob //只针对主角//伙伴转职出案子再做
	roleHeadCond serverproto.RoleHeadCond

	taskTypeList  map[int32]set.Interface //根据枚举类型对任务做区分[serverproto.TaskType, taslidlist]
	dailyTaskList map[uint32]*serverproto.TaskData
	weekTaskList  map[uint32]*serverproto.TaskData
	mainTaskList  map[uint32]*serverproto.TaskData

	dailyTaskScore serverproto.KeyValueType //活跃度/活跃度对应的奖励，按位处理(完成任务累加的积分)
	weekTaskScore  serverproto.KeyValueType

	saveTaskDataList []*serverproto.TaskData

	recTypeCnt map[int32]*serverproto.KeyValueType

	//任务通用累计计数
	totalAddZeny uint64
}

func newRoleTask(r *Role) *RoleTask {
	roleTask := &RoleTask{
		SaveObject: SaveObject{
			role: r,
		},
		loadTaskData:  &serverproto.RoleTask{},
		dailyTaskList: map[uint32]*serverproto.TaskData{},
		weekTaskList:  map[uint32]*serverproto.TaskData{},
		mainTaskList:  map[uint32]*serverproto.TaskData{},

		taskTypeList: map[int32]set.Interface{},
		recTypeCnt:   map[int32]*serverproto.KeyValueType{},
		roleHeadCond: serverproto.RoleHeadCond{},
	}

	return roleTask
}

func (this *RoleTask) Load(msg interface{}) bool {
	dbRole := msg.(*serverproto.Role)
	if dbRole != nil && dbRole.RoleBase != nil {
		//daily/week/main task
		if dbRole.RoleTask != nil {
			this.loadTaskData = dbRole.RoleTask

			if dbRole.RoleTask.DailyTaskScore != nil {
				this.dailyTaskScore = *dbRole.RoleTask.DailyTaskScore
			}
			if dbRole.RoleTask.WeekTaskScore != nil {
				this.weekTaskScore = *dbRole.RoleTask.WeekTaskScore
			}
			for idx := range dbRole.RoleTask.TaskList {
				taskInfo := dbRole.RoleTask.TaskList[idx]
				_, ok := model.ConvertTaskList[taskInfo.TaskId]
				if !ok {
					continue
				}
				if taskInfo.TaskType == model.TASK_TYPE_DAILY {
					this.dailyTaskList[taskInfo.TaskId] = taskInfo
				} else if taskInfo.TaskType == model.TASK_TYPE_WEEK {
					this.weekTaskList[taskInfo.TaskId] = taskInfo
				} else if taskInfo.TaskType == model.TASK_TYPE_MAIN {
					this.mainTaskList[taskInfo.TaskId] = taskInfo
				}
			}
			this.initTaskDataFromConfig()

			for _, valueType := range dbRole.RoleTask.TypeRecCount {
				this.recTypeCnt[valueType.Key] = valueType
			}
		}

		if len(dbRole.RoleTask.Condition) <= 0 { //账号初始化主角
			this.role.roleTask.GetChangeJobTask(this.role.GetRoleBase().RoleData().HeroData.Id, 0, false)
		}
		if len(this.jobCondition) <= 0 {
			this.jobCondition = dbRole.RoleTask.Condition
		}
		//this.role.roleTask.InitJobTask()
		dbRole.RoleTask.Condition = this.jobCondition

		//}
		//if len(dbRole.RoleTask.Condition) > 0 {
		//	this.jobCondition = dbRole.RoleTask.Condition
		//}
		if dbRole.RoleTask.HeadCond != nil {
			this.roleHeadCond = *dbRole.RoleTask.HeadCond
		}

		this.totalAddZeny = dbRole.RoleTask.TotalAddZeny
	}

	return true
}

func (this *RoleTask) OnlineProcess() {
	this.role.roleTask.InitJobTask()
}

func (this *RoleTask) CopyData() *serverproto.RoleTask {
	//this.loadTaskData.DailyTaskScore = &this.dailyTaskScore
	//this.loadTaskData.WeekTaskScore = &this.weekTaskScore
	//this.loadTaskData.Condition = this.jobCondition
	//this.loadTaskData.HeadCond = &this.roleHeadCond
	//
	//this.loadTaskData.Latest5HourTime = util.GetLatest5Hour()
	//this.loadTaskData.LatestWeek5HourTime = util.GetLatestWeek5Hour()

	//util.DebugF("Online Pack RoleTask =%v", this.loadTaskData)
	//return this.loadTaskData

	tmpRoleTask := &serverproto.RoleTask{
		DailyTaskScore:      &this.dailyTaskScore,
		WeekTaskScore:       &this.weekTaskScore,
		Condition:           this.jobCondition,
		HeadCond:            &this.roleHeadCond,
		Latest5HourTime:     util.GetLatest5Hour(),
		LatestWeek5HourTime: util.GetLatestWeek5Hour(0),
	}
	for _, val := range this.dailyTaskList {
		tmpRoleTask.TaskList = append(tmpRoleTask.TaskList, val)
	}
	for _, val := range this.weekTaskList {
		tmpRoleTask.TaskList = append(tmpRoleTask.TaskList, val)
	}
	for _, val := range this.mainTaskList {
		tmpRoleTask.TaskList = append(tmpRoleTask.TaskList, val)
	}
	for _, val := range this.recTypeCnt {
		tmpRoleTask.TypeRecCount = append(tmpRoleTask.TypeRecCount, val)
	}

	return tmpRoleTask
}

func (this *RoleTask) Save() {
	this.SetDirty(false)

	saveMsg := &serverproto.SSTaskDataSaveReq{
		Task: &serverproto.RoleTask{
			DailyTaskScore: &this.dailyTaskScore,
			WeekTaskScore:  &this.weekTaskScore,
		},
	}
	saveMsg.Task.Condition = this.jobCondition
	saveMsg.Task.HeadCond = &this.roleHeadCond

	saveMsg.Task.TaskList = append(this.saveTaskDataList)
	this.saveTaskDataList = this.saveTaskDataList[:0]
	saveMsg.Task.TotalAddZeny = this.totalAddZeny
	for _, val := range this.recTypeCnt {
		saveMsg.Task.TypeRecCount = append(saveMsg.Task.TypeRecCount, val)
	}
	this.role.SendDb(saveMsg)
}

// 记录任务事件计数， 触发该记录事件前先调用该函数进行计数累加
func (this *RoleTask) AddTypeCnt(recType serverproto.TaskType, cnt int32) {
	rec := int32(recType)
	val, ok := this.recTypeCnt[rec]
	if !ok {
		val = &serverproto.KeyValueType{Key: rec}
	}
	val.Value += cnt
	this.recTypeCnt[rec] = val
	this.SetDirty(true)
}

// 记录任务事件计数， 触发该记录事件前先调用该函数进行计数累加
func (this *RoleTask) SetTypeCnt(recType serverproto.TaskType, cnt int32) {
	rec := int32(recType)
	val, ok := this.recTypeCnt[rec]
	if !ok {
		val = &serverproto.KeyValueType{Key: rec}
	}
	val.Value = cnt
	this.recTypeCnt[rec] = val
	this.SetDirty(true)
}

func (this *RoleTask) GetTypeCnt(recType int32) int32 {
	val, ok := this.recTypeCnt[recType]
	if !ok {
		return 0
	}
	return val.Value
}

func (this *RoleTask) DailyReset(notify bool, oldDailyResetTimeStamp uint64) {
	ntfMsg := &serverproto.SCTaskChangeNtf{
		DailyTaskScore:      &this.dailyTaskScore,
		WeekTaskScore:       &this.weekTaskScore,
		Latest5HourTime:     util.GetLatest5Hour(),
		LatestWeek5HourTime: util.GetLatestWeek5Hour(0),
	}

	this.resetDailyTask(ntfMsg)
	//每日重置时判断是否是每周重置
	if util.IsInSameWeek(oldDailyResetTimeStamp, util.GetTimeMilliseconds()) {
		this.resetWeekTask(ntfMsg)
	}
	this.AddTypeCnt(serverproto.TaskType_Eve_Login_Day, 1)
	TaskMagCheck(this.role, serverproto.TaskType_Eve_Login_Day, 1)
	this.SetDirty(true)

	if notify {
		this.role.ReplayGate(ntfMsg, true)
	}
}

func (this *RoleTask) resetDailyTask(ntfMsg *serverproto.SCTaskChangeNtf) {
	this.dailyTaskScore.Key = 0
	this.dailyTaskScore.Value = 0
	for _, val := range this.dailyTaskList {
		if val.State != TASK_REWARD_STATE_NONE || len(val.Progress) > 0 {
			val.State = TASK_REWARD_STATE_NONE
			val.Progress = val.Progress[:0]
			this.saveTaskDataList = append(this.saveTaskDataList, val)
			ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, val)
		}
	}
}
func (this *RoleTask) resetWeekTask(ntfMsg *serverproto.SCTaskChangeNtf) {
	this.weekTaskScore.Key = 0
	this.weekTaskScore.Value = 0
	for _, val := range this.weekTaskList {
		if val.State != TASK_REWARD_STATE_NONE || len(val.Progress) > 0 {
			val.State = TASK_REWARD_STATE_NONE
			val.Progress = val.Progress[:0]
			this.saveTaskDataList = append(this.saveTaskDataList, val)
			ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, val)
		}
	}
}

func (this *RoleTask) initTaskDataFromConfig() {
	var tmpOriginalMainTask = map[uint32]struct{}{} //originalTaskId
	for _, mainTaskData := range this.mainTaskList {
		tmpId := model.ConvertMainTaskOriginalList[mainTaskData.TaskId]
		tmpOriginalMainTask[tmpId] = struct{}{}
	}

	//daily/week/main 添加新任务后，重新登陆即可自动接取
	for _, val := range model.ConvertAddTaskList {
		switch val.TaskType {
		case model.TASK_TYPE_DAILY:
			if _, ok := this.dailyTaskList[val.TaskId]; !ok {
				taskInfo := &serverproto.TaskData{
					TaskId: val.TaskId,
					State:  TASK_REWARD_STATE_NONE,
					//BeginTime: util.GetTimeMilliseconds(),
					TaskType: val.TaskType,
				}
				this.dailyTaskList[val.TaskId] = taskInfo
				this.loadTaskData.TaskList = append(this.loadTaskData.TaskList, taskInfo)
			}
		case model.TASK_TYPE_WEEK:
			if _, ok := this.weekTaskList[val.TaskId]; !ok {
				taskInfo := &serverproto.TaskData{
					TaskId: val.TaskId,
					State:  TASK_REWARD_STATE_NONE,
					//BeginTime: util.GetTimeMilliseconds(),
					TaskType: val.TaskType,
				}
				this.weekTaskList[val.TaskId] = taskInfo
				this.loadTaskData.TaskList = append(this.loadTaskData.TaskList, taskInfo)
			}
		case model.TASK_TYPE_MAIN:
			if _, ok := tmpOriginalMainTask[val.TaskId]; !ok {
				taskInfo := &serverproto.TaskData{
					TaskId: val.TaskId,
					State:  TASK_REWARD_STATE_NONE,
					//BeginTime: util.GetTimeMilliseconds(),
					TaskType: val.TaskType,
				}
				this.mainTaskList[val.TaskId] = taskInfo
				this.loadTaskData.TaskList = append(this.loadTaskData.TaskList, taskInfo)
			}
		}
	}
}

func (this *RoleTask) getTaskData(taskId uint32) *serverproto.TaskData {
	if taskInfo, ok := this.dailyTaskList[taskId]; ok {
		return taskInfo
	}
	if taskInfo, ok := this.weekTaskList[taskId]; ok {
		return taskInfo
	}
	if taskInfo, ok := this.mainTaskList[taskId]; ok {
		return taskInfo
	}
	return nil
}

func (this *RoleTask) initTaskTypeList() {
	if len(this.taskTypeList) <= 0 {
		//dailyTaskList
		for _, taskInfo := range this.dailyTaskList {
			convertData, ok := model.ConvertTaskList[taskInfo.TaskId]
			if !ok {
				continue
			}
			for key := range convertData.Condition {
				if _, ok := this.taskTypeList[key]; !ok {
					this.taskTypeList[key] = set.New(set.NonThreadSafe)
				}
				this.taskTypeList[key].Add(taskInfo.TaskId)
			}
		}
		//weekTaskList
		for _, taskInfo := range this.weekTaskList {
			convertData, ok := model.ConvertTaskList[taskInfo.TaskId]
			if !ok {
				continue
			}
			for key := range convertData.Condition {
				if _, ok := this.taskTypeList[key]; !ok {
					this.taskTypeList[key] = set.New(set.NonThreadSafe)
				}
				this.taskTypeList[key].Add(taskInfo.TaskId)
			}
		}
		//mainTaskList
		//主线已经完成的不再完成
		for _, taskInfo := range this.mainTaskList {
			if taskInfo.State == TASK_REWARD_STATE_COMPLETED {
				continue
			}
			convertData, ok := model.ConvertTaskList[taskInfo.TaskId]
			if !ok {
				continue
			}
			for key := range convertData.Condition {
				if _, ok := this.taskTypeList[key]; !ok {
					this.taskTypeList[key] = set.New(set.NonThreadSafe)
				}
				this.taskTypeList[key].Add(taskInfo.TaskId)
			}
		}
	}
}

func (this *RoleTask) TaskCheck(taskType serverproto.TaskType, count int32) {
	this.initTaskTypeList()
	typeList, ok := this.taskTypeList[int32(taskType)]
	if !ok || typeList.Size() <= 0 {
		return
	}

	ntfMsg := &serverproto.SCTaskChangeNtf{
		DailyTaskScore: &this.dailyTaskScore,
		WeekTaskScore:  &this.weekTaskScore,
	}
	for _, val := range this.taskTypeList[int32(taskType)].List() {
		tmpTaskId := val.(uint32)
		if taskInfo := this.getTaskData(tmpTaskId); taskInfo != nil {
			convertTaskData, ok := model.ConvertTaskList[taskInfo.TaskId]
			if !ok {
				util.ErrorF("uid=%v TaskCheck TaskCfgData not exist", this.role.GetUUid(), taskInfo)
				continue
			}
			if taskInfo.State != TASK_REWARD_STATE_COMPLETED &&
				taskInfo.State != TASK_REWARD_STATE_REWARD {
				util.InfoF("uid=%v TaskCheck before taskInfo=%v", this.role.GetUUid(), taskInfo)
			}
			//多条件处理
			ret := TaskConditionCheck(this.role, taskInfo, taskType, convertTaskData.Condition, count, false)
			if ret {
				this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
				ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, taskInfo)

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

func (this *RoleTask) jobConditionChangeNtf(changedId []int32) {
	ntfMsg := &serverproto.SCHeroConditinDataNtf{}
	for _, heroId := range changedId {
		for index, data := range this.jobCondition {
			if data.HeroId == heroId {
				ntfMsg.Condition = append(ntfMsg.Condition, this.jobCondition[index])
			}
		}
	}
	this.role.ReplayGate(ntfMsg, true)
	this.role.GetRoleBase().SetDirty(true)

	util.DebugF("uid=%v jobcondition=%v", this.role.GetUUid(), this.jobCondition)
}

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

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

func (this *RoleTask) GetTaskReward(taskId uint32) serverproto.ErrorCode {
	this.initTaskTypeList()

	taskInfo := this.getTaskData(taskId)
	if taskInfo == nil {
		return serverproto.ErrorCode_ERROR_FAIL
	}
	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
		}
	}

	convertTaskData, ok := model.ConvertTaskList[taskInfo.TaskId]
	if !ok {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//获取奖励
	var addItemList = map[int32]int32{}
	for _, value := range convertTaskData.TaskReward {
		addItemList[value.Key] = value.Value
	}
	//无道具有积分
	if len(addItemList) > 0 {
		//道具入背包
		if ret := this.role.CanAddItemList(addItemList); ret != serverproto.ErrorCode_ERROR_OK {
			return ret
		}
		this.role.AddItemList(addItemList, AddFrom_Task, true)
	}

	ntfMsg := &serverproto.SCTaskChangeNtf{
		DailyTaskScore: &this.dailyTaskScore,
		WeekTaskScore:  &this.weekTaskScore,
	}
	//是否有后续任务,自动接取后续任务
	taskInfo.State = TASK_REWARD_STATE_REWARD
	switch taskInfo.TaskType {
	case model.TASK_TYPE_DAILY:
		this.dailyTaskScore.Value += convertTaskData.TaskScore
	case model.TASK_TYPE_WEEK:
		this.weekTaskScore.Value += convertTaskData.TaskScore
	}
	if rune := this.role.GetRoleRune(); rune != nil {
		rune.AddMissionExp(convertTaskData.TaskScore)
	}

	this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
	ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, taskInfo)

	if convertTaskData.NextTaskId != 0 {
		////获取下一个任务的继承数值
		//var preTaskCount int32 = 0
		//if _, tmpOk := convertTaskData.Condition[int32(serverproto.TaskType_Get_Silver_Count)]; tmpOk {
		//	for idx := 0; idx < len(taskInfo.Progress); idx++ {
		//		if taskInfo.Progress[idx].Key == int32(serverproto.TaskType_Get_Silver_Count) {
		//			preTaskCount = taskInfo.Progress[idx].Value
		//		}
		//	}
		//}

		if taskInfo.TaskType == model.TASK_TYPE_MAIN {
			taskInfo.Progress = taskInfo.Progress[:0]
			for key, _ := range convertTaskData.Condition {
				if _, ok := this.taskTypeList[key]; ok {
					this.taskTypeList[key].Remove(taskInfo.TaskId)
				}
			}
			delete(this.mainTaskList, taskInfo.TaskId)
		}

		nextTaskInfo := this.genNextTask(convertTaskData.NextTaskId, 0)
		if nextTaskInfo != nil {
			ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, nextTaskInfo)
		}
	}

	this.SetDirty(true)
	this.role.ReplayGate(ntfMsg, true)

	//发送奖励数据(客户端显示)
	ackMsg := &serverproto.SCGetTaskRewardAck{
		Error: int32(serverproto.ErrorCode_ERROR_OK),
	}
	ackMsg.ItemList = append(convertTaskData.TaskReward)
	this.role.ReplayGate(ackMsg, true)

	//任务完成活跃度增加
	cfgData, ok := serverproto.MissionCfgLoader[int32(taskId)]
	if ok {
		this.role.roleGuild.AddGuildActivity(cfgData.Active)
	}

	util.DebugF("uid=%v SCGetTaskRewardAck current task reward=%v", this.role.GetUUid(), convertTaskData.TaskId)
	util.DebugF("uid=%v SCTaskChangeNtf msg=%v", this.role.GetUUid(), ntfMsg)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleTask) GetTaskScoreReward(rewardType, rewardIdx uint32) serverproto.ErrorCode {
	this.initTaskTypeList()

	if rewardIdx <= 0 || rewardIdx > 32 {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	//发送奖励数据(客户端显示)
	ackMsg := &serverproto.SCGetTaskScoreRewardAck{
		Error: int32(serverproto.ErrorCode_ERROR_OK),
	}
	//获取奖励
	var addItemList = map[int32]int32{}
	if rewardType == model.TASK_TYPE_DAILY { //daily
		if this.dailyTaskScore.Key&(1<<rewardIdx) > 0 {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_REWARDED
		}
		convertData, ok := model.ConvertDailyTaskScoreRewardList[rewardIdx]
		if !ok {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_NOT_FOUND
		}
		if convertData.Active > this.dailyTaskScore.Value {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_NOT_ENOUGH
		}

		for _, value := range convertData.RewardList {
			addItemList[value.Key] = value.Value
		}
		//活动掉落指定道具
		for _, value := range convertData.HDRewardList {
			if !CheckHDItemAdd(value.Key, this.role) {
				continue
			}
			addItemList[value.Key] = value.Value
		}
		if ret := this.role.CanAddItemList(addItemList); ret != serverproto.ErrorCode_ERROR_OK {
			return ret
		}

		this.dailyTaskScore.Key |= 1 << rewardIdx
		this.SetDirty(true)
	} else if rewardType == model.TASK_TYPE_WEEK { //week
		if this.weekTaskScore.Key&(1<<rewardIdx) > 0 {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_REWARDED
		}
		convertData, ok := model.ConvertWeekTaskScoreRewardList[rewardIdx]
		if !ok {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_NOT_FOUND
		}
		if convertData.Active > this.weekTaskScore.Value {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_NOT_ENOUGH
		}

		for _, value := range convertData.RewardList {
			addItemList[value.Key] = value.Value
		}
		//活动掉落指定道具
		for _, value := range convertData.HDRewardList {
			if !CheckHDItemAdd(value.Key, this.role) {
				continue
			}
			addItemList[value.Key] = value.Value
		}
		if ret := this.role.CanAddItemList(addItemList); ret != serverproto.ErrorCode_ERROR_OK {
			return ret
		}

		this.weekTaskScore.Key |= 1 << rewardIdx
		this.SetDirty(true)
	}
	for key, val := range addItemList {
		ackMsg.ItemList = append(ackMsg.ItemList, &serverproto.KeyValueType{
			Key:   key,
			Value: val,
		})
	}

	ntfMsg := &serverproto.SCTaskChangeNtf{
		DailyTaskScore: &this.dailyTaskScore,
		WeekTaskScore:  &this.weekTaskScore,
	}
	this.role.ReplayGate(ntfMsg, true)

	this.role.AddItemList(addItemList, AddFrom_Task, true)
	this.role.ReplayGate(ackMsg, true)

	util.DebugF("uid=%v, GetTaskScoreReward current task type=%v idx=%v additemlist=%v",
		this.role.GetUUid(), rewardType, rewardIdx, addItemList)
	return serverproto.ErrorCode_ERROR_OK
}

//来自上一个任务的继承数值preTaskCount
func (this *RoleTask) genNextTask(nextTaskId uint32, preTaskCount int32) *serverproto.TaskData {
	convertTaskData, ok := model.ConvertTaskList[nextTaskId]
	if ok && convertTaskData.TaskType == model.TASK_TYPE_MAIN {
		util.DebugF("uid=%v, genNextTask next task=%v", this.role.GetUUid(), nextTaskId)
		//接取下个任务后自动判断
		nextTaskInfo := &serverproto.TaskData{
			TaskId: nextTaskId,
			State:  TASK_REWARD_STATE_NONE,
			//BeginTime: util.GetTimeMilliseconds(),
			TaskType: convertTaskData.TaskType,
		}
		for key := range convertTaskData.Condition {
			if _, ok := this.taskTypeList[key]; !ok {
				this.taskTypeList[key] = set.New(set.NonThreadSafe)
			}
			this.taskTypeList[key].Add(nextTaskId)
		}

		TaskConditionCheck(this.role, nextTaskInfo, serverproto.TaskType_NONE,
			convertTaskData.Condition, preTaskCount, false)
		this.SetDirty(true)

		//save db
		this.saveTaskDataList = append(this.saveTaskDataList, nextTaskInfo)
		this.loadTaskData.TaskList = append(this.loadTaskData.TaskList, nextTaskInfo)
		this.mainTaskList[nextTaskInfo.TaskId] = nextTaskInfo

		return nextTaskInfo
	}
	return nil
}

func (this *RoleTask) InitJobTask() {
	for _, data := range this.jobCondition {
		if data.JobFushState > 0 {
			continue
		}
		heroData := this.role.roleHero.GetHero(data.HeroId)
		if heroData == nil {
			continue
		}
		data.JobFushState = 1
		dbIndex := model.GetJobChangeKey(this.role.roleHero.IsMainHero(data.HeroId), heroData.ConfigId)
		db, ok := model.DBJobChange[dbIndex]
		if !ok {
			util.InfoF("ChangeJob JobCfgLoader data not found cfgid=%v, %v", heroData.ConfigId, dbIndex)
			return
		}
		//if len(data.TaskList) == len(db.ChangeCond) {
		//	continue
		//}
		data.TaskList = data.TaskList[0:0]
		for _, condData := range db.ChangeCond { //遍历当前可转职任务
			var taskProgressType []*serverproto.TaskProgressType
			condId, _ := model.Str2Num(condData)
			condCfg, condOk := serverproto.ConditionCfgLoader[int32(condId)]
			if !condOk || len(condCfg.Condition[0]) < 2 {
				util.ErrorF("ChangeJob ConditionCfgLoader data not found cfgid=%v", condId)
				continue
			}
			//一个任务ID之对应一个条件，所以直接去第一个参数作为TaskType
			taskInfo := strings.Split(condCfg.Condition[0], ":")
			taskType, _ := model.Str2Num(taskInfo[0])
			taskProgressType = append(taskProgressType, &serverproto.TaskProgressType{
				Key:   int32(taskType),
				Value: 0,
			})

			data.TaskList = append(data.TaskList, &serverproto.TaskData{
				TaskId:   uint32(condId),
				Progress: taskProgressType,
			})
		}
		//刷新任务状态
		for _, task := range data.TaskList {
			for _, data := range task.Progress {
				TaskMagCheck(this.role, serverproto.TaskType(data.Key), 0)
			}
		}

	}
	this.SetDirty(true)
}
func (this *RoleTask) GetChangeJobTask(heroId int32, changeType int32, bNtf bool) {
	//获取转职的伙伴数据
	heroData := this.role.roleHero.GetHero(heroId)
	if heroData == nil {
		util.InfoF("uid=%v ChangeJob main hero not found", this.role.GetUUid())
		return
	}

	//获取可转职职业ID列表
	var changeCondition []string
	if this.role.roleHero.IsMainHero(heroId) {
		jobCfg, jobOk := serverproto.JobCfgLoader[heroData.ConfigId]
		if !jobOk {
			util.InfoF("ChangeJob JobCfgLoader data not found cfgid=%v", heroData.ConfigId)
			return
		}
		changeCondition = jobCfg.ChangeCond
	} else {
		jobCfg, jobOk := serverproto.ParterCfgLoader[heroData.ConfigId]
		if !jobOk {
			util.InfoF("ChangeJob ParterCfgLoader data not found cfgid=%v", heroData.ConfigId)
			return
		}
		changeCondition = jobCfg.ChangeCond
	}

	//是否有这个伙伴的转职任务列表
	var newJobCondition serverproto.ChangeJob
	var bFind bool = false
	for _, data := range this.jobCondition {
		if data.HeroId == heroId {
			newJobCondition = *data
			bFind = true
		}
	}
	if !bFind {
		this.jobCondition = append(this.jobCondition, &newJobCondition)
	}

	//清空当前的所有任务list
	if len(newJobCondition.TaskList) > 0 {
		newJobCondition.TaskList = newJobCondition.TaskList[0:0]
	}
	newJobCondition.HeroId = heroId

	//小任务加入任务列表
	for _, condData := range changeCondition { //遍历当前可转职任务
		var taskProgressType []*serverproto.TaskProgressType
		condId, _ := model.Str2Num(condData)
		condCfg, condOk := serverproto.ConditionCfgLoader[int32(condId)]
		if !condOk || len(condCfg.Condition[0]) < 2 {
			util.ErrorF("ChangeJob ConditionCfgLoader data not found cfgid=%v", condId)
			continue
		}
		//一个任务ID之对应一个条件，所以直接去第一个参数作为TaskType
		taskInfo := strings.Split(condCfg.Condition[0], ":")
		taskType, _ := model.Str2Num(taskInfo[0])
		taskProgressType = append(taskProgressType, &serverproto.TaskProgressType{
			Key:   int32(taskType),
			Value: 0,
		})

		newJobCondition.TaskList = append(newJobCondition.TaskList, &serverproto.TaskData{
			TaskId:   uint32(condId),
			Progress: taskProgressType,
		})
	}
	//如果是替换职业，并且，
	if len(newJobCondition.TaskList) > 0 {
		for _, task := range newJobCondition.TaskList {
			for _, data := range task.Progress {
				//转职条件处理
				this.jobConditionCheck(serverproto.TaskType(data.Key), 0)
			}
		}
	}

	if bNtf {
		this.jobConditionChangeNtf([]int32{heroId})
	}
	this.SetDirty(true)
}

func (this *RoleTask) jobConditionCheck(taskType serverproto.TaskType, count int32) {
	this.heroConditionCheck(taskType, count)
}

func (this *RoleTask) heroConditionCheck(taskType serverproto.TaskType, count int32) {
	roleData := this.role.GetRoleBase().RoleData()
	if roleData == nil {
		return
	}

	//遍历查找
	var changedIds []int32
	for _, data := range this.jobCondition {
		var bChanged bool = false
		for _, subData := range data.TaskList {
			taskInfo := subData.Progress[0]
			cond, ok := model.ChangeJobCond[int32(subData.TaskId)]
			if !ok {
				util.InfoF("heroConditionCheck ChangeJobCond data not found taskid=%v", subData.TaskId)
				continue
			}
			if taskInfo.Key != int32(taskType) || taskInfo.State == 1 { //不是条件任务。或者已经完成
				continue
			}
			bChanged = TaskConditionCheck(this.role, subData,
				taskType, cond.Condition, count, false)
		}
		if bChanged {
			changedIds = append(changedIds, data.HeroId)
			this.SetDirty(true)
		}
	}
	if len(changedIds) > 0 {
		this.jobConditionChangeNtf(changedIds)
	}
}

//------- 头像解锁条件 ----------------------------------

func (this *RoleTask) OnlineCheckNewHead() {
	//上线检查头像是否有更新
	headVersion, ok := serverproto.GlobalCfgLoader[int32(serverproto.GlobalType_Global_Cur_Head_Version)]
	if !ok {
		util.ErrorF(" headpic config not found")
		return
	}
	if this.role.GetRoleBase().roleBase.Head_Info.HeadVersion >= headVersion.IVal {
		util.ErrorF("headpic version error version=%v val=%v", this.role.GetRoleBase().roleBase.Head_Info.HeadVersion, headVersion.IVal)
		return
	}

	//遍历新的头像
	for _, data := range serverproto.HeadPortraitCfgLoader {
		//老版本已经加载过
		if this.role.GetRoleBase().roleBase.Head_Info.HeadVersion >= data.HeadLoadId {
			continue
		}
		//性别不一致
		if this.role.GetRoleBase().GetRoleSex() != data.HeadPortraitSex {
			continue
		}
		//没有解锁要求，默认解锁激活
		if data.UnlockCondition == 0 {
			this.role.GetRoleBase().roleBase.Head_Info.HeadList = append(this.role.GetRoleBase().roleBase.Head_Info.HeadList, data.HeadPortraitId)
			continue
		}

		//后续版本的头像都加入到条件列表中来
		condCfg, condOk := model.ChangeJobCond[data.UnlockCondition]
		if !condOk {
			util.ErrorF("headpic ChangeJobCond not find condition=%v", data.UnlockCondition)
			continue
		}
		//把当前头像加入到
		var headCond serverproto.HeadCond
		headCond.HeadId = data.HeadPortraitId
		var taskData serverproto.TaskData
		taskData.TaskId = uint32(data.UnlockCondition)
		for key, _ := range condCfg.Condition {
			taskData.Progress = append(taskData.Progress, &serverproto.TaskProgressType{
				Key:   key,
				Value: 0,
				State: 0,
			})
		}
		headCond.TaskList = append(headCond.TaskList, &taskData)

		this.roleHeadCond.Conditions = append(this.roleHeadCond.Conditions, &headCond)
	}
	//设置当前最新版本
	this.role.GetRoleBase().roleBase.Head_Info.HeadVersion = headVersion.IVal
	this.SetDirty(true)
}

//检查头像是否解锁
func (this *RoleTask) CheckHeadUnlocked(headId int32) bool {
	for _, data := range this.roleHeadCond.Conditions {
		if data.HeadId != headId {
			continue
		}
		for _, taskData := range data.TaskList {
			for _, taskInfo := range taskData.Progress {
				if taskInfo.State == 0 {
					return false
				}
			}
		}
	}
	return true
}

func (this *RoleTask) headConditionCheck(taskType serverproto.TaskType, count int32) {
	this.headUnlockCheck(taskType, count)
}

func (this *RoleTask) headUnlockCheck(taskType serverproto.TaskType, count int32) {
	//遍历查找
	var bRet bool = false
	for _, data := range this.roleHeadCond.Conditions {
		for _, taskData := range data.TaskList {
			if taskData.State == TASK_REWARD_STATE_REWARD {
				continue
			}
			for _, taskInfo := range taskData.Progress {
				cond, ok := model.ChangeJobCond[int32(taskData.TaskId)]
				if !ok {
					util.InfoF("headUnlockCheck ChangeJobCond not found taskid=%v", taskData.TaskId)
					continue
				}
				if taskInfo.Key != int32(taskType) || taskInfo.State == 1 { //不是条件任务。或者已经完成
					continue
				}

				bRet = TaskConditionCheck(this.role, taskData,
					taskType, cond.Condition, count, false)
				if !bRet {
					continue
				}
				this.SetDirty(true)
			}
		}
	}
	if bRet == true {
		//通知客户端
		//		this.headConditionChangeNtf()
	}
}