311 lines
7.3 KiB
Go
311 lines
7.3 KiB
Go
package task
|
|
|
|
import (
|
|
"go_dreamfactory/comm"
|
|
"go_dreamfactory/lego/core"
|
|
event_v2 "go_dreamfactory/lego/sys/event/v2"
|
|
"go_dreamfactory/modules"
|
|
"go_dreamfactory/pb"
|
|
"sort"
|
|
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
)
|
|
|
|
type ModelTask struct {
|
|
modules.MCompModel
|
|
moduleTask *ModuleTask
|
|
EventApp *event_v2.App
|
|
}
|
|
|
|
func (this *ModelTask) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
|
|
this.TableName = comm.TableTask
|
|
err = this.MCompModel.Init(service, module, comp, options)
|
|
this.moduleTask = module.(*ModuleTask)
|
|
this.EventApp = event_v2.NewApp()
|
|
this.EventApp.Listen(comm.EventTaskChanged, this.doTaskHandle)
|
|
return
|
|
}
|
|
|
|
//获取玩家任务列表
|
|
func (this *ModelTask) getTaskListByTag(uid string, taskTag comm.TaskTag) (newlist []*pb.DBTask) {
|
|
list := []*pb.DBTask{}
|
|
if err := this.GetList(uid, &list); err != nil {
|
|
this.moduleTask.Errorf("getTaskList err %v", err)
|
|
return
|
|
}
|
|
|
|
// 排序
|
|
sort.SliceStable(list, func(i, j int) bool {
|
|
return list[i].Sort < list[j].Sort
|
|
})
|
|
|
|
//
|
|
dr := this.moduleTask.ModuleRtask.GetCondiData(uid)
|
|
if dr == nil {
|
|
return
|
|
}
|
|
|
|
// 筛选出指定tag的任务
|
|
var taskList []*pb.DBTask
|
|
for _, v := range list {
|
|
if v.Tag == int32(taskTag) {
|
|
if p, ok := dr.Vals[v.TypeId]; ok {
|
|
if len(p.Data) > 0 {
|
|
v.Progress = p.Data[0]
|
|
}
|
|
}
|
|
taskList = append(taskList, v)
|
|
}
|
|
}
|
|
|
|
// 当前玩家任务
|
|
getCurTask := func(taskId int32) *pb.DBTask {
|
|
for _, v := range list {
|
|
if v.TaskId == taskId {
|
|
return v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 判断上个任务领取了才显示最后一个任务
|
|
isReceived := func(taskId int32) bool {
|
|
if preCnf := this.moduleTask.configure.getPreTask(taskId); preCnf != nil {
|
|
if preTask := getCurTask(preCnf.Key); preTask != nil {
|
|
if preTask.Received == 1 {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// 成就列表
|
|
if taskTag == comm.TASK_ACHIEVE {
|
|
for _, v := range taskList {
|
|
if curTask := this.moduleTask.configure.getTaskById(v.TaskId); curTask != nil {
|
|
if v.Received == 0 {
|
|
isFirst := this.moduleTask.configure.isFirstTask(curTask.Key)
|
|
if curTask.IdAfter == 0 && isFirst { //未领取和没有下个连续任务的
|
|
newlist = append(newlist, v)
|
|
continue
|
|
}
|
|
|
|
if isFirst && curTask.IdAfter != 0 { //连续任务的第一个任务
|
|
next := this.moduleTask.configure.getTaskById(curTask.IdAfter)
|
|
if next != nil && v.Received == 0 {
|
|
newlist = append(newlist, v)
|
|
}
|
|
} else {
|
|
if isReceived(curTask.Key) {
|
|
newlist = append(newlist, v)
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
newlist = taskList
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取用户任务
|
|
func (this *ModelTask) getTaskById(uid string, taskId int32) (newlist []*pb.DBTask) {
|
|
list := []*pb.DBTask{}
|
|
if err := this.GetList(uid, &list); err != nil {
|
|
this.moduleTask.Errorf("getTaskById err %v", err)
|
|
return
|
|
}
|
|
|
|
for _, v := range list {
|
|
if v.TaskId == taskId {
|
|
newlist = append(newlist, v)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//初始化任务
|
|
func (this *ModelTask) initTask(uid string, taskTag comm.TaskTag) error {
|
|
data := this.moduleTask.configure.getTaskByTag(int32(taskTag))
|
|
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,
|
|
Sort: cnf.IdList,
|
|
}
|
|
if err := this.AddList(uid, task.Id, task); err != nil {
|
|
this.moduleTask.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 {
|
|
this.moduleTask.Errorf("getUserTask err:%v", err)
|
|
return nil
|
|
}
|
|
return userTask
|
|
}
|
|
|
|
// 获取已完成的任务
|
|
func (this *ModelTask) getFinishTasks(uid string, taskTag comm.TaskTag) (list []*pb.DBTask) {
|
|
taskList := this.getTaskListByTag(uid, taskTag)
|
|
for _, v := range taskList {
|
|
if v.Status == 1 {
|
|
list = append(list, v)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取待处理的任务
|
|
func (this *ModelTask) getUnFinishTasks(uid string, taskId int32) (list []*pb.DBTask) {
|
|
taskList := this.getTaskById(uid, taskId)
|
|
for _, v := range taskList {
|
|
if v.Status == 0 {
|
|
list = append(list, v)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//检查任务状态 返回等待处理的任务
|
|
func (this *ModelTask) checkTask(uid string, taskId int32) (*pb.DBTask, bool) {
|
|
taskList := this.getUnFinishTasks(uid, taskId)
|
|
for _, v := range taskList {
|
|
if taskId == 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 {
|
|
this.moduleTask.Errorf("err %v", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//清空任务
|
|
func (this *ModelTask) clearTask(uid string, taskTag ...comm.TaskTag) {
|
|
if len(taskTag) == 0 {
|
|
this.moduleTask.Errorf("least one param for taskTag")
|
|
return
|
|
}
|
|
taskList := this.getTaskListByTag(uid, taskTag[0])
|
|
for _, v := range taskList {
|
|
if err := this.moduleTask.modelTask.DelListlds(uid, v.Id); err != nil {
|
|
this.moduleTask.Errorf("uid: %v err:%v", uid, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
//进入卡牌攻略
|
|
// Deprecated
|
|
func (this *ModelTask) inStrategy(uid string, heroCfgId int32) (taskIds []int32, err error) {
|
|
//检查此英雄攻略是否完成
|
|
taskList := this.getTaskListByTag(uid, comm.TASK_STRATEGY)
|
|
allFinished := true
|
|
for _, v := range taskList {
|
|
conf := this.moduleTask.configure.getTaskById(v.TaskId)
|
|
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
|
|
}
|
|
|
|
// 任务处理
|
|
func (this *ModelTask) doTaskHandle(event interface{}, next func(event interface{})) {
|
|
tl := event.(*TaskListen)
|
|
|
|
data, err := this.moduleTask.configure.getTasks(int32(tl.TaskType))
|
|
if err != nil {
|
|
this.moduleTask.Errorf("taskHandle err %v", err)
|
|
return
|
|
}
|
|
|
|
dr := this.moduleTask.ModuleRtask.GetCondiData(tl.Uid)
|
|
if dr == nil {
|
|
return
|
|
}
|
|
|
|
for _, conf := range data {
|
|
ret, ok := dr.Vals[conf.TypeId]
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
if task, ok := this.checkTask(tl.Uid, conf.Key); ok {
|
|
update := make(map[string]interface{})
|
|
var progress int32
|
|
if code := this.moduleTask.ModuleRtask.CheckCondi(tl.Uid, conf.TypeId); code == pb.ErrorCode_Success {
|
|
// update data
|
|
if ret != nil && len(ret.Data) > 0 {
|
|
progress = ret.Data[0]
|
|
}
|
|
update = map[string]interface{}{
|
|
"progress": progress,
|
|
"status": 1,
|
|
}
|
|
} else {
|
|
if ret != nil && len(ret.Data) > 0 {
|
|
progress = ret.Data[0]
|
|
}
|
|
update = map[string]interface{}{
|
|
"progress": progress,
|
|
}
|
|
}
|
|
if err = this.modifyUserTask(tl.Uid, task.Id, update); err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
}
|
|
return
|
|
}
|
|
|
|
type TaskListen struct {
|
|
event_v2.Event
|
|
Uid string
|
|
TaskType comm.TaskType
|
|
}
|