go_dreamfactory/modules/dragon/module.go

package dragon

import (
	"context"
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/event"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"go_dreamfactory/sys/db"

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

func NewModule() core.IModule {
	m := new(Dragon)
	return m
}

type Dragon struct {
	modules.ModuleBase
	service     core.IService
	api         *apiComp
	configure   *configureComp
	modelDragon *ModelDragon
}

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

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

// 装备组件
func (this *Dragon) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelDragon = this.RegisterComp(new(ModelDragon)).(*ModelDragon)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
}
func (this *Dragon) Start() (err error) {
	if err = this.ModuleBase.Start(); err != nil {
		return
	}
	event.RegisterGO(comm.EventUserOffline, this.EventUserOffline)
	return
}

// 获取坐骑列表
func (this *Dragon) GetDragonList(uid string) (list []*pb.DBDragon, err error) {
	return this.modelDragon.GetDragonList(uid)
}

// 创建坐骑
func (this *Dragon) CreateDragon(session comm.IUserSession, dragons map[string]int32, bPush bool) (errdata *pb.ErrorData) {
	return this.modelDragon.CreateDragon(session, dragons)
}

func (this *Dragon) CreateRobotDragon(dragonid string, lv int32) (dragon *pb.DBDragon, err error) {
	var (
		conf *cfg.GameTrainlvData
	)
	dragon = &pb.DBDragon{
		Id:       "",
		Uid:      "",
		Dragonid: dragonid,
		Lv:       lv,
		Exp:      0,
		Property: map[string]int32{},
		Play:     map[int32]*pb.PlayData{},
		Rtime:    configure.Now().Unix(),
	}

	if conf, err = this.configure.GetDragonConfById(dragonid, lv); err != nil {
		return
	}
	if c, err := this.configure.GetDragonMount(dragonid, conf.Type); err == nil {
		dragon.Property["stime"] = c.Stime
		dragon.Property["etime"] = c.Etime
		dragon.Property["hp"] = c.Hp
		dragon.Property["moderate"] = c.Moderate
		dragon.Property["sprint"] = c.Sprint
		dragon.Property["acceleration"] = c.Acceleration
		dragon.Property["deceleration"] = c.Deceleration
		dragon.Property["energyrecover"] = c.Energyrecover
		// dragon.Property["itemsprint"] = c.Itemsprint
		dragon.Property["caddtime"] = c.Caddtime
		dragon.Property["csubtime"] = c.Csubtime
	}
	return
}

func (this *Dragon) QueryBigDragonList(uid string) (dragon []*pb.DBDragon, err error) {
	var (
		list []*pb.DBDragon
	)

	if list, err = this.modelDragon.GetDragonList(uid); err != nil {
		return
	}
	for _, v := range list {
		if c, err := this.configure.GetDragonConfById(v.Dragonid, v.Lv); err == nil {
			if c.Type == 3 {
				dragon = append(dragon, v)
			}
		}
	}
	return
}

func (this *Dragon) QueryDragonById(uid string, dragonid string) (dragon *pb.DBDragon, err error) {
	var (
		list []*pb.DBDragon
	)

	if list, err = this.modelDragon.GetDragonList(uid); err != nil {
		return
	}
	for _, v := range list {
		if v.Id == dragonid {
			dragon = v
			return
		}
	}
	err = fmt.Errorf("not found dragon dragonid:%s", dragonid)
	return
}

// 通过区服id 和唯一id 查询坐骑信息
func (this *Dragon) QueryDragonByTagAndOid(tag string, objId []string) (dragon []*pb.DBDragon, err error) {
	var (
		conn   *db.DBConn
		model  *db.DBModel
		cursor *mongo.Cursor
	)
	if conn, err = db.ServerDBConn(tag); err != nil {
		return
	}
	dragon = make([]*pb.DBDragon, 0)
	model = db.NewDBModel(this.modelDragon.TableName, conn)

	result := make([]bson.M, 0)

	for _, v := range objId {
		result = append(result, bson.M{"_id": v})
	}
	if cursor, err = model.DB.Find(core.SqlTable(this.modelDragon.TableName), bson.M{"$or": result}); err != nil {
		this.Errorln(err)
		return
	}
	for cursor.Next(context.Background()) {
		temp := &pb.DBDragon{}
		if err = cursor.Decode(temp); err != nil {
			this.Errorln(err)
			continue
		}
		dragon = append(dragon, temp)
	}
	return
}

// gm 修改龙等级
func (this *Dragon) GMModifyDragonLv(uid string, cid string, lv int32) (dragon *pb.DBDragon, err error) {
	dragons, _ := this.modelDragon.GetDragonList(uid)
	for _, v := range dragons {
		if v.Dragonid == cid {
			update := make(map[string]interface{}, 0)
			v.Lv = lv
			if conf, err := this.configure.GetDragonConfById(cid, lv); err == nil {
				if c, err := this.configure.GetDragonMount(cid, conf.Type); err == nil {
					dragon.Property["stime"] = c.Stime
					dragon.Property["etime"] = c.Etime
					dragon.Property["hp"] = c.Hp
					dragon.Property["moderate"] = c.Moderate
					dragon.Property["sprint"] = c.Sprint
					dragon.Property["acceleration"] = c.Acceleration
					dragon.Property["deceleration"] = c.Deceleration
					dragon.Property["energyrecover"] = c.Energyrecover
					dragon.Property["caddtime"] = c.Caddtime
					dragon.Property["csubtime"] = c.Csubtime
					update["property"] = dragon.Property
				}
			}
			update["lv"] = lv
			this.modelDragon.UpdateDragonData(uid, v.Id, update)
			dragon = v
			return
		}

	}
	err = fmt.Errorf("not found config:%s", cid)
	return
}
func (this *Dragon) EventUserOffline(uid, sessionid string) {
	this.modelDragon.BatchDelLists(uid)
}