go_dreamfactory/modules/task/model_task.go

package task

import (
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	cfg "go_dreamfactory/sys/configure/structs"

	"go.mongodb.org/mongo-driver/bson/primitive"
)

const ( //Redis
	TableTask core.SqlTable = "task" //每日任务表
)

type ModelTask struct {
	modules.MCompModel
	moduleTask *ModuleTask

}

func (this *ModelTask) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	err = this.MCompModel.Init(service, module, comp, options)
	this.moduleTask = module.(*ModuleTask)
	this.TableName = string(TableTask)
	return
}

//获取玩家任务列表
func (this *ModelTask) getTaskList(uid string, taskTag comm.TaskTag) (newlist []*pb.DBTask) {
	list := []*pb.DBTask{}
	if err := this.GetList(uid, &list); err != nil {
		log.Errorf("getTaskList err %v", err)
		return
	}

	for _, v := range list {
		if v.Tag == int32(taskTag) {
			newlist = append(newlist, v)
		}
	}
	return
}

func (this *ModelTask) getTaskTypeList(uid string, taskType comm.TaskType) (newlist []*pb.DBTask) {
	list := []*pb.DBTask{}
	if err := this.GetList(uid, &list); err != nil {
		log.Errorf("getTaskList err %v", err)
		return
	}

	for _, v := range list {
		if v.TypeId == int32(taskType) {
			newlist = append(newlist, v)
		}
	}
	return
}

//任务处理器注册

//初始化任务
func (this *ModelTask) initTask(uid string) error {
	if data, err := this.moduleTask.configure.getTaskList(); err == nil {
		for _, cnf := range data {
			//注册任务处理器
			
			//初始玩家任务数据
			objId := primitive.NewObjectID().Hex()
			task := &pb.DBTask{
				Id:       objId,
				Tag:      cnf.IdTag,
				Uid:      uid,
				TypeId:   cnf.TypeId,
				TaskId:   cnf.Key,
				Active:   cnf.Active,
				Progress: cnf.ConditionSecond,
			}
			if err := this.AddList(uid, task.Id, task); err != nil {
				log.Errorf("initTask addlists err %v", err)
				return err
			}
		}
	}
	return nil
}

//查询用户任务
func (this *ModelTask) getUserTask(uid string, taskId string) *pb.DBTask {
	userTask := &pb.DBTask{}
	if err := this.moduleTask.modelTask.GetListObj(uid, taskId, userTask); err != nil {
		log.Errorf("getUserTask err:%v", err)
		return nil
	}
	return userTask
}

//获取未完成的任务列表
func (this *ModelTask) getUnFinishTaskList(uid string, taskType comm.TaskType) (list []*pb.DBTask) {
	taskList := this.getTaskTypeList(uid, taskType)
	for _, v := range taskList {
		if v.Status == 0 {
			list = append(list, v)
		}
	}
	return
}

//活跃度统计
func (this *ModelTask) countActive(uid string, taskTag comm.TaskTag) (total int32) {
	taskList := this.getTaskList(uid, taskTag)
	for _, v := range taskList {
		if v.Status == 1 {
			total += v.Active
		}
	}
	return
}

//检查任务进度  返回未完成的
func (this *ModelTask) checkTaskProgress(uid string, config *cfg.Game_taskRoundData) (*pb.DBTask, bool) {
	taskList := this.getUnFinishTaskList(uid, comm.TaskType(config.TypeId))
	for _, v := range taskList {
		if config.Key == v.TaskId && v.Status == 0 {
			return v, true
		}
	}

	return nil, false
}

//更改用户任务
func (this *ModelTask) modifyUserTask(uid string, taskId string, data map[string]interface{}) error {
	if err := this.ChangeList(uid, taskId, data); err != nil {
		log.Errorf("err %v", err)
		return err
	}
	return nil
}

//任务处理
func (this *ModelTask) taskHandle(uid string, taskType comm.TaskType, taskParam *pb.TaskParam) (tasks []*pb.DBTask, err error) {
	data, err := this.moduleTask.configure.getTasks(int32(taskType))
	if err != nil {
		log.Errorf("taskHandle err %v", err)
		return nil, err
	}

	for _, conf := range data {
		if conf.RestrictiveCondition != 0 {
			//不满足限定条件
			if taskParam.First < conf.RestrictiveCondition {
				continue
			}
		}

		if taskParam.Second < conf.ConditionSecond {
			continue
		}

		//检查进度，执行处理器
		if v, ok := this.checkTaskProgress(uid, conf); ok {
			if tt, err := this.finishHandle(v, conf, taskParam.Second); err != nil {
				return nil, err
			} else {
				tasks = append(tasks, tt)
			}
		}
	}
	return tasks, nil
}

//任务完成处理
func (this *ModelTask) finishHandle(userTask *pb.DBTask, config *cfg.Game_taskRoundData, count int32) (*pb.DBTask, error) {
	var progress int32
	if count >= userTask.Progress {
		progress = 0
	}

	if progress == 0 {
		//修改玩家任务状态和进度
		update := map[string]interface{}{
			"progress": progress,
		}
		update["status"] = 1
		if err := this.modifyUserTask(userTask.Uid, userTask.Id, update); err != nil {
			log.Errorf("err %v", err)
			return nil, err
		}
		userTask.Progress = progress
		userTask.Status = 1
	}

	return userTask, nil
}

//清空任务
func (this *ModelTask) clearTask(uid string, taskTag comm.TaskTag) error {
	taskList := this.getTaskList(uid, taskTag)
	for _, v := range taskList {
		if err := this.moduleTask.modelTask.DelListlds(uid, v.Id); err != nil {
			log.Errorf("uid: %v taskTag:%v err:%v", uid, taskTag, err)
			return err
		}
	}
	return nil
}

//进入卡牌攻略
func (this *ModelTask) inStrategy(uid string, heroCfgId int32) (taskIds []int32, err error) {
	//检查此英雄攻略是否完成
	taskList := this.getTaskList(uid, comm.TASK_STRATEGY)
	allFinished := true
	for _, v := range taskList {
		conf, err := this.moduleTask.configure.getTaskById(v.TaskId)
		if err != nil {
			this.moduleTask.Errorf("get task[%v] config err %v", v.TaskId, err)
			return nil, err
		}
		if conf != nil {
			if conf.RestrictiveCondition == heroCfgId && v.Status != 1 {
				allFinished = false
				break
			}
		}
	}

	if !allFinished {
		//重置状态
		for _, v := range taskList {
			if v.Status != 0 {
				update := map[string]interface{}{
					"status": 0,
				}
				if err = this.modifyUserTask(uid, v.Id, update); err != nil {
					this.moduleTask.Errorf("doStrategy err %v", err)
					break
				}
			}
			taskIds = append(taskIds, v.TaskId)
		}
	}

	return
}