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_REWARD_STATE_DELETE    = 3 //困难模式可删除状态

	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
	mapHardTaskList      map[uint32]*serverproto.TaskData //困难模式任务
	mapGroupHardTaskList 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{},
		mapHardTaskList:      map[uint32]*serverproto.TaskData{},
		mapGroupHardTaskList: 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/game 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
			}
			//util.InfoF("qqqqqqdb:%v", dbRole.RoleTask.TaskList)
			for idx := range dbRole.RoleTask.TaskList {
				taskInfo := dbRole.RoleTask.TaskList[idx]
				if taskInfo.TaskType == model.TASK_TYPE_HARD {
					_, ok := model.HardMissionTaskList[taskInfo.TaskId]
					if !ok {
						continue
					}
				} else if taskInfo.TaskType == model.TASK_TYPE_HARD_GROUP {
					_, ok := model.HardGroupMissionTaskList[taskInfo.TaskId]
					if !ok {
						continue
					}
				} else {
					_, 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
				} else if taskInfo.TaskType == model.TASK_TYPE_HARD {
					this.mapHardTaskList[taskInfo.TaskId] = taskInfo
				} else if taskInfo.TaskType == model.TASK_TYPE_HARD_GROUP {
					this.mapGroupHardTaskList[taskInfo.TaskId] = taskInfo
				}
			}
			//util.InfoF("qqqqqq:%v bbbbbb:%v", this.mapHardTaskList, this.mapGroupHardTaskList)
			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)
	}
	//var groupId uint32
	//for _, val := range this.mapHardTaskList {
	//	if val.State != TASK_REWARD_STATE_REWARD {
	//		groupId = model.HardMissionTaskList[val.TaskId].GroupTaskId
	//		tmpRoleTask.TaskList = append(tmpRoleTask.TaskList, val)
	//		continue
	//	}
	//	if groupId == 0 && model.HardMissionTaskList[val.TaskId].GroupTaskId == groupId {
	//		tmpRoleTask.TaskList = append(tmpRoleTask.TaskList, val)
	//	}
	//}

	for _, val := range this.mapHardTaskList {
		tmpRoleTask.TaskList = append(tmpRoleTask.TaskList, val)
	}

	for _, val := range this.mapGroupHardTaskList {
		tmpRoleTask.TaskList = append(tmpRoleTask.TaskList, val)
	}
	util.InfoF("send task group:%v task:%v all task:%v", this.mapGroupHardTaskList, this.mapHardTaskList, tmpRoleTask.TaskList)

	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/game 添加新任务后，重新登陆即可自动接取
	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)
			}
		}
	}
	//util.InfoF("uuid:%v init hard task1:%v", this.role.GetUUid(), this.mapHardTaskList)
	var curId uint32
	var bSave bool
	if len(this.mapHardTaskList) > 0 {
		for _, v := range this.mapHardTaskList {
			if curId <= v.TaskId {
				curId = v.TaskId
			}
		}
	}
	for _, val := range model.HardMissionTaskIdList {
		//每组任务3个，目前只初始化5组所以是15个任务
		if len(this.mapHardTaskList) >= 15 {
			break
		}
		if val < curId {
			continue
		}
		bSave = true
		data := model.HardMissionTaskList[val]
		if data != nil {
			taskInfo := &serverproto.TaskData{
				TaskId: data.TaskId,
				State:  TASK_REWARD_STATE_NONE,
				//BeginTime: util.GetTimeMilliseconds(),
				TaskType: data.TaskType,
			}
			this.mapHardTaskList[data.TaskId] = taskInfo
			this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
		}
	}
	util.InfoF("uuid:%v init hard task2:%v", this.role.GetUUid(), this.mapHardTaskList)

	var curGroupId uint32
	if len(this.mapGroupHardTaskList) > 0 {
		for _, v := range this.mapGroupHardTaskList {
			if curGroupId <= v.TaskId {
				curGroupId = v.TaskId
			}
		}
	}
	//util.InfoF("uuid:%v init hard task group1:%v", this.role.GetUUid(), this.mapGroupHardTaskList)
	for _, val := range model.HardGroupMissionTaskIdList {
		//初始化5组 组任务
		if len(this.mapGroupHardTaskList) >= 5 {
			break
		}
		if val < curGroupId {
			continue
		}
		bSave = true
		data := model.HardGroupMissionTaskList[val]
		if data != nil {
			taskInfo := &serverproto.TaskData{
				TaskId: data.GroupTaskId,
				State:  TASK_REWARD_STATE_NONE,
				//BeginTime: util.GetTimeMilliseconds(),
				TaskType: data.TaskType,
			}
			this.mapGroupHardTaskList[data.GroupTaskId] = taskInfo
			this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
		}
	}
	if bSave {
		this.SetDirty(true)
	}
	util.InfoF("uuid:%v init hard task group2:%v", this.role.GetUUid(), this.mapGroupHardTaskList)
}

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
	}
	//if taskInfo, ok := this.mapHardTaskList[taskId]; ok {
	//	return taskInfo
	//}
	return nil
}

