615 lines
18 KiB
Go
615 lines
18 KiB
Go
package modules
|
||
|
||
import (
|
||
"fmt"
|
||
"go_dreamfactory/comm"
|
||
"go_dreamfactory/lego/core"
|
||
"go_dreamfactory/lego/core/cbase"
|
||
"go_dreamfactory/lego/sys/log"
|
||
"go_dreamfactory/pb"
|
||
"go_dreamfactory/sys/configure"
|
||
cfg "go_dreamfactory/sys/configure/structs"
|
||
"sync"
|
||
)
|
||
|
||
const (
|
||
game_global = "game_global.json" //全局配置表
|
||
game_initial = "game_initial.json" //初始化表
|
||
game_gamecolor = "game_gamecolor.json" //颜色表
|
||
game_playerlv = "game_playerlv.json" //玩家等级
|
||
game_facemod = "game_facemod.json" //形象配置表
|
||
game_drop = "game_drop.json" //掉落
|
||
new_hero = "game_hero.json"
|
||
// 签到
|
||
game_signreset = "game_signreset.json"
|
||
game_sign = "game_sign.json"
|
||
|
||
game_item = "game_item.json"
|
||
game_vip = "game_vip.json"
|
||
|
||
game_equip = "game_equip.json" //装备信息表
|
||
|
||
game_lottery = "game_lottery.json"
|
||
)
|
||
|
||
///配置管理基础组件
|
||
type MCompConfigure struct {
|
||
cbase.ModuleCompBase
|
||
hlock sync.RWMutex
|
||
_dropMap map[int32][]*cfg.GameDropData // 掉落表 key 是DiropId
|
||
_sign map[int32]*cfg.GameSignData
|
||
|
||
_group map[int64][]int32 // key 小组ID value cid
|
||
|
||
// 类型为1 的数据 该大组中的小组为权重掉落，必定从N个小组中随机出1个小组
|
||
_lotteryType1 map[int32][]int32 // key 大组ID value cid
|
||
// 类型为2 的数据 有多个小组ID
|
||
_lotteryType2 map[int32][]int32 // key 大组ID value 小组ID
|
||
// 小组类型为1
|
||
_groupType1 map[int64][]int32 //value cid
|
||
// 小组类型为2
|
||
_groupType2 map[int64][]int32 //value cid
|
||
Btype map[int32]int32
|
||
Stype map[int64]int32 // subtype
|
||
SNum map[int64]int32 // 小组产出数量
|
||
}
|
||
|
||
//组件初始化接口
|
||
func (this *MCompConfigure) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
|
||
err = this.ModuleCompBase.Init(service, module, comp, options)
|
||
err = this.LoadConfigure(game_global, cfg.NewGameGlobal)
|
||
err = this.LoadConfigure(game_initial, cfg.NewGameInitial)
|
||
err = this.LoadConfigure(game_gamecolor, cfg.NewGameGameColor)
|
||
err = this.LoadConfigure(new_hero, cfg.NewGameHero)
|
||
err = this.LoadConfigure(game_playerlv, cfg.NewGamePlayerlv)
|
||
err = this.LoadConfigure(game_facemod, cfg.NewGameFacemod)
|
||
err = this.LoadConfigure(game_signreset, cfg.NewGameSignReset)
|
||
err = this.LoadConfigure(game_equip, cfg.NewGameEquip)
|
||
//err = this.LoadConfigure(game_sign, cfg.NewGameSign)
|
||
err = this.LoadConfigure(game_item, cfg.NewGameItem)
|
||
err = this.LoadConfigure(game_vip, cfg.NewGameVip)
|
||
err = this.LoadConfigure(game_lottery, cfg.NewGameLottery)
|
||
this._dropMap = make(map[int32][]*cfg.GameDropData, 0)
|
||
this._sign = make(map[int32]*cfg.GameSignData, 0)
|
||
configure.RegisterConfigure(game_drop, cfg.NewGameDrop, this.LoadDropData)
|
||
configure.RegisterConfigure(game_sign, cfg.NewGameSign, this.LoadSignData)
|
||
|
||
this._group = make(map[int64][]int32, 0)
|
||
this._lotteryType1 = make(map[int32][]int32, 0)
|
||
this._lotteryType2 = make(map[int32][]int32, 0)
|
||
this._groupType1 = make(map[int64][]int32, 0)
|
||
this._groupType2 = make(map[int64][]int32, 0)
|
||
this.Btype = make(map[int32]int32, 0)
|
||
this.Stype = make(map[int64]int32, 0)
|
||
this.SNum = make(map[int64]int32, 0)
|
||
configure.RegisterConfigure(game_lottery, cfg.NewGameLottery, this.LoadGroupData)
|
||
_d := this.GetGroupData(40001001, 1, 1)
|
||
fmt.Printf("%v", _d)
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) LoadGroupData() {
|
||
if v, err := this.GetConfigure(game_lottery); err == nil {
|
||
if configure, ok := v.(*cfg.GameLottery); ok {
|
||
this.hlock.Lock()
|
||
defer this.hlock.Unlock()
|
||
this._group = make(map[int64][]int32, 0)
|
||
this._lotteryType1 = make(map[int32][]int32, 0)
|
||
this._lotteryType2 = make(map[int32][]int32, 0)
|
||
this._groupType1 = make(map[int64][]int32, 0)
|
||
this._groupType2 = make(map[int64][]int32, 0)
|
||
this.Btype = make(map[int32]int32, 0)
|
||
this.Stype = make(map[int64]int32, 0)
|
||
this.SNum = make(map[int64]int32, 0)
|
||
for _, value := range configure.GetDataList() {
|
||
key := int64(value.Lotteryid)<<31 + int64(value.Groupid)
|
||
this._group[key] = append(this._group[key], value.Id)
|
||
|
||
if _, ok := this.Btype[value.Lotteryid]; !ok {
|
||
this.Btype[value.Lotteryid] = value.Type
|
||
}
|
||
|
||
if _, ok := this.Stype[key]; !ok {
|
||
this.Stype[key] = value.Subtype
|
||
}
|
||
if _, ok := this.SNum[key]; !ok {
|
||
this.SNum[key] = value.Groupnum
|
||
}
|
||
if this.Btype[value.Lotteryid] == 1 {
|
||
this._lotteryType1[value.Lotteryid] = append(this._lotteryType1[value.Lotteryid], value.Id)
|
||
} else if this.Btype[value.Lotteryid] == 2 {
|
||
this._lotteryType2[value.Lotteryid] = append(this._lotteryType2[value.Lotteryid], value.Id)
|
||
}
|
||
|
||
if this.Stype[key] == 1 { // 小组ID为1
|
||
this._groupType1[key] = append(this._groupType1[key], value.Id)
|
||
} else if this.Stype[key] == 2 {
|
||
this._groupType2[key] = append(this._groupType2[key], value.Id)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
} else {
|
||
log.Errorf("get LoadGroupData conf err:%v", err)
|
||
}
|
||
return
|
||
}
|
||
|
||
// 实际掉落逻辑 (传入 掉落组ID vip等级 玩家等级 返回获得的道具)
|
||
func (this *MCompConfigure) GetGroupData(lotterId int32, vipLv int32, lv int32) (items []*cfg.Gameatn) {
|
||
// 优先校验大组ID 的类型
|
||
if this.Btype[lotterId] == 1 { // 该大组中的小组为权重掉落，必定从N个小组中随机出1个小组
|
||
var (
|
||
szW []int32 // 权重数组
|
||
szID []int32 // 小组ID 数组
|
||
groupID int32
|
||
gourp map[int32]int32 // key 小组ID value 权重
|
||
)
|
||
|
||
gourp = make(map[int32]int32, 0)
|
||
// 随机小组id
|
||
for _, v := range this._lotteryType1[lotterId] {
|
||
if _data := this.GetLotterConfById(v); _data != nil {
|
||
if (_data.Playerlvmax == 0 || _data.Playerlvmin <= lv && lv <= _data.Playerlvmax) && (_data.VIPmax == 0 || _data.VIPmin <= vipLv && vipLv <= _data.VIPmax) { // 过滤等级等条件
|
||
if _, ok := gourp[_data.Groupid]; !ok {
|
||
gourp[_data.Groupid] = _data.Groupwt // 小组ID 权重赋值
|
||
szW = append(szW, _data.Groupwt)
|
||
szID = append(szID, _data.Groupid)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
groupID = szID[comm.GetRandW(szW)] // 获得小组ID
|
||
fmt.Printf("获得小组ID :%d", groupID)
|
||
key := int64(lotterId)<<31 + int64(groupID)
|
||
// 小组ID 类型判断
|
||
if this.Stype[key] == 1 { // 该小组的道具为权重掉落，必定从N个道具中随机出1个道具
|
||
for i := 0; i < int(this.SNum[key]); i++ {
|
||
szW = make([]int32, 0)
|
||
szID = make([]int32, 0)
|
||
gourp = make(map[int32]int32, 0)
|
||
for _, v := range this._groupType1[key] {
|
||
if _data := this.GetLotterConfById(v); _data != nil { // 权重赋值
|
||
if _, ok := gourp[_data.Groupid]; !ok {
|
||
szW = append(szW, _data.Itemwt)
|
||
szID = append(szID, _data.Id)
|
||
}
|
||
}
|
||
}
|
||
index := comm.GetRandW(szW)
|
||
_data := this.GetLotterConfById(szID[index])
|
||
fmt.Printf("获得最终的道具 :%d", _data.Id)
|
||
count := comm.GetRandNum(_data.Min, _data.Max)
|
||
// 随机获得的数量
|
||
items = append(items, &cfg.Gameatn{
|
||
A: _data.Itemid.A,
|
||
T: _data.Itemid.T,
|
||
N: _data.Itemid.N * count,
|
||
})
|
||
}
|
||
return
|
||
} else if this.Stype[key] == 2 { // 该小组中的道具为概率掉落，每个道具都会随机一次是否会掉落（单位为千分比）
|
||
for _, v := range this._groupType2[key] {
|
||
if _data := this.GetLotterConfById(v); _data != nil { // 权重赋值
|
||
if _data.Itemwt >= comm.GetRandNum(0, 1000) { // 命中
|
||
count := comm.GetRandNum(_data.Min, _data.Max)
|
||
items = append(items, &cfg.Gameatn{
|
||
A: _data.Itemid.A,
|
||
T: _data.Itemid.T,
|
||
N: _data.Itemid.N * count, // 小组产出数量
|
||
})
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
} else if this.Btype[lotterId] == 2 { // 该大组中的小组为概率掉落，每个小组都会随机一次是否会掉落（单位为千分比）
|
||
// 每个小组id 都随机取一次
|
||
var szGroupID []int32 // 获得的权重数组
|
||
gourp := make(map[int32]*cfg.GameLotteryData, 0) // key 小组ID value 权重
|
||
for _, v := range this._lotteryType2[lotterId] {
|
||
if _data := this.GetLotterConfById(v); _data != nil {
|
||
if (_data.Playerlvmax == 0 || _data.Playerlvmin <= lv && lv <= _data.Playerlvmax) && (_data.VIPmax == 0 || _data.VIPmin <= vipLv && vipLv <= _data.VIPmax) { // 过滤等级等条件
|
||
if _, ok := gourp[_data.Groupid]; !ok {
|
||
gourp[_data.Groupid] = _data // 小组ID 权重赋值
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 类型为2 可能会同时获得多个组id
|
||
for k, v := range gourp {
|
||
if v.Itemwt >= comm.GetRandNum(0, 1000) { // 命中
|
||
szGroupID = append(szGroupID, k)
|
||
key := int64(lotterId)<<31 + int64(k)
|
||
if this.Stype[key] == 1 { // 随机一组数据
|
||
for i := 0; i < int(this.SNum[key]); i++ {
|
||
szW := make([]int32, 0)
|
||
szID := make([]int32, 0)
|
||
gourp := make(map[int32]int32, 0)
|
||
for _, v := range this._groupType1[key] {
|
||
if _data := this.GetLotterConfById(v); _data != nil { // 权重赋值
|
||
if _, ok := gourp[_data.Groupid]; !ok {
|
||
szW = append(szW, _data.Itemwt)
|
||
szID = append(szID, _data.Id)
|
||
}
|
||
}
|
||
}
|
||
index := comm.GetRandW(szW)
|
||
_data := this.GetLotterConfById(szID[index])
|
||
fmt.Printf("获得最终的道具 :%d", _data.Id)
|
||
count := comm.GetRandNum(_data.Min, _data.Max)
|
||
// 随机获得的数量
|
||
items = append(items, &cfg.Gameatn{
|
||
A: _data.Itemid.A,
|
||
T: _data.Itemid.T,
|
||
N: _data.Itemid.N * count,
|
||
})
|
||
}
|
||
} else if this.Stype[key] == 2 {
|
||
for _, v := range this._groupType2[key] {
|
||
if _data := this.GetLotterConfById(v); _data != nil { // 权重赋值
|
||
if _data.Itemwt >= comm.GetRandNum(0, 1000) { // 命中
|
||
count := comm.GetRandNum(_data.Min, _data.Max)
|
||
items = append(items, &cfg.Gameatn{
|
||
A: _data.Itemid.A,
|
||
T: _data.Itemid.T,
|
||
N: _data.Itemid.N * count, // 小组产出数量
|
||
})
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) LoadConfigure(name string, fn interface{}) (err error) {
|
||
return configure.RegisterConfigure(name, fn, nil)
|
||
}
|
||
|
||
//加载一个配置文件
|
||
func (this *MCompConfigure) LoadDropData() {
|
||
if v, err := this.GetConfigure(game_drop); err == nil {
|
||
if configure, ok := v.(*cfg.GameDrop); ok {
|
||
this.hlock.Lock()
|
||
defer this.hlock.Unlock()
|
||
for _, value := range configure.GetDataList() {
|
||
|
||
if value.Condition == 0 {
|
||
this._dropMap[value.Dropid] = append(this._dropMap[value.Dropid], value)
|
||
} else {
|
||
key := value.Condition
|
||
key = value.Dropid*100 + key
|
||
this._dropMap[key] = append(this._dropMap[key], value)
|
||
for _, v1 := range this._dropMap[value.Dropid] {
|
||
this._dropMap[key] = append(this._dropMap[key], v1)
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
} else {
|
||
log.Errorf("get game_pagoda conf err:%v", err)
|
||
}
|
||
return
|
||
}
|
||
|
||
//加载多个配置文件
|
||
func (this *MCompConfigure) LoadMultiConfigure(confs map[string]interface{}) (err error) {
|
||
for k, v := range confs {
|
||
err = configure.RegisterConfigure(k, v, nil)
|
||
if err != nil {
|
||
log.Errorf("配置文件:%s解析失败!", k)
|
||
break
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
//读取配置数据
|
||
func (this *MCompConfigure) GetConfigure(name string) (v interface{}, err error) {
|
||
return configure.GetConfigure(name)
|
||
}
|
||
|
||
//全局配置
|
||
func (this *MCompConfigure) GetGlobalConf() *cfg.GameGlobalData {
|
||
var (
|
||
configure *cfg.GameGlobal
|
||
ok bool
|
||
)
|
||
if v, err := this.GetConfigure(game_global); err != nil {
|
||
log.Errorf("get global conf err:%v", err)
|
||
return nil
|
||
} else {
|
||
if configure, ok = v.(*cfg.GameGlobal); !ok {
|
||
log.Errorf("%T no is *cfg.Game_global", v)
|
||
return nil
|
||
}
|
||
}
|
||
return configure.GetDataList()[0] // 返回对象信息
|
||
}
|
||
|
||
func (this *MCompConfigure) GetGlobalInitConf() (configure *cfg.GameInitial, err error) {
|
||
var (
|
||
v interface{}
|
||
ok bool
|
||
)
|
||
if v, err = this.GetConfigure(game_initial); err == nil {
|
||
if configure, ok = v.(*cfg.GameInitial); !ok {
|
||
err = fmt.Errorf("%T no is *cfg.Game_comInitial", v)
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// 主角等级经验配置列表
|
||
func (this *MCompConfigure) GetPlayerlvConfList() (list []*cfg.GamePlayerlvData) {
|
||
if v, err := this.GetConfigure(game_playerlv); err != nil {
|
||
return
|
||
} else {
|
||
if configure, ok := v.(*cfg.GamePlayerlv); !ok {
|
||
err = fmt.Errorf("%T no is *cfg.Game_playerlv", v)
|
||
return
|
||
} else {
|
||
if configure != nil {
|
||
list = configure.GetDataList()
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// 玩家等级经验配置表
|
||
func (this *MCompConfigure) GetPlayerlvConf(lv int32) (data *cfg.GamePlayerlvData) {
|
||
if v, err := this.GetConfigure(game_playerlv); err != nil {
|
||
return
|
||
} else {
|
||
if configure, ok := v.(*cfg.GamePlayerlv); !ok {
|
||
err = fmt.Errorf("%T no is *cfg.Game_playerlv", v)
|
||
return
|
||
} else {
|
||
if configure != nil {
|
||
data = configure.GetDataMap()[lv]
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// 玩家形象预设配置
|
||
func (this *MCompConfigure) GetPlayerFigureConf() (list []*cfg.GameFacemodData) {
|
||
if v, err := this.GetConfigure(game_facemod); err != nil {
|
||
return
|
||
} else {
|
||
if configure, ok := v.(*cfg.GameFacemod); !ok {
|
||
err = fmt.Errorf("%T no is *cfg.Game_playerlv", v)
|
||
return
|
||
} else {
|
||
if configure != nil {
|
||
list = configure.GetDataList()
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) GetDropData(dropId int32) (data []*cfg.GameDropData) {
|
||
data = this._dropMap[dropId]
|
||
return
|
||
}
|
||
|
||
// todo 调用drop 表 获取掉落信息
|
||
func (this *MCompConfigure) GetMultipleDropReward(count, dropId int32, items []*pb.UserAssets) (resData []*pb.UserAssets) {
|
||
res := make([]*cfg.Gameatn, 0)
|
||
|
||
for i := 0; i < int(count); i++ {
|
||
data := this.GetDropData(dropId)
|
||
szW := make([]int32, 0)
|
||
for _, value := range data {
|
||
szW = append(szW, value.P)
|
||
}
|
||
if len(szW) > 0 {
|
||
index := comm.GetRandW(szW)
|
||
res = append(res, data[index].Prize...)
|
||
}
|
||
}
|
||
for _, v := range res {
|
||
bFind := false
|
||
for _, v1 := range items {
|
||
if v.A == v1.A && v.T == v1.T {
|
||
v1.N += v.N
|
||
bFind = true
|
||
}
|
||
}
|
||
if !bFind {
|
||
items = append(items, &pb.UserAssets{
|
||
A: v.A,
|
||
T: v.T,
|
||
N: v.N,
|
||
})
|
||
}
|
||
}
|
||
resData = append(resData, items...)
|
||
return
|
||
}
|
||
func (this *MCompConfigure) GetDropReward(dropId int32) (result []*cfg.Gameatn) {
|
||
result = make([]*cfg.Gameatn, 0)
|
||
|
||
data := this.GetDropData(dropId)
|
||
if len(data) == 0 {
|
||
return
|
||
}
|
||
szW := make([]int32, 0)
|
||
for _, value := range data {
|
||
szW = append(szW, value.P)
|
||
}
|
||
index := comm.GetRandW(szW)
|
||
result = append(result, data[index].Prize...)
|
||
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) GetColor(id int32) (item *cfg.GameGameColorData, err error) {
|
||
var (
|
||
v interface{}
|
||
ok bool
|
||
)
|
||
if v, err = this.GetConfigure(game_gamecolor); err == nil {
|
||
return
|
||
} else {
|
||
if item, ok = v.(*cfg.GameGameColor).GetDataMap()[id]; !ok {
|
||
err = fmt.Errorf("on found color:%d", id)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// 获取英雄原始星级
|
||
func (this *MCompConfigure) GetHeroConfig(heroCfgId string) *cfg.GameHeroData {
|
||
if v, err := this.GetConfigure(new_hero); err == nil {
|
||
if configure, ok := v.(*cfg.GameHero); ok {
|
||
if v, ok := configure.GetDataMap()[heroCfgId]; ok {
|
||
return v
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 获取英雄原始星级
|
||
func (this *MCompConfigure) GetHeroConfigStar(heroCfgId string) int32 {
|
||
if v, err := this.GetConfigure(new_hero); err == nil {
|
||
if configure, ok := v.(*cfg.GameHero); ok {
|
||
if v, ok := configure.GetDataMap()[heroCfgId]; ok {
|
||
return v.Star
|
||
}
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// 获取签到信息
|
||
func (this *MCompConfigure) GetSignConf(day, group int32) *cfg.GameSignData {
|
||
if v, ok := this._sign[day<<8+group]; ok {
|
||
return v
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 获取组id
|
||
func (this *MCompConfigure) GetSignResetConf(id int32) int32 {
|
||
if v, err := this.GetConfigure(game_signreset); err == nil {
|
||
if configure, ok := v.(*cfg.GameSignReset); ok {
|
||
if configure != nil {
|
||
return configure.Get(id).Groups
|
||
}
|
||
}
|
||
}
|
||
return -1
|
||
}
|
||
func (this *MCompConfigure) LoadSignData() {
|
||
if v, err := this.GetConfigure(game_sign); err == nil {
|
||
if configure, ok := v.(*cfg.GameSign); ok {
|
||
this.hlock.Lock()
|
||
defer this.hlock.Unlock()
|
||
for _, value := range configure.GetDataList() {
|
||
this._sign[value.Day<<8+value.Group] = value
|
||
}
|
||
return
|
||
}
|
||
} else {
|
||
log.Errorf("get game_sign conf err:%v", err)
|
||
}
|
||
return
|
||
}
|
||
func (this *MCompConfigure) GetHeroConfigData() (data []*cfg.GameHeroData) {
|
||
if v, err := this.GetConfigure(new_hero); err == nil {
|
||
if configure, ok := v.(*cfg.GameHero); ok {
|
||
return configure.GetDataList()
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
//读取物品配置
|
||
func (this *MCompConfigure) GetItemConfigureData(id string) (item *cfg.GameItemData, err error) {
|
||
var (
|
||
v interface{}
|
||
ok bool
|
||
)
|
||
if v, err = this.GetConfigure(game_item); err != nil {
|
||
log.Errorf("err:%v", err)
|
||
return
|
||
} else {
|
||
if item, ok = v.(*cfg.GameItem).GetDataMap()[id]; !ok {
|
||
err = fmt.Errorf("no found item:%s configure", id)
|
||
log.Errorf("err:%v", err)
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) GetVipConfigureData(lv int32) (item *cfg.GameVipData) {
|
||
|
||
if v, err := this.GetConfigure(game_vip); err == nil {
|
||
|
||
if configure, ok := v.(*cfg.GameVip); ok {
|
||
item = configure.Get(lv)
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) GetItemConfigureByType(useType int32) (item []*cfg.GameItemData) {
|
||
if v, err := this.GetConfigure(game_item); err == nil {
|
||
for _, v1 := range v.(*cfg.GameItem).GetDataMap() {
|
||
if v1.Usetype == useType {
|
||
item = append(item, v1)
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
func (this *MCompConfigure) GetEquipmentConfigureById(equipmentId string) (configure *cfg.GameEquipData) {
|
||
|
||
if v, err := this.GetConfigure(game_equip); err == nil {
|
||
configure = v.(*cfg.GameEquip).Get(equipmentId)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
func (this *MCompConfigure) GetAllItemConfigure() (item []*cfg.GameItemData) {
|
||
if v, err := this.GetConfigure(game_item); err == nil {
|
||
for _, v1 := range v.(*cfg.GameItem).GetDataMap() {
|
||
item = append(item, v1)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) GetAllEquipmentConfigure() (configure []*cfg.GameEquipData) {
|
||
|
||
if v, err := this.GetConfigure(game_equip); err == nil {
|
||
for _, v1 := range v.(*cfg.GameEquip).GetDataMap() {
|
||
configure = append(configure, v1)
|
||
}
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
func (this *MCompConfigure) GetLotterConfById(id int32) (data *cfg.GameLotteryData) {
|
||
if v, err := this.GetConfigure(game_lottery); err == nil {
|
||
if configure, ok := v.(*cfg.GameLottery); ok {
|
||
return configure.Get(id)
|
||
}
|
||
}
|
||
return
|
||
}
|