323 lines
7.8 KiB
Go
323 lines
7.8 KiB
Go
package pack
|
|
|
|
import (
|
|
"fmt"
|
|
"go_dreamfactory/lego/core"
|
|
"go_dreamfactory/lego/sys/mgo"
|
|
"go_dreamfactory/lego/sys/redis"
|
|
"go_dreamfactory/modules"
|
|
"go_dreamfactory/pb"
|
|
"reflect"
|
|
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
)
|
|
|
|
///背包缓存数据管理组件
|
|
type Cache_Comp struct {
|
|
modules.MComp_CacheComp
|
|
module *Pack
|
|
}
|
|
|
|
//组件初始化接口
|
|
func (this *Cache_Comp) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
|
|
this.ModuleCompBase.Init(service, module, comp, options)
|
|
this.module = module.(*Pack)
|
|
return
|
|
}
|
|
|
|
///查询用户背包数据
|
|
func (this *Cache_Comp) Pack_QueryUserPack(uId string) (itmes []*pb.DB_UserItemData, err error) {
|
|
var (
|
|
lists []interface{}
|
|
temp map[string]interface{}
|
|
)
|
|
if lists, err = this.Redis.HGetAll(fmt.Sprintf(Redis_PackCache, uId), reflect.TypeOf(pb.DB_UserItemData{})); err == nil {
|
|
itmes = make([]*pb.DB_UserItemData, 0, len(lists))
|
|
for i, v := range lists {
|
|
itmes[i] = v.(*pb.DB_UserItemData)
|
|
}
|
|
return
|
|
} else if err == redis.RedisNil {
|
|
if itmes, err = this.module.db_comp.Pack_QueryUserPack(uId); err == nil {
|
|
temp = make(map[string]interface{})
|
|
for _, v := range itmes {
|
|
temp[v.GridId] = v
|
|
}
|
|
this.Redis.HMSet(fmt.Sprintf(Redis_PackCache, uId), temp)
|
|
} else if err == mgo.MongodbNil {
|
|
err = nil
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
///查询用户指定格子的物品数据
|
|
func (this *Cache_Comp) Pack_QueryUserPackByGridId(uId string, grid string) (itme *pb.DB_UserItemData, err error) {
|
|
var (
|
|
itmes []*pb.DB_UserItemData
|
|
temp map[string]interface{}
|
|
)
|
|
itme = &pb.DB_UserItemData{}
|
|
if err = this.Redis.HGet(fmt.Sprintf(Redis_PackCache, uId), grid, itme); err == nil {
|
|
return
|
|
} else if err == redis.RedisNil {
|
|
if itmes, err = this.module.db_comp.Pack_QueryUserPack(uId); err == nil {
|
|
temp = make(map[string]interface{})
|
|
for _, v := range itmes {
|
|
temp[v.GridId] = v
|
|
}
|
|
this.Redis.HMSet(fmt.Sprintf(Redis_PackCache, uId), temp)
|
|
for _, v := range itmes {
|
|
if v.GridId == grid {
|
|
itme = v
|
|
return
|
|
}
|
|
}
|
|
err = fmt.Errorf("no found uid:%s grid:%s", uId, grid)
|
|
} else if err == mgo.MongodbNil {
|
|
err = nil
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//更新用户的背包信息
|
|
func (this *Cache_Comp) Pack_UpdateUserPack(uId string, itmes ...*pb.DB_UserItemData) (err error) {
|
|
temp := make(map[string]interface{})
|
|
for _, v := range itmes {
|
|
temp[v.GridId] = v
|
|
}
|
|
if err = this.Redis.HMSet(fmt.Sprintf(Redis_PackCache, uId), temp); err != nil {
|
|
this.module.db_comp.Pack_UpdateGridToUserPack(uId, itmes...)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
//更新用户的背包信息
|
|
func (this *Cache_Comp) Pack_DeleteUserPack(uId string, gridIds ...string) (err error) {
|
|
if err = this.Redis.HDel(fmt.Sprintf(Redis_PackCache, uId), gridIds...); err != nil {
|
|
err = this.module.db_comp.Pack_DeleteGridToUserPack(uId, gridIds...)
|
|
}
|
|
return
|
|
}
|
|
|
|
//查询用户背包物品数量
|
|
func (this *Cache_Comp) Pack_QueryUserPackItemAmount(uId string, itemid int32) (amount uint32) {
|
|
var (
|
|
itmes []*pb.DB_UserItemData
|
|
err error
|
|
)
|
|
if itmes, err = this.Pack_QueryUserPack(uId); err != nil {
|
|
return
|
|
}
|
|
for _, v := range itmes {
|
|
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 (
|
|
itmes []*pb.DB_UserItemData
|
|
modifys []*pb.DB_UserItemData
|
|
leftnum int64
|
|
)
|
|
if addnum == 0 {
|
|
return
|
|
}
|
|
if itmes, err = this.Pack_QueryUserPack(uId); err != nil {
|
|
return
|
|
}
|
|
modifys, leftnum = this.pack_addItemToUserPack(itmes, itemId, addnum)
|
|
if leftnum < 0 {
|
|
err = ItemNotEnoughError
|
|
return
|
|
} else if leftnum > 0 {
|
|
err = PackGridNumUpper
|
|
return
|
|
}
|
|
this.Pack_UpdateUserPack(uId, modifys...)
|
|
return
|
|
}
|
|
|
|
///添加或则减少多个物品到用户背包
|
|
func (this *Cache_Comp) Pack_AddItemsToUserPack(uId string, items map[int32]int32) (err error) {
|
|
var (
|
|
itmes []*pb.DB_UserItemData
|
|
modifys []*pb.DB_UserItemData
|
|
tempmodifys []*pb.DB_UserItemData
|
|
leftnum int64
|
|
iskeep bool
|
|
)
|
|
if itmes, err = this.Pack_QueryUserPack(uId); err != nil {
|
|
return
|
|
}
|
|
for k, v := range items {
|
|
tempmodifys, leftnum = this.pack_addItemToUserPack(itmes, 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)
|
|
}
|
|
}
|
|
}
|
|
|
|
this.Pack_UpdateUserPack(uId, modifys...)
|
|
return
|
|
}
|
|
|
|
///修改指定格子的物品数量
|
|
func (this *Cache_Comp) Pack_AddItemToUserPackByGrid(uId string, gridid string, itemId int32, addnum int32) (err error) {
|
|
var (
|
|
itme *pb.DB_UserItemData
|
|
grid *pb.DB_UserItemData
|
|
num int64
|
|
amount int64
|
|
)
|
|
if addnum == 0 {
|
|
return
|
|
}
|
|
if itme, err = this.Pack_QueryUserPackByGridId(uId, gridid); err != nil {
|
|
return
|
|
}
|
|
amount = int64(itme.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 {
|
|
itme.Amount = uint32(num)
|
|
this.Pack_UpdateUserPack(uId, itme)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
///添加移除物品到用户背包
|
|
func (this *Cache_Comp) pack_addItemToUserPack(items []*pb.DB_UserItemData, itemId int32, addnum int32) (modifys []*pb.DB_UserItemData, leftnum int64) {
|
|
var (
|
|
num int64
|
|
isNew bool
|
|
)
|
|
if addnum == 0 {
|
|
return
|
|
}
|
|
isNew = true
|
|
leftnum = int64(addnum)
|
|
modifys = make([]*pb.DB_UserItemData, 0)
|
|
for _, v := range items {
|
|
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 items {
|
|
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(items))
|
|
for leftnum > 0 { //需要补充格子
|
|
if leftnum <= GridCapMaxNum {
|
|
grid := &pb.DB_UserItemData{
|
|
GridId: primitive.NewObjectID().Hex(),
|
|
IsEmpty: false,
|
|
ItemId: itemId,
|
|
Amount: uint32(leftnum),
|
|
IsNewItem: isNew,
|
|
}
|
|
items = append(items, grid)
|
|
modifys = append(modifys, grid)
|
|
leftnum = 0
|
|
break
|
|
} else {
|
|
leftnum -= GridCapMaxNum
|
|
grid := &pb.DB_UserItemData{
|
|
GridId: primitive.NewObjectID().Hex(),
|
|
IsEmpty: false,
|
|
ItemId: itemId,
|
|
Amount: uint32(GridCapMaxNum),
|
|
IsNewItem: isNew,
|
|
}
|
|
items = append(items, grid)
|
|
modifys = append(modifys, grid)
|
|
index++
|
|
}
|
|
if index > GridMaxNUm { //格子已达上限
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|