func (this *RoleTask) getTaskHardAllData(taskId uint32) *serverproto.TaskData {
	if taskInfo, ok := this.mapHardTaskList[taskId]; ok {
		return taskInfo
	}
	if taskInfo, ok := this.mapGroupHardTaskList[taskId]; ok {
		return taskInfo
	}
	return nil
}

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

func (this *RoleTask) getGroupTaskHardData(taskId uint32) *serverproto.TaskData {
	if taskInfo, ok := this.mapGroupHardTaskList[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)
			}
		}

		for _, taskInfo := range this.mapHardTaskList {
			if taskInfo.State == TASK_REWARD_STATE_COMPLETED {
				continue
			}
			convertData, ok := model.HardMissionTaskList[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)
			}
		}

		for _, taskInfo := range this.mapGroupHardTaskList {
			if taskInfo.State == TASK_REWARD_STATE_COMPLETED {
				continue
			}
			convertData, ok := model.HardGroupMissionTaskList[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 taskType == serverproto.TaskType_Level_Hard_Battle_Count {
			if taskInfo := this.getTaskHardAllData(tmpTaskId); taskInfo != nil {
				if taskInfo.TaskType == model.TASK_TYPE_HARD {
					convertTaskData, ok := model.HardMissionTaskList[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)
					}
				} else if taskInfo.TaskType == model.TASK_TYPE_HARD_GROUP {
					convertTaskData, ok := model.HardGroupMissionTaskList[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)
					}
				}
			}
		} else {
			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 taskType == serverproto.TaskType_Level_Hard_Battle_Count {
		this.AddHardTask()
	}
	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) AddHardTask() bool {
	var (
		count2     int32  //未完成任务组数量
		maxGroupId uint32 //最后一组 组id
		//ggId       uint32
	)

	for _, v := range this.mapGroupHardTaskList {
		if v.State == TASK_REWARD_STATE_NONE {
			count2++
			//if maxGroupId < v.TaskId {
			//	maxGroupId = v.TaskId
			//}
			break
		}
		if maxGroupId < v.TaskId {
			maxGroupId = v.TaskId
		}
	}

	if count2 < 1 {
		////一下全部完成了任务
		//if maxGroupId == 0 {
		//	maxGroupId = ggId
		//}
		var (
			count3 int32
			count4 int32
			maxId  uint32 //最后一个小任务id
		)
		if v, ok := model.HardGroupMissionTaskList[maxGroupId]; ok {
			maxId = v.TaskId
		}
		ntfMsg := &serverproto.SCTaskChangeNtf{
			DailyTaskScore: &this.dailyTaskScore,
			WeekTaskScore:  &this.weekTaskScore,
		}
		for _, val := range model.HardGroupMissionTaskIdList {
			//初始化5组 组任务
			if count3 >= 5 {
				break
			}
			if val <= maxGroupId {
				continue
			}
			data := model.HardGroupMissionTaskList[val]
			if data != nil {
				taskInfo := &serverproto.TaskData{
					TaskId: data.GroupTaskId,
					State:  TASK_REWARD_STATE_NONE,
					//BeginTime: util.GetTimeMilliseconds(),
					TaskType: data.TaskType,
				}
				passNum := this.role.GetRoleBattle().GetPassHardBattleIdNum(data.Condition[int32(serverproto.TaskType_Level_Hard_Battle_Count)][1])
				if passNum == 1 {
					taskInfo.State = TASK_REWARD_STATE_COMPLETED
					taskInfo.Progress = []*serverproto.TaskProgressType{{Key: 102, Value: 1, State: 1}}
				}
				this.mapGroupHardTaskList[data.GroupTaskId] = taskInfo
				//role.roleTask.loadTaskData.TaskList = append(role.roleTask.loadTaskData.TaskList, taskInfo)
				this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
				ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, taskInfo)
				//util.InfoF("add task gg:%v", taskInfo)
				count3++
			}
		}
		for _, val := range model.HardMissionTaskIdList {
			//每组任务3个，目前只初始化5组所以是15个任务
			if count4 >= 15 {
				break
			}
			if val <= maxId {
				continue
			}
			data := model.HardMissionTaskList[val]
			if data != nil {
				taskInfo := &serverproto.TaskData{
					TaskId: data.TaskId,
					State:  TASK_REWARD_STATE_NONE,
					//BeginTime: util.GetTimeMilliseconds(),
					TaskType: data.TaskType,
				}
				passNum := this.role.GetRoleBattle().GetPassHardBattleIdNum(data.Condition[int32(serverproto.TaskType_Level_Hard_Battle_Count)][1])
				if passNum == 1 {
					taskInfo.State = TASK_REWARD_STATE_COMPLETED
					taskInfo.Progress = []*serverproto.TaskProgressType{{Key: 102, Value: 1, State: 1}}
				}
				this.mapHardTaskList[data.TaskId] = taskInfo
				//this.loadTaskData.TaskList = append(this.loadTaskData.TaskList, taskInfo)
				this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
				ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, taskInfo)
				//util.InfoF("add task gg2:%v", taskInfo)
				count4++
			}
		}
		for _, taskInfo := range this.mapHardTaskList {
			if taskInfo.State == TASK_REWARD_STATE_COMPLETED {
				continue
			}
			convertData, ok := model.HardMissionTaskList[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)
			}
		}

		for _, taskInfo := range this.mapGroupHardTaskList {
			if taskInfo.State == TASK_REWARD_STATE_COMPLETED {
				continue
			}
			convertData, ok := model.HardGroupMissionTaskList[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)
			}
		}

		this.role.ReplayGate(ntfMsg, true)
		this.role.roleTask.SetDirty(true)
		util.InfoF("uuid:%v add start hard group taskId:%v  little taskId:%v task info:%v  group info:%v", this.role.GetUUid(), maxGroupId, maxId, this.role.roleTask.mapHardTaskList, this.role.roleTask.mapGroupHardTaskList)
		if len(ntfMsg.TaskChangeList) > 0 {
			return true
		} else {
			return false
		}
	}
	return false
}

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

	if (rewardIdx <= 0 || rewardIdx > 32) && rewardType != model.TASK_TYPE_HARD && rewardType != model.TASK_TYPE_HARD_GROUP {
		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)
	} else if rewardType == model.TASK_TYPE_HARD {
		taskInfo := this.getTaskHardData(rewardIdx)
		if taskInfo == nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		if taskInfo.State == TASK_REWARD_STATE_REWARD || taskInfo.State == TASK_REWARD_STATE_NONE {
			return serverproto.ErrorCode_ERROR_TASK_REWARDED
		}
		convertData, ok := model.HardMissionTaskList[rewardIdx]
		if !ok {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_NOT_FOUND
		}
		for _, value := range convertData.TaskReward {
			addItemList[value.Key] = value.Value
		}
		if ret := this.role.CanAddItemList(addItemList); ret != serverproto.ErrorCode_ERROR_OK {
			return ret
		}
		taskInfo.State = TASK_REWARD_STATE_REWARD
		this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
		this.SetDirty(true)
	} else if rewardType == model.TASK_TYPE_HARD_GROUP {
		taskInfo := this.getGroupTaskHardData(rewardIdx)
		if taskInfo == nil {
			return serverproto.ErrorCode_ERROR_FAIL
		}
		if taskInfo.State == TASK_REWARD_STATE_REWARD || taskInfo.State == TASK_REWARD_STATE_NONE {
			return serverproto.ErrorCode_ERROR_TASK_REWARDED
		}
		convertData, ok := model.HardGroupMissionTaskList[rewardIdx]
		if !ok {
			return serverproto.ErrorCode_ERROR_ROLE_TASK_SCORE_NOT_FOUND
		}
		//没找到这组的奖励
		if len(convertData.GroupTaskReward) == 0 {
			for _, v := range model.HardMissionTaskList {
				if v.GroupTaskId == convertData.GroupTaskId {
					if len(v.GroupTaskReward) != 0 {
						convertData.GroupTaskReward = v.GroupTaskReward
						break
					}
				}
			}
		}
		for _, value := range convertData.GroupTaskReward {
			addItemList[value.Key] = value.Value
		}
		if ret := this.role.CanAddItemList(addItemList); ret != serverproto.ErrorCode_ERROR_OK {
			return ret
		}
		taskInfo.State = TASK_REWARD_STATE_REWARD
		this.saveTaskDataList = append(this.saveTaskDataList, taskInfo)
		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,
	}
	if rewardType == model.TASK_TYPE_HARD {
		ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, this.getTaskHardData(rewardIdx))
	}
	if rewardType == model.TASK_TYPE_HARD_GROUP {
		ntfMsg.TaskChangeList = append(ntfMsg.TaskChangeList, this.getGroupTaskHardData(rewardIdx))
	}
	this.role.ReplayGate(ntfMsg, true)
	if rewardType == model.TASK_TYPE_HARD {
		this.CheckHardTaskAndDelete(rewardIdx)
	}
	if rewardType == model.TASK_TYPE_HARD_GROUP {
		this.CheckHardGroupTaskAndDelete(rewardIdx)
	}
	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
}

