go_dreamfactory/modules/rtask/module.go

// package 随机任务
package rtask

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"
)

var _ comm.IRtask = (*ModuleRtask)(nil)

// 限定条件
type rtaskCondi struct {
	cfg    *cfg.GameRdtaskCondiData
	verify verifyHandle     //校验任务条件
	find   condiFindHandle  //检索任务条件
	update updateDataHandle //更新任务数据
}

type verifyHandle func(uid string, cfg *cfg.GameRdtaskCondiData) (error, bool)
type condiFindHandle func(cfg *cfg.GameRdtaskCondiData, vals ...int32) int32
type updateDataHandle func(uid string, cfg *cfg.GameRdtaskCondiData, vals ...int32) error

type ModuleRtask struct {
	modules.ModuleBase
	modelRtask       *ModelRtask
	modelRtaskRecord *ModelRtaskRecord
	api              *apiComp
	configure        *configureComp

	handleMap map[int32]*rtaskCondi //任务校验处理器
}

func NewModule() core.IModule {
	return &ModuleRtask{
		handleMap: make(map[int32]*rtaskCondi),
	}
}

func (this *ModuleRtask) GetType() core.M_Modules {
	return comm.ModuleRtask
}

func (this *ModuleRtask) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	err = this.ModuleBase.Init(service, module, options)
	this.initRtaskVerifyHandle()
	return
}

func (this *ModuleRtask) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelRtask = this.RegisterComp(new(ModelRtask)).(*ModelRtask)
	this.modelRtaskRecord = this.RegisterComp(new(ModelRtaskRecord)).(*ModelRtaskRecord)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
}

func (this *ModuleRtask) registerVerifyHandle(condiId int32, condi *rtaskCondi) {
	if _, ok := this.handleMap[condiId]; !ok {
		this.handleMap[condiId] = condi
	}
}

// 条件校验初始
func (this *ModuleRtask) initRtaskVerifyHandle() {
	conf, err := this.configure.getRtaskCondiCfg()
	if err != nil {
		return
	}

	for _, v := range conf.GetDataList() {
		if typeCfg, err := this.configure.getRtaskTypeById(v.Id); err == nil {
			if typeCfg != nil {
				switch comm.TaskType(typeCfg.Type) {
				case comm.Rtype1:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verfiyRtype1,
					})
				case comm.Rtype2:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verifyRtype2,
					})
				case comm.Rtype3:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verifyRtype3,
					})
				case comm.Rtype4:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verifyRtype4,
					})
				case comm.Rtype5:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verifyRtype5,
					})
				case comm.Rtype6:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verifyRtype6,
					})
				case comm.Rtype7:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verfiyRtype7,
					})
				case comm.Rtype8:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verfiyRtype8,
					})
				case comm.Rtype9:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verfiyRtype9,
					})
				case comm.Rtype10:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verfiyRtype10,
					})
				case comm.Rtype12, comm.Rtype13, comm.Rtype14, comm.Rtype15:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						find:   this.modelRtaskRecord.lessThanParams,
						verify: this.modelRtaskRecord.verifyFromDb,
						update: this.modelRtaskRecord.addUpdate,
					})
				case comm.Rtype20:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verifyRtype20,
					})
				case comm.Rtype11, comm.Rtype16, comm.Rtype17, comm.Rtype21,
					comm.Rtype22, comm.Rtype35, comm.Rtype40, comm.Rtype44,
					comm.Rtype59, comm.Rtype61, comm.Rtype70:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						find:   this.modelRtaskRecord.equalParams,
						verify: this.modelRtaskRecord.verifyFromDb,
						update: this.modelRtaskRecord.overrideUpdate,
					})
				case comm.Rtype18, comm.Rtype19, comm.Rtype23, comm.Rtype24,
					comm.Rtype25, comm.Rtype26, comm.Rtype27,
					comm.Rtype28, comm.Rtype29, comm.Rtype30, comm.Rtype31,
					comm.Rtype32, comm.Rtype33, comm.Rtype34, comm.Rtype36,
					comm.Rtype37, comm.Rtype38, comm.Rtype39, comm.Rtype41,
					comm.Rtype42, comm.Rtype43, comm.Rtype45,
					comm.Rtype46, comm.Rtype47, comm.Rtype48, comm.Rtype49,
					comm.Rtype50, comm.Rtype51, comm.Rtype52, comm.Rtype53,
					comm.Rtype54, comm.Rtype55, comm.Rtype56, comm.Rtype57,
					comm.Rtype58, comm.Rtype60, comm.Rtype62, comm.Rtype64,
					comm.Rtype65, comm.Rtype66, comm.Rtype67, comm.Rtype68, comm.Rtype69:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						find:   this.modelRtaskRecord.lessThanParams,
						verify: this.modelRtaskRecord.verifyFromDb,
						update: this.modelRtaskRecord.addUpdate,
					})
				case comm.Rtype63:
					this.registerVerifyHandle(v.Id, &rtaskCondi{
						cfg:    typeCfg,
						verify: this.modelRtask.verifyRtype63,
					})
				default:
					log.Warnf("rtaskType[%v] not register", typeCfg.Type)
				}
			}
		}
	}
}

func (this *ModuleRtask) SendToRtask(session comm.IUserSession, rtaskType comm.TaskType, params ...int32) (code pb.ErrorCode) {
	log.Debugf("Rtask params: %v", params)
	var (
		condiId int32
		condi   *rtaskCondi
	)

	user := this.ModuleUser.GetUser(session.GetUserId())
	if user == nil {
		code = pb.ErrorCode_UserSessionNobeing
		return
	}

	for _, v := range this.handleMap {
		// 找到任务类型
		if int32(rtaskType) == v.cfg.Type {
			if v.find == nil {
				break
			}
			if condiId = v.find(v.cfg, params...); condiId == 0 {
				continue
			} else {
				//数据记录方式是1
				// if v.cfg.Datatype == 1 ||
				// 	v.cfg.Datatype == 2 && this.ModuleSys.IsAccess("task", user.Lv) {
				condi = v
				// }
				break
			}
		}
	}

	if condiId == 0 {
		log.Debugf("condi not found, typeId: %v params: %v", rtaskType, params)
		code = pb.ErrorCode_RtaskCondiNoFound
		return
	}

	// update
	if condi.update != nil {
		if err := condi.update(session.GetUserId(), condi.cfg, params...); err != nil {
			code = pb.ErrorCode_DBError
		}
	}

	return
}

func (this *ModuleRtask) CheckCondi(session comm.IUserSession, condiId int32) (code pb.ErrorCode) {
	if _, ok := this.modelRtask.checkCondi(session.GetUserId(), condiId); !ok {
		code = pb.ErrorCode_RtaskCondiNoReach
	}
	return
}