582 lines
16 KiB
Go
582 lines
16 KiB
Go
package hero
|
|
|
|
import (
|
|
"fmt"
|
|
"go_dreamfactory/comm"
|
|
"go_dreamfactory/modules"
|
|
"go_dreamfactory/pb"
|
|
"go_dreamfactory/sys/configure"
|
|
cfg "go_dreamfactory/sys/configure/structs"
|
|
"sync"
|
|
|
|
"go_dreamfactory/lego/core"
|
|
"go_dreamfactory/utils"
|
|
)
|
|
|
|
const moduleName = "hero"
|
|
const (
|
|
equip_suit = "game_equipsuit.json" //装备套装表
|
|
new_hero = "game_hero.json" //英雄
|
|
hero_stargrow = "game_herostargrow.json" //英雄品质系数
|
|
hero_levelgrow = "game_herolevelgrow.json" //英雄成长系数
|
|
hero_starup = "game_herostarup.json" // 升星
|
|
hero_levelup = "game_herolevelup.json" //英雄等级基础属性
|
|
hero_exp = "game_heroexp.json" // 升级
|
|
hero_skillup = "game_heroskilllevel.json" // 英雄技能升级
|
|
game_skillatk = "game_skillatk.json" // 英雄技能
|
|
hero_awaken = "game_heroawaken.json" // 英雄觉醒
|
|
//hero_drawcard = "game_drawcard.json" // 抽卡
|
|
hero_drawupdraw = "game_drawupdraw.json" // 抽卡概率调整
|
|
hero_drawcost = "game_drawcost.json" // 抽卡消耗
|
|
hero_fusion = "game_herofusion.json" // 卡牌融合
|
|
hero_talent = "game_herotalent.json" // 天赋详细数据
|
|
hero_talentbox = "game_talentbox.json" // 天赋详细数据
|
|
game_shopitem = "game_shopitem.json"
|
|
hero_skill = "game_heroskill.json"
|
|
|
|
hero_draw = "game_drawpool.json" // 新版抽卡
|
|
hero_cardweight = "game_drawweight.json" // 新版抽卡权重
|
|
hero_cardpool = "game_cardpool.json" // 新版卡池
|
|
|
|
// 限定招募和许愿招募
|
|
draw_replace = "game_drawreplace.json" // 设置5星英雄
|
|
draw_reward = "game_drawreward.json" //新手招募奖励
|
|
)
|
|
|
|
type CondData struct {
|
|
cd int32
|
|
num int32
|
|
buyCos *cfg.Gameatn
|
|
}
|
|
type Replace struct {
|
|
InitHero string // 默认英雄
|
|
Cond map[string]*CondData // 条件
|
|
}
|
|
|
|
// /配置管理组件
|
|
type configureComp struct {
|
|
modules.MCompConfigure
|
|
hlock sync.RWMutex
|
|
//drawCardCfg map[string]map[int32][]*cfg.GameDrawCardData // 第一个key 卡池id 第二个key 星级
|
|
awakenMap map[int64]*cfg.GameHeroAwakenData
|
|
starMap map[int64]*cfg.GameHeroStarupData
|
|
module *Hero
|
|
starW map[int64]int32
|
|
cardPool map[string][]*cfg.GameCardPoolData
|
|
|
|
// 限定英雄
|
|
wish *Replace // 许愿英雄招募
|
|
appoint *Replace // 限定英雄招募
|
|
}
|
|
|
|
// 组件初始化接口
|
|
func (this *configureComp) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
|
|
|
|
err = this.MCompConfigure.Init(service, module, comp, options)
|
|
this.module = module.(*Hero)
|
|
err = this.LoadMultiConfigure(map[string]interface{}{
|
|
equip_suit: cfg.NewGameEquipSuit,
|
|
new_hero: cfg.NewGameHero,
|
|
hero_stargrow: cfg.NewGameHeroStargrow,
|
|
hero_levelgrow: cfg.NewGameHeroLevelgrow,
|
|
hero_levelup: cfg.NewGameHeroLevelup,
|
|
hero_exp: cfg.NewGameHeroExp,
|
|
hero_skillup: cfg.NewGameHeroSkillLevel,
|
|
game_skillatk: cfg.NewGameSkillAtk,
|
|
//hero_drawcard: cfg.NewGameDrawCard,
|
|
hero_talent: cfg.NewGameHeroTalent,
|
|
hero_talentbox: cfg.NewGameTalentBox,
|
|
game_shopitem: cfg.NewGameShopitem,
|
|
hero_skill: cfg.NewGameHeroSkill,
|
|
hero_draw: cfg.NewGameDrawPool,
|
|
draw_reward: cfg.NewGamedrawReward,
|
|
//hero_cardweight: cfg.NewGameDrawWeight,
|
|
})
|
|
//this.drawCardCfg = make(map[string]map[int32][]*cfg.GameDrawCardData, 0)
|
|
//configure.RegisterConfigure(hero_drawcard, cfg.NewGameDrawCard, this.SetHeroDrawConfig)
|
|
this.awakenMap = make(map[int64]*cfg.GameHeroAwakenData, 0)
|
|
configure.RegisterConfigure(hero_awaken, cfg.NewGameHeroAwaken, func() {
|
|
if v, err := this.GetConfigure(hero_awaken); err == nil {
|
|
this.hlock.Lock()
|
|
defer this.hlock.Unlock()
|
|
if _configure, ok := v.(*cfg.GameHeroAwaken); ok {
|
|
for _, v := range _configure.GetDataList() {
|
|
this.awakenMap[utils.ToInt64(v.Hid)+int64(v.Phase)<<31] = v
|
|
}
|
|
return
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("%T no is *cfg.GameHeroAwaken", v)
|
|
}
|
|
})
|
|
|
|
// 升星
|
|
this.starMap = make(map[int64]*cfg.GameHeroStarupData, 0)
|
|
configure.RegisterConfigure(hero_starup, cfg.NewGameHeroStarup, func() {
|
|
if v, err := this.GetConfigure(hero_starup); err == nil {
|
|
if _configure, ok := v.(*cfg.GameHeroStarup); ok {
|
|
this.hlock.Lock()
|
|
defer this.hlock.Unlock()
|
|
for _, v := range _configure.GetDataList() {
|
|
key := utils.ToInt64(v.Id)
|
|
key += int64(v.Star) << 31
|
|
this.starMap[key] = v
|
|
}
|
|
|
|
return
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("%T no is *cfg.Game_drawCard", v)
|
|
}
|
|
})
|
|
configure.RegisterConfigure(hero_cardweight, cfg.NewGameDrawWeight, func() {
|
|
if v, err := this.GetConfigure(hero_cardweight); err == nil {
|
|
if _configure, ok := v.(*cfg.GameDrawWeight); ok {
|
|
this.hlock.Lock()
|
|
defer this.hlock.Unlock()
|
|
this.starW = make(map[int64]int32)
|
|
for _, v := range _configure.GetDataList() {
|
|
this.starW[(int64(v.Dtype)<<16)+int64(v.Key)] = v.Weight
|
|
}
|
|
|
|
return
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("%T no is *cfg.NewGameDrawWeight", v)
|
|
}
|
|
})
|
|
|
|
// 卡池初始化
|
|
configure.RegisterConfigure(hero_cardpool, cfg.NewGameCardPool, func() {
|
|
if v, err := this.GetConfigure(hero_cardpool); err == nil {
|
|
if _configure, ok := v.(*cfg.GameCardPool); ok {
|
|
this.hlock.Lock()
|
|
defer this.hlock.Unlock()
|
|
this.cardPool = make(map[string][]*cfg.GameCardPoolData)
|
|
for _, v := range _configure.GetDataList() {
|
|
this.cardPool[v.CardPoolType] = append(this.cardPool[v.CardPoolType], v)
|
|
}
|
|
|
|
return
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("%T no is *cfg.NewGameCardPool", v)
|
|
}
|
|
})
|
|
//可选卡池初始化
|
|
configure.RegisterConfigure(draw_replace, cfg.NewGamedrawReplace, func() {
|
|
if v, err := this.GetConfigure(draw_replace); err == nil {
|
|
if _configure, ok := v.(*cfg.GamedrawReplace); ok {
|
|
this.hlock.Lock()
|
|
defer this.hlock.Unlock()
|
|
this.appoint = &Replace{}
|
|
this.wish = &Replace{}
|
|
this.appoint.Cond = make(map[string]*CondData)
|
|
this.wish.Cond = make(map[string]*CondData)
|
|
for _, v := range _configure.GetDataList() {
|
|
if v.Pool == 1 {
|
|
this.appoint.InitHero = v.HeroInitial
|
|
this.appoint.Cond[v.HeroReplace] = &CondData{
|
|
cd: v.ReplaceCd,
|
|
num: v.ReplaceNum,
|
|
buyCos: v.BuyCos,
|
|
}
|
|
} else if v.Pool == 2 {
|
|
this.wish.InitHero = v.HeroInitial
|
|
this.wish.Cond[v.HeroReplace] = &CondData{
|
|
cd: v.ReplaceCd,
|
|
num: v.ReplaceNum,
|
|
buyCos: v.BuyCos,
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
} else {
|
|
err = fmt.Errorf("%T no is *cfg.NewGamedrawReplace", v)
|
|
}
|
|
})
|
|
|
|
return
|
|
}
|
|
func (this *configureComp) GetApportHeroReplaceConfig() *Replace {
|
|
return this.appoint
|
|
}
|
|
func (this *configureComp) GetWishHeroReplaceConfig() *Replace {
|
|
return this.wish
|
|
}
|
|
|
|
// 获取英雄升星相关配置数据
|
|
func (this *configureComp) GetHeroStarupConfig(hid string, star int32) (conf *cfg.GameHeroStarupData, err error) {
|
|
var (
|
|
ok bool
|
|
par interface{}
|
|
)
|
|
this.hlock.RLock()
|
|
defer this.hlock.RUnlock()
|
|
if conf, ok = this.starMap[utils.ToInt64(hid)+int64(star)<<31]; !ok {
|
|
par = fmt.Errorf("hid:%s,phase:%d", hid, star)
|
|
err = comm.NewNotFoundConfErr("hero", hero_starup, par)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取当前英雄最高星级
|
|
func (this *configureComp) GetHeroMaxStar(hid string, curStar int32) int32 {
|
|
var star int32
|
|
this.hlock.RLock()
|
|
defer this.hlock.RUnlock()
|
|
for star = curStar; star < 100; star++ {
|
|
if v, ok := this.starMap[utils.ToInt64(hid)+int64(star+1)<<31]; !ok {
|
|
this.module.Debugf("%v", v)
|
|
return star
|
|
}
|
|
}
|
|
return star
|
|
}
|
|
|
|
// 获取觉醒配置
|
|
func (this *configureComp) GetHeroAwakenConfig(hid string, phase int32) (cfg *cfg.GameHeroAwakenData, err error) {
|
|
var (
|
|
ok bool
|
|
par interface{}
|
|
)
|
|
this.hlock.RLock()
|
|
defer this.hlock.RUnlock()
|
|
if cfg, ok = this.awakenMap[utils.ToInt64(hid)+int64(phase)<<31]; !ok {
|
|
par = fmt.Errorf("hid:%s,phase:%d", hid, phase)
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_awaken, par)
|
|
}
|
|
return
|
|
}
|
|
func (this *configureComp) GetHeroExp(hid string) (conf *cfg.GameHeroExpData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
if v, err = this.GetConfigure(hero_exp); err == nil {
|
|
if c, ok := v.(*cfg.GameHeroExp); ok {
|
|
if conf = c.Get(hid); conf != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_exp, hid)
|
|
return
|
|
}
|
|
|
|
// 获取英雄配置
|
|
func (this *configureComp) GetHeroConfig(heroCfgId string) (conf *cfg.GameHeroData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
if v, err = this.GetConfigure(new_hero); err == nil {
|
|
if configure, ok := v.(*cfg.GameHero); ok {
|
|
if conf, ok = configure.GetDataMap()[heroCfgId]; ok {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, new_hero, heroCfgId)
|
|
return
|
|
}
|
|
|
|
// 获取英雄星级配置
|
|
func (this *configureComp) GetHeroStar(star int32) *cfg.GameHeroStargrowData {
|
|
|
|
if v, err := this.GetConfigure(hero_stargrow); err == nil {
|
|
|
|
if configure, ok := v.(*cfg.GameHeroStargrow); ok {
|
|
return configure.Get(star)
|
|
}
|
|
}
|
|
this.module.Errorf(" GetHeroStar err : lv:%d", star)
|
|
return nil
|
|
}
|
|
|
|
// 获取英雄等级配置
|
|
func (this *configureComp) GetHeroLv(lv int32) *cfg.GameHeroLevelupData {
|
|
if v, err := this.GetConfigure(hero_levelup); err == nil {
|
|
if configure, ok := v.(*cfg.GameHeroLevelup); ok {
|
|
return configure.Get(lv)
|
|
}
|
|
}
|
|
|
|
this.module.Errorf(" GetHeroLv err : lv:%d", lv)
|
|
|
|
return nil
|
|
}
|
|
|
|
// 英雄成长配置
|
|
func (this *configureComp) GetHeroLvgrow(heroId string) *cfg.GameHeroLevelgrowData {
|
|
if v, err := this.GetConfigure(hero_levelgrow); err == nil {
|
|
if configure, ok := v.(*cfg.GameHeroLevelgrow); ok {
|
|
return configure.Get(heroId)
|
|
}
|
|
}
|
|
this.module.Errorf("cfg.GetHeroLvgrow :id = %s", heroId)
|
|
return nil
|
|
}
|
|
|
|
// 获取英雄技能升级相关信息
|
|
func (this *configureComp) GetHeroSkillUpConfig(skillid int32) (data *cfg.GameHeroSkillLevelData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
|
|
if v, err = this.GetConfigure(hero_skillup); err == nil {
|
|
if conf, ok := v.(*cfg.GameHeroSkillLevel); ok {
|
|
if data = conf.Get(skillid); data != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_skillup, skillid)
|
|
return
|
|
}
|
|
|
|
// 获取英雄技能最大等级
|
|
func (this *configureComp) GetHeroSkillMaxLvConfig(skillId uint32) int32 {
|
|
|
|
if v, err := this.GetConfigure(game_skillatk); err == nil {
|
|
if configure, ok := v.(*cfg.GameSkillAtk); ok {
|
|
for _, v1 := range configure.GetDataList() {
|
|
if v1.Id == int32(skillId) {
|
|
return v1.MaxLV
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.module.Errorf("cfg.GetHeroSkillMaxLvConfig :id = %d", skillId)
|
|
return 0
|
|
}
|
|
|
|
func (this *configureComp) GetHeroTalent(id int32) (data *cfg.GameHeroTalentData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
if v, err = this.GetConfigure(hero_talent); err == nil {
|
|
if configure, ok := v.(*cfg.GameHeroTalent); ok {
|
|
if data = configure.Get(id); data != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_talent, id)
|
|
return
|
|
}
|
|
|
|
// 天赋指定消耗
|
|
func (this *configureComp) GetHeroTalentBoxItem(heroid string) (itemid string) {
|
|
if v, err := this.GetConfigure(hero_talentbox); err == nil {
|
|
if configure, ok := v.(*cfg.GameTalentBox); ok {
|
|
itemid = configure.Get(heroid).Itemid
|
|
return
|
|
}
|
|
}
|
|
this.module.Errorf("cfg.GameItemBoxData GetHeroTalentBoxItem:skillId = %d", heroid)
|
|
return ""
|
|
}
|
|
|
|
// 读取商品
|
|
func (this *configureComp) GetShopItemsConfigure(key int32) (result *cfg.GameShopitemData, err error) {
|
|
var (
|
|
v interface{}
|
|
ok bool
|
|
)
|
|
if v, err = this.GetConfigure(game_shopitem); err != nil {
|
|
this.module.Errorf("err:%v", err)
|
|
return
|
|
} else {
|
|
if result, ok = v.(*cfg.GameShopitem).GetDataMap()[key]; !ok {
|
|
// err = fmt.Errorf("ShopConfigure not found:%d ", key)
|
|
err = comm.NewNotFoundConfErr(string(this.module.GetType()), game_shopitem, key)
|
|
this.module.Errorf("err:%v", err)
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
func (this *configureComp) GetShopItemsConfigureByGroups(groupid int32, user *pb.DBUser) (result *cfg.GameShopitemData, err error) {
|
|
var (
|
|
v interface{}
|
|
table *cfg.GameShopitem
|
|
)
|
|
if v, err = this.GetConfigure(game_shopitem); err == nil {
|
|
table = v.(*cfg.GameShopitem)
|
|
for _, v := range table.GetDataMap() {
|
|
if v.Id == groupid &&
|
|
user.Lv >= v.Lvmin &&
|
|
user.Lv <= v.Lvmax &&
|
|
user.Vip >= v.Vip {
|
|
result = v
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, game_shopitem, groupid)
|
|
return
|
|
}
|
|
|
|
// 获取英雄升级属性变化相关配置数据
|
|
func (this *configureComp) GetEquipsuit(id int32) (configure *cfg.GameEquipSuitData, err error) {
|
|
var (
|
|
v interface{}
|
|
ok bool
|
|
)
|
|
if v, err = this.GetConfigure(equip_suit); err == nil {
|
|
if configure, ok = v.(*cfg.GameEquipSuit).GetDataMap()[id]; !ok {
|
|
err = fmt.Errorf("%T no is *cfg.GameEquipSuit", v)
|
|
return
|
|
}
|
|
|
|
}
|
|
return
|
|
}
|
|
|
|
func (this *configureComp) GetHeroSkillCost(star int32) (cost []*cfg.Gameatn) {
|
|
|
|
if v, err := this.GetConfigure(hero_skill); err == nil {
|
|
if configure, ok := v.(*cfg.GameHeroSkill); ok {
|
|
return configure.Get(star).Needgold
|
|
}
|
|
}
|
|
this.module.Errorf(" GetHeroSkillCost err : star:%d", star)
|
|
return
|
|
}
|
|
|
|
// 获取英雄最大等级
|
|
func (this *configureComp) GetHeroMaxLv(star int32) int32 {
|
|
|
|
if v, err := this.GetConfigure(hero_stargrow); err == nil {
|
|
if configure, ok := v.(*cfg.GameHeroStargrow); ok {
|
|
return configure.Get(star).Maxlevel
|
|
}
|
|
}
|
|
this.module.Errorf(" GetHeroMaxLv err : star:%d", star)
|
|
|
|
return 1
|
|
}
|
|
func (this *configureComp) GetHeroTalentMaxLv(heroid string) (maxlv int32) {
|
|
if v, err := this.GetConfigure(hero_talentbox); err == nil {
|
|
if configure, ok := v.(*cfg.GameTalentBox); ok {
|
|
return int32(len(configure.GetDataList()))
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
// id: 1新手卡池 2 表示普通抽 3表示阵营1 4表示阵营2 ...
|
|
func (this *configureComp) GetHeroDrawConfigByType(id int32) (data *cfg.GameDrawPoolData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
|
|
if v, err = this.GetConfigure(hero_draw); err == nil {
|
|
if conf, ok := v.(*cfg.GameDrawPool); ok {
|
|
if data = conf.Get(id); data != nil {
|
|
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_draw, id)
|
|
return
|
|
}
|
|
|
|
func (this *configureComp) GetHeroDrawWeightConfigById(dtype int32, key int32) int32 {
|
|
this.hlock.RLock()
|
|
defer this.hlock.RUnlock()
|
|
return this.starW[(int64(dtype)<<16)+int64(key)]
|
|
}
|
|
|
|
// 通过卡池获取 英雄
|
|
func (this *configureComp) GetHeroByPool(pool string) (hid string, err error) {
|
|
this.hlock.RLock()
|
|
defer this.hlock.RUnlock()
|
|
if v, ok := this.cardPool[pool]; ok {
|
|
var sz []int32
|
|
for _, v1 := range v {
|
|
sz = append(sz, v1.Weight)
|
|
}
|
|
if len(sz) == 0 { // 异常报错提醒
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_cardpool, pool)
|
|
return
|
|
}
|
|
hid = v[comm.GetRandW(sz)].Id
|
|
return
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_cardpool, pool)
|
|
return
|
|
}
|
|
|
|
// gm 用 不管性能
|
|
func (this *configureComp) GMGetTalentByHeroId(hid string) (data []*cfg.GameHeroTalentData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
if v, err = this.GetConfigure(hero_talent); err == nil {
|
|
if configure, ok := v.(*cfg.GameHeroTalent); ok {
|
|
for _, v1 := range configure.GetDataList() {
|
|
if v1.Hid == hid {
|
|
data = append(data, v1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if len(data) == 0 {
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_talent, hid)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 获取指定抽的奖励
|
|
func (this *configureComp) GetHeroDrawRewardConfigById(id int32) (data *cfg.GamedrawRewardData, err error) {
|
|
var (
|
|
v interface{}
|
|
)
|
|
if v, err = this.GetConfigure(draw_reward); err == nil {
|
|
if conf, ok := v.(*cfg.GamedrawReward); ok {
|
|
if data = conf.Get(id); data != nil {
|
|
|
|
return
|
|
}
|
|
}
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, draw_reward, id)
|
|
return
|
|
}
|
|
|
|
// 获取所有的奖励数据
|
|
func (this *configureComp) GetAllDrawRewardConf() (data map[int32]*cfg.GamedrawRewardData) {
|
|
|
|
if v, err := this.GetConfigure(draw_reward); err == nil {
|
|
if conf, ok := v.(*cfg.GamedrawReward); ok {
|
|
data = conf.GetDataMap()
|
|
}
|
|
}
|
|
return
|
|
}
|
|
func (this *configureComp) GetHeroByPoolExcept(pool string, cards map[string]struct{}) (hid string, err error) {
|
|
this.hlock.RLock()
|
|
defer this.hlock.RUnlock()
|
|
if v, ok := this.cardPool[pool]; ok {
|
|
|
|
var sz []int32
|
|
for _, v1 := range v {
|
|
if _, ok := cards[v1.Id]; !ok {
|
|
sz = append(sz, v1.Weight)
|
|
}
|
|
}
|
|
if len(sz) == 0 { // 异常报错提醒
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_cardpool, pool)
|
|
return
|
|
}
|
|
hid = v[comm.GetRandW(sz)].Id
|
|
return
|
|
}
|
|
err = comm.NewNotFoundConfErr(moduleName, hero_cardpool, pool)
|
|
return
|
|
}
|