func (this *RoleTask) CheckHardGroupTaskAndDelete(groupTaskId uint32) {
	groupTask := this.getGroupTaskHardData(groupTaskId)
	isDelete := true
	list := make([]uint32, 0)
	for _, v := range this.mapHardTaskList {
		if v2, ok := model.HardMissionTaskList[v.TaskId]; ok {
			if v2.GroupTaskId == groupTask.TaskId {
				list = append(list, v.TaskId)
				if v.State != TASK_REWARD_STATE_REWARD {
					isDelete = false
					break
				}
			}
		}
	}
	if isDelete {
		//最后一组任务删除前新增任务
		if len(this.mapGroupHardTaskList) == 1 {
			if !this.AddHardTask() {
				return
			}

		}
		for _, v := range list {
			task := this.getTaskHardData(v)
			task.HardState = TASK_REWARD_STATE_DELETE
			this.saveTaskDataList = append(this.saveTaskDataList, task)
			delete(this.mapHardTaskList, v)
		}
		task2 := this.getGroupTaskHardData(groupTaskId)
		if task2 != nil {
			task2.HardState = TASK_REWARD_STATE_DELETE
		}
		this.saveTaskDataList = append(this.saveTaskDataList, task2)
		this.SetDirty(true)
		delete(this.mapGroupHardTaskList, groupTaskId)
		util.InfoF("uuid:%v delete groupId:%v saveTask:%v ", this.role.GetUUid(), groupTaskId, this.saveTaskDataList)
	}
}

