go_dreamfactory/modules/combat/module.go

package combat

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

	"go_dreamfactory/lego/sys/log"
)

/*
模块名:关卡编辑器
描述:新手训练营
开发:李伟
*/
func NewModule() core.IModule {
	m := new(Combat)
	return m
}

type Combat struct {
	modules.ModuleBase
	service     base.IRPCXService
	battle      comm.IBattle
	api_comp    *apiComp
	configure   *configureComp
	modelCombat *modelCombatComp
}

// 模块名
func (this *Combat) GetType() core.M_Modules {
	return comm.ModuleCombat
}

// 模块初始化接口 注册用户创建角色事件
func (this *Combat) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	err = this.ModuleBase.Init(service, module, options)
	this.service = service.(base.IRPCXService)
	return
}

func (this *Combat) 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)
	event.RegisterGO(comm.EventUserOffline, this.EventUserOffline)
	return
}

// 装备组件
func (this *Combat) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api_comp = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelCombat = this.RegisterComp(new(modelCombatComp)).(*modelCombatComp)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
}

// Event------------------------------------------------------------------------------------------------------------
func (this *Combat) EventUserOffline(uid, sessionid string) {
	this.modelCombat.delInfo(uid)
}

func (this *Combat) GetLevels(uid string) (levels map[int32]*pb.DBCombatLevel) {
	combat := &pb.DBCombatUser{}
	levels = make(map[int32]*pb.DBCombatLevel)
	if err := this.modelCombat.Get(uid, combat); err != nil {
		return
	}
	levels = combat.Level
	return
}

//任务埋点通知
func (this *Combat) BuriedsNotify(uid string, condis []*pb.ConIProgress) {
	this.Debug("收到埋点中心 进度改变通知", log.Field{Key: "uid", Value: uid}, log.Field{Key: "condis", Value: condis})
	//废弃 采用主动询问机制
	return

	var (
		err      error
		session  comm.IUserSession
		online   bool
		info     *pb.DBCombatUser
		lvconf   *cfg.GameCombatLevelData
		progress []*pb.LevelProgressItem
		pitem    *pb.LevelProgressItem
		ok       bool
		pass     bool
	)
	session, online = this.GetUserSession(uid)
	defer func() {
		if online {
			session.Push()
		}
		this.PutUserSession(session)
	}()
	if info, err = this.modelCombat.queryInfo(uid); err != nil {
		return
	}
	progress = make([]*pb.LevelProgressItem, 0)
	for _, l := range info.Level {
		l.Progress = 0
		pitem = &pb.LevelProgressItem{
			Level:        l.Id,
			Passmaintask: l.Passmaintask,
			Passpertask:  l.Passpertask,
			Progress:     l.Progress,
			Pass:         l.Pass,
			Mainaward:    make([]*pb.UserAssets, 0),
			Peraward:     make([]*pb.UserAssets, 0),
		}
		if l.Pass != 2 {
			ok = false
			pass = true
			for _, v := range l.Passmaintask {
				for _, v1 := range condis {
					if v.Conid == v1.Conid {
						ok = true
						v.Value = v1.Value
						v.State = v1.State
					}
				}
				l.Progress += v.Value
				if v.State != 1 {
					pass = false
				}
			}

			if l.Pass == 0 && pass { //基础通关达成
				l.Pass = 1
				pitem.Pass = l.Pass
				if lvconf, err = this.configure.getCombatLevel(l.Id); err != nil {
					this.Error("BuriedsNotify 执行错误!", log.Field{Key: "err", Value: err.Error()})
					return
				}
				this.DispenseRes(session, lvconf.Award, true)
				atns := make([]*pb.UserAssets, len(lvconf.Award))
				for i, v := range lvconf.Award {
					atns[i] = &pb.UserAssets{
						A: v.A,
						T: v.T,
						N: v.N,
					}
				}
				pitem.Mainaward = atns

			}
			pass = true
			for _, v := range l.Passpertask {
				for _, v1 := range condis {
					if v.Conid == v1.Conid {
						ok = true
						v.Value = v1.Value
						v.State = v1.State
					}
				}
				l.Progress += v.Value
				if v.State != 1 {
					pass = false
				}
			}

			if l.Pass == 1 && pass { //完美通关完成
				l.Pass = 2
				pitem.Pass = l.Pass
				if lvconf, err = this.configure.getCombatLevel(l.Id); err != nil {
					this.Error("BuriedsNotify 执行错误!", log.Field{Key: "err", Value: err.Error()})
					return
				}
				this.DispenseRes(session, lvconf.Profectaward, true)
				atns := make([]*pb.UserAssets, len(lvconf.Profectaward))
				for i, v := range lvconf.Profectaward {
					atns[i] = &pb.UserAssets{
						A: v.A,
						T: v.T,
						N: v.N,
					}
				}
				pitem.Peraward = atns
			}
			pitem.Progress = l.Progress
			if ok {
				progress = append(progress, pitem)
			}
		}
	}

	if len(progress) > 0 {
		session.SendMsg(string(this.GetType()), "progress", &pb.CombatProgressPush{Levels: progress})
	}

}