730 lines
20 KiB
Go
730 lines
20 KiB
Go
package wtask
|
|
|
|
import (
|
|
"fmt"
|
|
"go_dreamfactory/comm"
|
|
"go_dreamfactory/lego/core"
|
|
"go_dreamfactory/lego/sys/log"
|
|
"go_dreamfactory/modules"
|
|
"go_dreamfactory/pb"
|
|
cfg "go_dreamfactory/sys/configure/structs"
|
|
)
|
|
|
|
const modulename = "世界任务"
|
|
|
|
type WTask struct {
|
|
modules.ModuleBase
|
|
service core.IService
|
|
caravan comm.ICaravan
|
|
dailytask comm.IDailytask
|
|
battle comm.IBattle
|
|
sys comm.ISys
|
|
api *apiComp
|
|
configure *configureComp
|
|
modelwtask *ModelWTask
|
|
}
|
|
|
|
func NewModule() core.IModule {
|
|
return &WTask{}
|
|
}
|
|
|
|
func (this *WTask) GetType() core.M_Modules {
|
|
return comm.ModuleWtask
|
|
}
|
|
|
|
func (this *WTask) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
|
|
err = this.ModuleBase.Init(service, module, options)
|
|
this.service = service
|
|
return
|
|
}
|
|
|
|
func (this *WTask) Start() (err error) {
|
|
err = this.ModuleBase.Start()
|
|
var module core.IModule
|
|
if module, err = this.service.GetModule(comm.ModuleBattle); err != nil {
|
|
return
|
|
}
|
|
this.battle = module.(comm.IBattle)
|
|
if module, err = this.service.GetModule(comm.ModuleSys); err != nil {
|
|
return
|
|
}
|
|
this.sys = module.(comm.ISys)
|
|
if module, err = this.service.GetModule(comm.ModuleCaravan); err != nil {
|
|
return
|
|
}
|
|
this.caravan = module.(comm.ICaravan)
|
|
return
|
|
}
|
|
|
|
func (this *WTask) OnInstallComp() {
|
|
this.ModuleBase.OnInstallComp()
|
|
this.api = this.RegisterComp(new(apiComp)).(*apiComp)
|
|
this.modelwtask = this.RegisterComp(new(ModelWTask)).(*ModelWTask)
|
|
this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
|
|
}
|
|
|
|
// 埋点通知
|
|
func (this *WTask) BuriedsNotify(session comm.IUserSession, condis []*pb.ConIProgress) {
|
|
var (
|
|
condisMap map[int32]*pb.ConIProgress = make(map[int32]*pb.ConIProgress)
|
|
utask *pb.DBWTask
|
|
accepttaskMap map[int32]struct{} = make(map[int32]struct{})
|
|
condlTask map[int32][]*cfg.GameWorldTaskData
|
|
temptasks []*cfg.GameWorldTaskData
|
|
changetasks map[int32]*cfg.GameWorldTaskData = make(map[int32]*cfg.GameWorldTaskData)
|
|
checkcondlsMap map[int32]struct{} = make(map[int32]struct{})
|
|
checkcondls []int32 = make([]int32, 0)
|
|
detailstasks []*pb.DBWTaskItem = make([]*pb.DBWTaskItem, 0)
|
|
ok bool
|
|
needcheck bool //是否需要校验
|
|
|
|
err error
|
|
)
|
|
this.Debug("收到子任务进度变化推送", log.Field{Key: "uid", Value: session.GetUserId()}, log.Field{Key: "condis", Value: condis})
|
|
if utask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
|
|
this.Error("读取玩家世界任务数据 失败", log.Field{Key: "err", Value: err.Error()})
|
|
return
|
|
}
|
|
condlTask = this.configure.getcondlTask()
|
|
|
|
for _, v := range condis {
|
|
condisMap[v.Conid] = v
|
|
}
|
|
|
|
for _, v := range utask.Accepts {
|
|
accepttaskMap[v] = struct{}{}
|
|
}
|
|
|
|
for _, v := range condis {
|
|
if temptasks, ok = condlTask[v.Conid]; ok {
|
|
for _, task := range temptasks {
|
|
if _, ok = accepttaskMap[task.Key]; ok { //任务列表进度有变化
|
|
if _, ok = changetasks[task.Key]; !ok {
|
|
changetasks[task.Key] = task
|
|
for _, cid := range task.Completetask {
|
|
if _, ok = checkcondlsMap[cid]; !ok {
|
|
checkcondlsMap[cid] = struct{}{}
|
|
checkcondls = append(checkcondls, cid)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if len(changetasks) == 0 { //没有任务变化
|
|
return
|
|
}
|
|
for k, _ := range checkcondlsMap {
|
|
if _, ok = condisMap[k]; !ok {
|
|
needcheck = true
|
|
}
|
|
}
|
|
if needcheck { //校验有变化的任务 的完成条件
|
|
if condis, err = this.ModuleBuried.CheckCondition(session.GetUserId(), checkcondls...); err != nil {
|
|
this.Error("校验玩家子任务进度数据 失败", log.Field{Key: "err", Value: err.Error()})
|
|
return
|
|
}
|
|
for _, v := range condis {
|
|
condisMap[v.Conid] = v
|
|
}
|
|
}
|
|
|
|
//推送进度变化消息
|
|
for k, v := range changetasks {
|
|
task := &pb.DBWTaskItem{
|
|
Tid: k,
|
|
Conlds: make([]*pb.ConIProgress, len(v.Completetask)),
|
|
}
|
|
for i, v := range v.Completetask {
|
|
task.Conlds[i] = condisMap[v]
|
|
}
|
|
detailstasks = append(detailstasks, task)
|
|
}
|
|
//发送进度变化消息
|
|
session.SendMsg(string(this.GetType()), "acceptchange", &pb.WTaskAcceptChangePush{Accepts: detailstasks})
|
|
}
|
|
|
|
// 功能开启
|
|
func (this *WTask) OpenCmdNotice(uid string, keys ...string) {
|
|
var (
|
|
opencmdTask map[string][]*cfg.GameWorldTaskData
|
|
user *pb.DBUser
|
|
wtask *pb.DBWTask
|
|
err error
|
|
ok bool
|
|
)
|
|
//初步校验
|
|
opencmdTask = this.configure.getopencmdTask()
|
|
for _, key := range keys {
|
|
if _, ok = opencmdTask[key]; ok {
|
|
break
|
|
}
|
|
}
|
|
if user = this.ModuleUser.GetUser(uid); user == nil {
|
|
this.Error("获取用户信息失败!", log.Field{Key: "uid", Value: uid})
|
|
return
|
|
}
|
|
|
|
if wtask, err = this.modelwtask.getUserWTasks(uid); err != nil {
|
|
this.Error("获取世界任务数据 失败!", log.Field{Key: "uid", Value: uid}, log.Field{Key: "err", Value: err.Error()})
|
|
return
|
|
}
|
|
|
|
session, _ := this.GetUserSession(uid)
|
|
defer func() {
|
|
session.Push()
|
|
this.PutUserSession(session)
|
|
}()
|
|
this.inquireActivations(session, wtask, user.Lv, keys, true)
|
|
}
|
|
|
|
// 获取商队任务
|
|
func (this *WTask) AcceptCaravanTask(session comm.IUserSession, groupId int32) (tid, groud int32, errdata *pb.ErrorData) {
|
|
var (
|
|
alltasks []*cfg.GameWorldTaskData
|
|
grouptask []*cfg.GameWorldTaskData = make([]*cfg.GameWorldTaskData, 0)
|
|
completeMap map[int32]struct{} = make(map[int32]struct{})
|
|
target *cfg.GameWorldTaskData
|
|
wtask *pb.DBWTask
|
|
err error
|
|
ok bool
|
|
)
|
|
alltasks = this.configure.getdesTask(5)
|
|
for _, v := range alltasks {
|
|
if v.Group == groupId {
|
|
grouptask = append(grouptask, v)
|
|
}
|
|
}
|
|
|
|
if len(grouptask) == 0 {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: fmt.Sprintf("no found des:%d groud:%d tasks", 5, groupId),
|
|
}
|
|
return
|
|
}
|
|
|
|
if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
|
|
for _, v := range wtask.Completes {
|
|
completeMap[v] = struct{}{}
|
|
}
|
|
|
|
for _, v := range grouptask {
|
|
if _, ok = completeMap[v.Key]; !ok { //找到一个为完成任务
|
|
target = v
|
|
break
|
|
}
|
|
}
|
|
|
|
if target == nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: fmt.Sprintf("no found des:%d groud:%d nocomplete tasks", 5, groupId),
|
|
}
|
|
return
|
|
}
|
|
|
|
//有新任务接取
|
|
wtask.Activations = append(wtask.Activations, target.Key)
|
|
//有新任务接取
|
|
session.SendMsg(string(this.GetType()), "activationschange", &pb.WTaskActivationsChangePush{Activations: wtask.Activations})
|
|
if err = this.modelwtask.updateUserWTasks(session.GetUserId(), wtask); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
tid = target.Key
|
|
groud = target.Group
|
|
return
|
|
}
|
|
|
|
// 重置日常任务
|
|
func (this *WTask) ResetDailytaskTask(session comm.IUserSession, groupId ...int32) (results map[int32][]int32, errdata *pb.ErrorData) {
|
|
var (
|
|
alltasks map[int32]*cfg.GameWorldTaskData = make(map[int32]*cfg.GameWorldTaskData)
|
|
groupTasks map[int32][]*cfg.GameWorldTaskData
|
|
tasks []*cfg.GameWorldTaskData
|
|
wtask *pb.DBWTask
|
|
activations []int32 = make([]int32, 0)
|
|
accepts []int32 = make([]int32, 0)
|
|
completes []int32 = make([]int32, 0)
|
|
err error
|
|
ok bool
|
|
)
|
|
results = make(map[int32][]int32)
|
|
for _, v := range this.configure.getdesTask(1) {
|
|
alltasks[v.Key] = v
|
|
}
|
|
|
|
if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
//移除之前的日常任务
|
|
for _, v := range wtask.Activations {
|
|
if _, ok = alltasks[v]; !ok {
|
|
activations = append(activations, v)
|
|
}
|
|
}
|
|
for _, v := range wtask.Accepts {
|
|
if _, ok = alltasks[v]; !ok {
|
|
accepts = append(accepts, v)
|
|
}
|
|
}
|
|
for _, v := range wtask.Completes {
|
|
if _, ok = alltasks[v]; !ok {
|
|
completes = append(completes, v)
|
|
}
|
|
}
|
|
|
|
//添加新的日常任务
|
|
groupTasks = this.configure.getgroupTask()
|
|
for _, v := range groupId {
|
|
if tasks, ok = groupTasks[v]; !ok {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.String(),
|
|
Message: fmt.Sprintf("no found group:%d", v),
|
|
}
|
|
return
|
|
}
|
|
for _, task := range tasks {
|
|
if task.Ontxe == 0 {
|
|
accepts = append(accepts, task.Key)
|
|
if _, ok = results[v]; !ok {
|
|
results[v] = make([]int32, 0)
|
|
}
|
|
results[v] = append(results[v], task.Key)
|
|
}
|
|
}
|
|
|
|
}
|
|
wtask.Activations = activations
|
|
wtask.Accepts = accepts
|
|
wtask.Completes = completes
|
|
//有新任务接取
|
|
this.pushtaskprogress(session, wtask, true)
|
|
if err = this.modelwtask.updateUserWTasks(session.GetUserId(), wtask); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 查询完成列表
|
|
func (this *WTask) InquireCompletes(uid string) []int32 {
|
|
var (
|
|
wtask *pb.DBWTask
|
|
completes []int32 = make([]int32, 0)
|
|
err error
|
|
)
|
|
if wtask, err = this.modelwtask.getUserWTasks(uid); err == nil {
|
|
completes = wtask.Completes
|
|
}
|
|
return completes
|
|
}
|
|
|
|
// 查询日常任务进度
|
|
func (this *WTask) InquireTaskProgress(session comm.IUserSession, tasks ...int32) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
|
|
var (
|
|
checkcondlsMap map[int32]struct{} = make(map[int32]struct{})
|
|
checkcondls []int32 = make([]int32, 0)
|
|
conf *cfg.GameWorldTaskData
|
|
condis []*pb.ConIProgress = make([]*pb.ConIProgress, 0)
|
|
condisMap map[int32]*pb.ConIProgress = make(map[int32]*pb.ConIProgress)
|
|
err error
|
|
ok bool
|
|
)
|
|
|
|
for _, v := range tasks {
|
|
if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
|
|
this.Errorln(err)
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
for _, v := range conf.Completetask {
|
|
if _, ok = checkcondlsMap[v]; !ok {
|
|
checkcondlsMap[v] = struct{}{}
|
|
checkcondls = append(checkcondls, v)
|
|
}
|
|
}
|
|
}
|
|
if len(checkcondls) > 0 {
|
|
if condis, err = this.ModuleBuried.CheckCondition(session.GetUserId(), checkcondls...); err != nil {
|
|
this.Error("校验玩家子任务进度数据 失败", log.Field{Key: "err", Value: err.Error()})
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ExternalModule,
|
|
Title: pb.ErrorCode_ExternalModule.ToString(),
|
|
Message: fmt.Sprintf("ModuleBuried.CheckCondition Error:%s", err.Error()),
|
|
}
|
|
return
|
|
}
|
|
for _, v := range condis {
|
|
condisMap[v.Conid] = v
|
|
}
|
|
}
|
|
|
|
for _, v := range tasks {
|
|
if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
task := &pb.DBWTaskItem{
|
|
Tid: v,
|
|
Conlds: make([]*pb.ConIProgress, len(conf.Completetask)),
|
|
}
|
|
for i, v := range conf.Completetask {
|
|
task.Conlds[i] = condisMap[v]
|
|
}
|
|
progress = append(progress, task)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 清除商队任务
|
|
func (this *WTask) ClearCaravanTask(session comm.IUserSession, task int32) {
|
|
var (
|
|
wtask *pb.DBWTask
|
|
err error
|
|
change bool
|
|
)
|
|
|
|
if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
|
|
this.Errorln(err)
|
|
return
|
|
}
|
|
for i, v := range wtask.Accepts {
|
|
if v == task {
|
|
wtask.Accepts = append(wtask.Accepts[0:i], wtask.Accepts[i+1:]...)
|
|
change = true
|
|
}
|
|
}
|
|
|
|
if change {
|
|
this.pushtaskprogress(session, wtask, true)
|
|
if err = this.modelwtask.updateUserWTasks(session.GetUserId(), wtask); err != nil {
|
|
this.Errorln(err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// 跳世界任务
|
|
func (this *WTask) BingoJumpTask(session comm.IUserSession, taskId int32) (errdata *pb.ErrorData) {
|
|
var (
|
|
wtask *pb.DBWTask
|
|
accepts []int32 = make([]int32, 0)
|
|
acceptsMap map[int32]struct{} = make(map[int32]struct{})
|
|
complete []int32 = make([]int32, 0)
|
|
completeMap map[int32]struct{} = make(map[int32]struct{})
|
|
conf *cfg.GameWorldTaskData
|
|
update map[string]interface{} = make(map[string]interface{})
|
|
ok bool
|
|
err error
|
|
)
|
|
if conf, err = this.configure.gettaskconfconfigure(taskId); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
|
|
if wtask, err = this.modelwtask.getUserWTasks(session.GetUserId()); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
for _, v := range wtask.Accepts {
|
|
acceptsMap[v] = struct{}{}
|
|
}
|
|
for _, v := range wtask.Completes {
|
|
completeMap[v] = struct{}{}
|
|
}
|
|
ok = false
|
|
for _, v := range wtask.Activations {
|
|
if taskId == v {
|
|
ok = true
|
|
}
|
|
}
|
|
|
|
if ok {
|
|
return
|
|
}
|
|
|
|
for {
|
|
if conf.Ontxe != 0 {
|
|
if _, ok = completeMap[conf.Ontxe]; !ok {
|
|
completeMap[conf.Ontxe] = struct{}{}
|
|
if _, ok = acceptsMap[conf.Ontxe]; ok {
|
|
delete(acceptsMap, conf.Ontxe)
|
|
}
|
|
}
|
|
if conf, err = this.configure.gettaskconfconfigure(conf.Ontxe); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
for k, _ := range acceptsMap {
|
|
accepts = append(accepts, k)
|
|
}
|
|
for k, _ := range completeMap {
|
|
complete = append(complete, k)
|
|
}
|
|
|
|
wtask.Activations = append(wtask.Activations, taskId)
|
|
wtask.Accepts = accepts
|
|
wtask.Completes = complete
|
|
update["activations"] = wtask.Activations
|
|
update["accepts"] = wtask.Accepts
|
|
update["completes"] = wtask.Completes
|
|
|
|
if err = this.modelwtask.Change(session.GetUserId(), update); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_DBError,
|
|
Title: pb.ErrorCode_DBError.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
session.SendMsg(string(this.GetType()), "activationschange", &pb.WTaskActivationsChangePush{Activations: wtask.Activations})
|
|
return
|
|
}
|
|
|
|
// 校验任务进度
|
|
func (this *WTask) pushtaskprogress(session comm.IUserSession, wtask *pb.DBWTask, ispush bool) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
|
|
var (
|
|
checkcondlsMap map[int32]struct{} = make(map[int32]struct{})
|
|
checkcondls []int32 = make([]int32, 0)
|
|
conf *cfg.GameWorldTaskData
|
|
condis []*pb.ConIProgress = make([]*pb.ConIProgress, 0)
|
|
condisMap map[int32]*pb.ConIProgress = make(map[int32]*pb.ConIProgress)
|
|
err error
|
|
ok bool
|
|
)
|
|
progress = make([]*pb.DBWTaskItem, 0)
|
|
if len(wtask.Accepts) == 0 {
|
|
return
|
|
}
|
|
|
|
for _, v := range wtask.Accepts {
|
|
if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
|
|
this.Errorln(err)
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
for _, v := range conf.Completetask {
|
|
if _, ok = checkcondlsMap[v]; !ok {
|
|
checkcondlsMap[v] = struct{}{}
|
|
checkcondls = append(checkcondls, v)
|
|
}
|
|
}
|
|
}
|
|
if len(checkcondls) > 0 {
|
|
if condis, err = this.ModuleBuried.CheckCondition(session.GetUserId(), checkcondls...); err != nil {
|
|
this.Error("校验玩家子任务进度数据 失败", log.Field{Key: "err", Value: err.Error()})
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ExternalModule,
|
|
Title: pb.ErrorCode_ExternalModule.ToString(),
|
|
Message: fmt.Sprintf("ModuleBuried.CheckCondition Error:%s", err.Error()),
|
|
}
|
|
return
|
|
}
|
|
for _, v := range condis {
|
|
condisMap[v.Conid] = v
|
|
}
|
|
}
|
|
|
|
for _, v := range wtask.Accepts {
|
|
if conf, err = this.configure.gettaskconfconfigure(v); err != nil {
|
|
errdata = &pb.ErrorData{
|
|
Code: pb.ErrorCode_ConfigNoFound,
|
|
Title: pb.ErrorCode_ConfigNoFound.ToString(),
|
|
Message: err.Error(),
|
|
}
|
|
return
|
|
}
|
|
task := &pb.DBWTaskItem{
|
|
Tid: v,
|
|
Conlds: make([]*pb.ConIProgress, len(conf.Completetask)),
|
|
}
|
|
ok = true
|
|
for i, v := range conf.Completetask {
|
|
task.Conlds[i] = condisMap[v]
|
|
}
|
|
progress = append(progress, task)
|
|
}
|
|
if ispush {
|
|
session.SendMsg(string(this.GetType()), "acceptchange", &pb.WTaskAcceptChangePush{Accepts: progress})
|
|
}
|
|
return
|
|
}
|
|
|
|
// 完成任务
|
|
func (this *WTask) fishtask(session comm.IUserSession, wtask *pb.DBWTask, ispush bool) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
|
|
var (
|
|
opencmdMap map[string]int32
|
|
opencmd []string
|
|
user *pb.DBUser
|
|
)
|
|
|
|
if opencmdMap, errdata = this.sys.QueryOpenCondData(session.GetUserId()); errdata != nil {
|
|
this.Error("查询用户功能是否开启表 失败!", log.Field{Key: "key", Value: errdata})
|
|
return
|
|
}
|
|
opencmd = make([]string, 0)
|
|
for k, v := range opencmdMap {
|
|
if v == 2 {
|
|
opencmd = append(opencmd, k)
|
|
}
|
|
}
|
|
if user = this.ModuleUser.GetUser(session.GetUserId()); user == nil {
|
|
this.Error("获取用户信息失败!", log.Field{Key: "uid", Value: session.GetUserId()})
|
|
return
|
|
}
|
|
progress, errdata = this.inquireActivations(session, wtask, user.Lv, opencmd, ispush)
|
|
return
|
|
}
|
|
|
|
// 校验组进度变化
|
|
func (this *WTask) checkgroupState(session comm.IUserSession, wtask *pb.DBWTask, group int32) {
|
|
var (
|
|
groupTask map[int32][]*cfg.GameWorldTaskData
|
|
completeMap map[int32]struct{} = make(map[int32]struct{})
|
|
des int32
|
|
ok bool
|
|
)
|
|
groupTask = this.configure.getgroupTask()
|
|
for _, v := range wtask.Completes {
|
|
completeMap[v] = struct{}{}
|
|
}
|
|
for _, v := range groupTask[group] {
|
|
if _, ok = completeMap[v.Key]; !ok {
|
|
return
|
|
}
|
|
des = v.Des
|
|
}
|
|
wtask.Groups[group] = 1
|
|
if des == 5 { //商队任务
|
|
this.caravan.TaskGroupComplete(session, group)
|
|
} else if des == 1 { //日常任务
|
|
this.dailytask.TaskGroupComplete(session, group)
|
|
}
|
|
}
|
|
|
|
// 查询可接取任务列表
|
|
func (this *WTask) inquireActivations(session comm.IUserSession, wtask *pb.DBWTask, lv int32, opencmd []string, ispush bool) (progress []*pb.DBWTaskItem, errdata *pb.ErrorData) {
|
|
var (
|
|
conf *cfg.GameWorldTask
|
|
err error
|
|
activatMap map[int32]struct{} = make(map[int32]struct{})
|
|
acceptsMap map[int32]struct{} = make(map[int32]struct{})
|
|
completeMap map[int32]struct{} = make(map[int32]struct{})
|
|
opencmdMap map[string]struct{} = make(map[string]struct{})
|
|
ok bool
|
|
changeActiva bool
|
|
changeAccept bool
|
|
)
|
|
if conf, err = this.configure.getWorldtaskCfg(); err != nil {
|
|
return
|
|
}
|
|
for _, v := range wtask.Activations {
|
|
activatMap[v] = struct{}{}
|
|
}
|
|
for _, v := range wtask.Accepts {
|
|
acceptsMap[v] = struct{}{}
|
|
}
|
|
for _, v := range wtask.Completes {
|
|
completeMap[v] = struct{}{}
|
|
}
|
|
for _, v := range opencmd {
|
|
opencmdMap[v] = struct{}{}
|
|
}
|
|
for _, v := range conf.GetDataList() {
|
|
if _, ok = activatMap[v.Key]; ok { //已在可接取列表中
|
|
continue
|
|
}
|
|
if _, ok = acceptsMap[v.Key]; v.LockAdd == 0 && ok { //已在已接取任务列表中 LockAdd 0 表示只能接取一次 1 表示可以重复接取
|
|
continue
|
|
}
|
|
if _, ok = completeMap[v.Key]; ok { //已在完成列表中
|
|
continue
|
|
}
|
|
if lv < v.Lock || lv > v.Lockend { //等级不符合
|
|
continue
|
|
}
|
|
if _, ok = opencmdMap[v.Opencond]; v.Opencond != "" && !ok { //功能未开启
|
|
continue
|
|
}
|
|
if _, ok = completeMap[v.Ontxe]; v.Ontxe != 0 && !ok { //前置任务判断
|
|
continue
|
|
}
|
|
if v.Des == 5 || v.Des == 1 { //商队任务不主动触发 日常任务直接接取不进入可接取列表中
|
|
continue
|
|
}
|
|
wtask.Activations = append(wtask.Activations, v.Key)
|
|
changeActiva = true
|
|
if v.Des == 2 { //主线任务
|
|
wtask.Currchapter = v.Group
|
|
}
|
|
if _, ok = wtask.Groups[v.Group]; !ok {
|
|
wtask.Groups[v.Group] = 0
|
|
}
|
|
}
|
|
|
|
//有新任务接取
|
|
if ispush && changeActiva {
|
|
session.SendMsg(string(this.GetType()), "activationschange", &pb.WTaskActivationsChangePush{Activations: wtask.Activations})
|
|
}
|
|
|
|
if changeAccept {
|
|
progress, errdata = this.pushtaskprogress(session, wtask, ispush)
|
|
}
|
|
return
|
|
}
|