go_dreamfactory/modules/equipment/model_equipment_comp.go

package equipment

import (
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	cfg "go_dreamfactory/sys/configure/structs"
	"math/rand"
	"time"

	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/x/bsonx"
)

///装备 数据组件
type Model_Equipment_Comp struct {
	modules.Model_Comp
	module *Equipment
}

//组件初始化接口
func (this *Model_Equipment_Comp) Init(service core.IService, module core.IModule, comp core.IModuleComp, opt core.IModuleOptions) (err error) {
	this.Model_Comp.Init(service, module, comp, opt)
	this.module = module.(*Equipment)
	this.TableName = "equipment"
	//创建uid索引
	this.DB.CreateIndex(core.SqlTable(this.TableName), mongo.IndexModel{
		Keys: bsonx.Doc{{Key: "uid", Value: bsonx.Int32(1)}},
	})
	return
}

//查询用户装备数据
func (this *Model_Equipment_Comp) Equipment_QueryUserEquipmentsPackById(uId, id string) (equipment *pb.DB_Equipment, err error) {
	equipment = &pb.DB_Equipment{}
	err = this.GetListObj(uId, id, equipment)
	return
}

///查询用户的武器背包
func (this *Model_Equipment_Comp) Equipment_QueryUserEquipmentsPack(uId string) (equipments []*pb.DB_Equipment, err error) {
	equipments = make([]*pb.DB_Equipment, 0)
	err = this.GetList(uId, &equipments)
	return
}

//添加装备
func (this *Model_Equipment_Comp) Equipment_AddEquipmentsToPack(uId string, cIds map[int32]uint32) (err error) {
	var (
		configure  *cfg.Game_equip
		equipments []*pb.DB_Equipment
		iskeep     bool
		add        map[string]*pb.DB_Equipment
		update     map[string]*pb.DB_Equipment
	)
	if configure, err = this.module.configure_comp.GetEquipmentConfigure(); err != nil {
		return
	}
	if equipments, err = this.Equipment_QueryUserEquipmentsPack(uId); err != nil {
		return
	}
	add = make(map[string]*pb.DB_Equipment)
	update = make(map[string]*pb.DB_Equipment)
	for k, v := range cIds {
		iskeep = false
		for _, equipment := range equipments {
			if equipment.CId == k && equipment.IsInitialState {
				update[equipment.Id] = equipment
				equipment.OverlayNum += v
				iskeep = true
				break
			}
		}
		if !iskeep {
			if c, ok := configure.GetDataMap()[k]; ok {
				if equipment, err := this.newEquipment(uId, c, v); err != nil {
					return err
				} else {
					add[equipment.Id] = equipment
				}
			}
		}
	}
	if err = this.AddLists(uId, add); err != nil {
		log.Errorf("[Equipment] Equipment_AddEquipmentsToPack err:%v", err)
		return
	}
	for _, v := range update {
		if err = this.ChangeList(uId, v.Id, map[string]interface{}{"overlayNum": v.OverlayNum}); err != nil {
			log.Errorf("[Equipment] Equipment_AddEquipmentsToPack err:%v", err)
			return
		}
	}
	return
}

func (this *Model_Equipment_Comp) Equipment_UpdateIsEquip(uid string, equipments ...*pb.DB_Equipment) (err error) {
	for _, v := range equipments {
		if err = this.ChangeList(uid, v.Id, map[string]interface{}{
			"heroId": v.HeroId,
		}); err != nil {
			log.Errorf("Equipment_UpdateIsEquip err:%v", err)
			return
		}
	}
	return
}

//创建新的武器对象
func (this *Model_Equipment_Comp) newEquipment(uid string, conf *cfg.Game_equipData, num uint32) (equipment *pb.DB_Equipment, err error) {
	var (
		mattr     []*cfg.Game_equipAttrlibraryData
		sattr     []*cfg.Game_equipAttrlibraryData
		total     int
		satterNum int32
	)
	equipment = &pb.DB_Equipment{
		Id:             primitive.NewObjectID().Hex(),
		CId:            conf.Id,
		UId:            uid,
		OverlayNum:     num,
		IsInitialState: true,
		AdverbEntry:    make([]*pb.EquipmentAttributeEntry, 4),
	}
	if mattr, err = this.module.configure_comp.GetEquipmentAttrlibraryConfigureById(conf.Leadlibrary); err != nil || len(mattr) == 0 {
		return
	}
	equipment.MainEntry = &pb.EquipmentAttributeEntry{
		Id:        mattr[0].Key,
		Libraryid: mattr[0].Libraryid,
		Lv:        0,
		AttrName:  mattr[0].Attr[0],
		Value:     0,
	}
	if sattr, err = this.module.configure_comp.GetEquipmentAttrlibraryConfigureById(conf.Addlibrary); err != nil || len(mattr) == 0 {
		return
	}

	for _, v := range conf.Addattrnump {
		total += int(v)
	}
	n := rand.Intn(total)
	for i, v := range conf.Addattrnump {
		if int32(n) <= v {
			satterNum = conf.Addattrnum[i]
			break
		}
	}
	if satterNum > 0 {
		r := rand.New(rand.NewSource(time.Now().Unix()))
		for i, v := range r.Perm(len(sattr))[:satterNum] {
			equipment.AdverbEntry[i] = &pb.EquipmentAttributeEntry{
				Id:        sattr[v].Key,
				Libraryid: sattr[v].Libraryid,
				Lv:        0,
				AttrName:  sattr[v].Attr[0],
				Value:     0,
			}
		}
	}

	return
}