liwei_3d/go_dreamfactory
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

上传代码

Browse Source
This commit is contained in:
liwei1dao 2022-06-09 16:10:20 +08:00
parent 8ca83cb6ab
commit cdf146f287
6 changed files with 411 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
comm/imodule.go
View File

@ -11,6 +11,9 @@ type (
}
//背包模块对外接口定义 提供给其他模块使用的
IPack interface {
//查询用户背包物品数量
QueryUserPackItemAmount(uId string, itemid int32) (amount uint32)
///添加单个物品到背包 (可以加物品和减物品)
AddItemToUserPack(uId string, itemid, addnum int32) (err error)
///添加多个物品到背包 (可以加物品和减物品)
AddItemsToUserPack(uId string, items map[int32]int32) (err error)

288
modules/pack/cache_comp.go Normal file
View File

@ -0,0 +1,288 @@
package pack
import (
"fmt"
"go_dreamfactory/lego/core/cbase"
"go_dreamfactory/lego/sys/mgo"
"go_dreamfactory/lego/sys/redis"
"go_dreamfactory/pb"
"go_dreamfactory/sys/db"
)
///背包缓存数据管理组件
type Cache_Comp struct {
cbase.ModuleCompBase
redis redis.ISys
}
///查询用户背包数据
func (this *Cache_Comp) Pack_QueryUserPack(uId string) (pack *pb.DB_UserPackData, err error) {
pack = &pb.DB_UserPackData{
UserId: uId,
}
if err = this.redis.Get(fmt.Sprintf(Redis_PackCache, uId), pack); err == nil {
return
} else if err == redis.RedisNil {
if pack, err = db.Defsys.Pack_QueryUserPack(uId); err == nil {
this.redis.Set(fmt.Sprintf(Redis_PackCache, uId), pack, Pack_Expiration)
} else if err == mgo.MongodbNil {
err = nil
}
}
return
}
//查询用户背包物品数量
func (this *Cache_Comp) Pack_QueryUserPackItemAmount(uId string, itemid int32) (amount uint32) {
var (
pack *pb.DB_UserPackData
err error
)
if pack, err = this.Pack_QueryUserPack(uId); err != nil {
return
}
for _, v := range pack.Pack {
if !v.IsEmpty && v.ItemId == itemid {
amount += v.Amount
}
}
return
}
///添加或则减少物品到用户背包
func (this *Cache_Comp) Pack_AddItemToUserPack(uId string, itemId int32, addnum int32) (err error) {
var (
pack *pb.DB_UserPackData
modifys []*pb.DB_GridData
leftnum int64
)
if addnum == 0 {
return
}
if pack, err = this.Pack_QueryUserPack(uId); err != nil {
return
}
modifys, leftnum = this.pack_addItemToUserPack(pack, itemId, addnum)
if leftnum < 0 {
err = ItemNotEnoughError
return
} else if leftnum > 0 {
err = PackGridNumUpper
return
}
if pack, err = db.Defsys.Pack_UpdateGridToUserPack(uId, modifys...); err == nil {
this.redis.Set(fmt.Sprintf(Redis_PackCache, uId), pack, Pack_Expiration)
}
return
}
///添加或则减少多个物品到用户背包
func (this *Cache_Comp) Pack_AddItemsToUserPack(uId string, items map[int32]int32) (err error) {
var (
pack *pb.DB_UserPackData
modifys []*pb.DB_GridData
tempmodifys []*pb.DB_GridData
leftnum int64
iskeep bool
)
if pack, err = this.Pack_QueryUserPack(uId); err != nil {
return
}
for k, v := range items {
tempmodifys, leftnum = this.pack_addItemToUserPack(pack, k, v)
if leftnum < 0 {
err = ItemNotEnoughError
return
} else if leftnum > 0 {
err = PackGridNumUpper
return
}
for _, v1 := range tempmodifys {
iskeep = false
for _, v2 := range modifys {
if v1.GridId == v2.GridId {
iskeep = true
}
}
if !iskeep {
modifys = append(modifys, v1)
}
}
}
if pack, err = db.Defsys.Pack_UpdateGridToUserPack(uId, modifys...); err == nil {
this.redis.Set(fmt.Sprintf(Redis_PackCache, uId), pack, Pack_Expiration)
}
return
}
///修改指定格子的物品数量
func (this *Cache_Comp) Pack_AddItemToUserPackByGrid(uId string, gridid int32, itemId int32, addnum int32) (err error) {
var (
pack *pb.DB_UserPackData
grid *pb.DB_GridData
num int64
amount int64
)
if addnum == 0 {
return
}
if pack, err = this.Pack_QueryUserPack(uId); err != nil {
return
}
if int32(len(pack.Pack)) <= gridid {
err = NoFoundGirdError
return
}
grid = pack.Pack[gridid]
if grid == nil {
err = NoFoundGirdError
return
}
amount = int64(grid.Amount)
if grid.IsEmpty {
amount = 0
} else if grid.ItemId != itemId {
err = fmt.Errorf("target grid itemid:%d no is %d ", grid.ItemId, itemId)
}
num = amount + int64(addnum)
if num < 0 {
err = ItemNotEnoughError
} else {
if num > GridCapMaxNum {
err = GirdAmountUpper
return
} else {
if pack, err = db.Defsys.Pack_UpdateGridToUserPack(uId, grid); err == nil {
this.redis.Set(fmt.Sprintf(Redis_PackCache, uId), pack, Pack_Expiration)
}
}
}
return
}
///修改目标格子的新获取标识
func (this *Cache_Comp) Pack_ModifyPackGridIsNewItem(uId string, grids []int32) (err error) {
var (
pack *pb.DB_UserPackData
)
if pack, err = db.Defsys.Pack_ModifyPackGridIsNewItem(uId, grids); err == nil {
err = this.redis.Set(fmt.Sprintf(Redis_PackCache, uId), pack, Pack_Expiration)
}
return
}
///修改目标格子的新获取标识
func (this *Cache_Comp) Pack_UpdateGridToUserPack(uId string, grids ...*pb.DB_GridData) (err error) {
var (
pack *pb.DB_UserPackData
)
if pack, err = db.Defsys.Pack_UpdateGridToUserPack(uId, grids...); err == nil {
err = this.redis.Set(fmt.Sprintf(Redis_PackCache, uId), pack, Pack_Expiration)
}
return
}
///添加移除物品到用户背包
func (this *Cache_Comp) pack_addItemToUserPack(pack *pb.DB_UserPackData, itemId int32, addnum int32) (modifys []*pb.DB_GridData, leftnum int64) {
var (
num int64
isNew bool
)
if addnum == 0 {
return
}
isNew = true
leftnum = int64(addnum)
modifys = make([]*pb.DB_GridData, 0)
for _, v := range pack.Pack {
if !v.IsEmpty && v.ItemId == itemId {
isNew = false
num = int64(v.Amount) + int64(leftnum)
if num < 0 {
leftnum += int64(v.Amount)
v.Amount = 0
v.IsEmpty = true
modifys = append(modifys, v)
} else if num > 0 && num < int64(v.Amount) {
leftnum = 0
v.Amount = uint32(num)
modifys = append(modifys, v)
break
} else if num > 0 && num > int64(v.Amount) {
if num <= GridCapMaxNum {
leftnum = 0
v.Amount = uint32(num)
modifys = append(modifys, v)
break
} else {
if v.Amount < GridCapMaxNum {
leftnum = int64(num - GridCapMaxNum)
v.Amount = uint32(GridCapMaxNum)
modifys = append(modifys, v)
}
}
} else if num == 0 {
leftnum = 0
v.Amount = 0
v.IsEmpty = true
modifys = append(modifys, v)
}
}
}
if leftnum < 0 { //背包物品不够
return
}
if leftnum > 0 { //还没有放完 寻找空的格子填充
for _, v := range pack.Pack {
if v.IsEmpty {
if leftnum <= GridCapMaxNum {
v.IsEmpty = false
v.ItemId = itemId
v.Amount = uint32(leftnum)
leftnum = 0
modifys = append(modifys, v)
break
} else {
leftnum -= GridCapMaxNum
v.IsEmpty = false
v.ItemId = itemId
v.Amount = uint32(GridCapMaxNum)
modifys = append(modifys, v)
}
}
}
index := int32(len(pack.Pack))
for leftnum > 0 { //需要补充格子
if leftnum <= GridCapMaxNum {
grid := &pb.DB_GridData{
GridId: index,
IsEmpty: false,
ItemId: itemId,
Amount: uint32(leftnum),
IsNewItem: isNew,
}
pack.Pack = append(pack.Pack, grid)
modifys = append(modifys, grid)
leftnum = 0
break
} else {
leftnum -= GridCapMaxNum
grid := &pb.DB_GridData{
GridId: index,
IsEmpty: false,
ItemId: itemId,
Amount: uint32(GridCapMaxNum),
IsNewItem: isNew,
}
pack.Pack = append(pack.Pack, grid)
modifys = append(modifys, grid)
index++
}
if index > GridMaxNUm { //格子已达上限
break
}
}
}
return
}

29
modules/pack/core.go
View File

@ -1,11 +1,24 @@
package pack
import "go_dreamfactory/modules"
type (
IPack interface {
modules.IModule
}
IConfigure_Comp interface {
}
import (
"errors"
"go_dreamfactory/lego/core"
)
const ( //Redis
Redis_PackCache string = "pack:%s" //背包缓存数据存放key
DB_PackTable core.SqlTable = "pack" //背包数据库定义表
)
const (
GridCapMaxNum = 99 //单个格子的最大容量
GridMaxNUm = 200 //背包格子数量上限
Pack_Expiration = -1 //背包缓存数据过期时间
)
var (
ItemNotEnoughError = errors.New("item not enough!") //物品不足
NoFoundGirdError = errors.New("no found gvrid!") //未找到格子
PackGridNumUpper = errors.New("grid amount upper!") //背包格子达到上限
GirdAmountUpper = errors.New("grid amount upper!") //格子容量达到上限
)

73
modules/pack/db_comp.go Normal file
View File

@ -0,0 +1,73 @@
package pack
import (
"fmt"
"go_dreamfactory/lego/core/cbase"
"go_dreamfactory/lego/sys/mgo"
"go_dreamfactory/pb"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo/options"
)
///背包数据库数据管理组件
type DB_Comp struct {
cbase.ModuleCompBase
mgo mgo.ISys
}
func (this *DB_Comp) Pack_InitUserPack(uId string) (pack *pb.DB_UserPackData, err error) {
pack = &pb.DB_UserPackData{UserId: uId, Pack: make([]*pb.DB_GridData, 0)}
_, err = this.mgo.InsertOne(DB_PackTable, pack)
return
}
///查询用户背包数据
func (this *DB_Comp) Pack_QueryUserPack(uId string) (pack *pb.DB_UserPackData, err error) {
pack = &pb.DB_UserPackData{}
err = this.mgo.FindOne(DB_PackTable, bson.M{"_id": uId}).Decode(pack)
return
}
//更新背包格子数据
func (this *DB_Comp) Pack_UpdateGridToUserPack(uId string, grids ...*pb.DB_GridData) (pack *pb.DB_UserPackData, err error) {
pack = &pb.DB_UserPackData{}
update := bson.M{}
for _, v := range grids {
update[fmt.Sprintf("pack.%d.gridid", v.GridId)] = v.GridId
update[fmt.Sprintf("pack.%d.isempty", v.GridId)] = v.IsEmpty
update[fmt.Sprintf("pack.%d.itemid", v.GridId)] = v.ItemId
update[fmt.Sprintf("pack.%d.amount", v.GridId)] = v.Amount
update[fmt.Sprintf("pack.%d.isnewitem", v.GridId)] = v.IsNewItem
}
err = this.mgo.FindOneAndUpdate(DB_PackTable,
bson.M{"_id": uId},
bson.M{"$set": update},
options.FindOneAndUpdate().SetUpsert(true).SetReturnDocument(options.After)).Decode(pack)
return
}
//更新背包格子物品的数据
func (this *DB_Comp) Pack_AddGridAmountToUserPack(uId string, grid int32, amount int32) (pack *pb.DB_UserPackData, err error) {
pack = &pb.DB_UserPackData{}
err = this.mgo.FindOneAndUpdate(DB_PackTable,
bson.M{"_id": uId},
bson.M{"$inc": bson.M{
fmt.Sprintf("pack.%d.amount", grid): amount,
}},
options.FindOneAndUpdate().SetUpsert(true).SetReturnDocument(options.After)).Decode(pack)
return
}
//修改背包格子IsNew标识
func (this *DB_Comp) Pack_ModifyPackGridIsNewItem(uId string, grids []int32) (pack *pb.DB_UserPackData, err error) {
pack = &pb.DB_UserPackData{}
identifier := []interface{}{bson.M{"item.gridid": bson.M{"$in": grids}}}
err = this.mgo.FindOneAndUpdate(DB_PackTable,
bson.M{"_id": uId},
bson.M{"$set": bson.M{
"pack.$[item].isNewitem": false,
}}, options.FindOneAndUpdate().SetArrayFilters(options.ArrayFilters{Filters: identifier}).SetReturnDocument(options.After)).Decode(pack)
return
}

7
modules/pack/module.go
View File

@ -47,6 +47,13 @@ func (this *Pack) OnInstallComp() {
}
//IPack-------------------------------------------------------------------------------------------------------------------------------
///查询用户背包物品数量
func (this *Pack) QueryUserPackItemAmount(uId string, itemid int32) (amount uint32) {
defer log.Debugf("获取物品 uId:%s itemid:%d addnum:%d ", uId, itemid, amount)
amount = cache.Defsys.Pack_QueryUserPackItemAmount(uId, itemid)
return
}
///添加单个物品到背包 (可以加物品和减物品)
func (this *Pack) AddItemToUserPack(uId string, itemid, addnum int32) (err error) {
defer log.Debugf("给用户添加物品 uId:%s itemid:%d addnum:%d issucc:%v", uId, itemid, addnum, err == nil)

19
sys/cache/pack.go vendored
View File

@ -30,6 +30,8 @@ var (
type IPack interface {
///查询用户背包
Pack_QueryUserPack(uId string) (pack *pb.DB_UserPackData, err error)
//查询用户背包物品数量
Pack_QueryUserPackItemAmount(uId string, itemid int32) (amount uint32)
///添加物品到背包 (可以加物品和减物品)
Pack_AddItemToUserPack(uId string, itemId int32, addnum int32) (err error)
///添加多个物品到背包 (可以加物品和减物品)
@ -57,6 +59,23 @@ func (this *Cache) Pack_QueryUserPack(uId string) (pack *pb.DB_UserPackData, err
return
}
//查询用户背包物品数量
func (this *Cache) Pack_QueryUserPackItemAmount(uId string, itemid int32) (amount uint32) {
var (
pack *pb.DB_UserPackData
err error
)
if pack, err = this.Pack_QueryUserPack(uId); err != nil {
return
}
for _, v := range pack.Pack {
if !v.IsEmpty && v.ItemId == itemid {
amount += v.Amount
}
}
return
}
///添加或则减少物品到用户背包
func (this *Cache) Pack_AddItemToUserPack(uId string, itemId int32, addnum int32) (err error) {
var (