func (this *RoleTask) CheckHardTaskAndDelete(TaskId uint32) {

	var (
		groupId     uint32
		isOver      bool
		isGroupOver bool
	)
	list := make([]uint32, 0)
	if g, ok := model.HardMissionTaskList[TaskId]; ok {
		groupId = g.GroupTaskId
	}
	if v, ok := this.mapGroupHardTaskList[groupId]; ok {
		if v.State != TASK_REWARD_STATE_REWARD {
			isGroupOver = true
		}
	}
	for _, v := range this.mapHardTaskList {
		if v2, ok := model.HardMissionTaskList[v.TaskId]; ok {
			if v2.GroupTaskId == groupId {
				list = append(list, v.TaskId)
				if v.State != TASK_REWARD_STATE_REWARD {
					isOver = true
					break
				}
			}
		}
	}
	if !isOver && !isGroupOver {
		//for _, v := range list {
		//	delete(this.mapHardTaskList, v)
		//}
		//delete(this.mapGroupHardTaskList, groupId)
		//最后一组任务不删除
		if len(this.mapGroupHardTaskList) == 1 {
			if !this.AddHardTask() {
				return
			}
		}
		for _, v := range list {
			task := this.getTaskHardData(v)
			task.HardState = TASK_REWARD_STATE_DELETE
			this.saveTaskDataList = append(this.saveTaskDataList, task)
			delete(this.mapHardTaskList, v)
		}
		task2 := this.getGroupTaskHardData(groupId)
		if task2 != nil {
			task2.HardState = TASK_REWARD_STATE_DELETE
		}
		this.saveTaskDataList = append(this.saveTaskDataList, task2)
		delete(this.mapGroupHardTaskList, groupId)
		this.SetDirty(true)
		util.InfoF("uuid:%v delete groupId2:%v hard task:%v ", this.role.GetUUid(), groupId, list)
	}
}

// 来自上一个任务的继承数值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 game 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()
	}
}