go_dreamfactory/sys/cache/pack.go

package cache

import (
	"errors"
	"fmt"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/db"

	"go_dreamfactory/lego/sys/mgo"
	"go_dreamfactory/lego/sys/redis"
)

const ( //Redis
	Redis_PackCache string = "pack:%s" //背包缓存数据存放key
)

const (
	GridCapMaxNum = 99 //单个格子的最大容量
)

var (
	ItemNotEnoughError = errors.New("item not enough!")   //物品不足
	NoFoundGirdError   = errors.New("no found gvrid!")    //未找到格子
	GirdAmountUpper    = errors.New("grid amount upper!") //背包格子达到上限
)

type IPack interface {
	///查询用户背包
	Pack_QueryUserPack(uId string) (pack *pb.DB_UserPackData, err error)
	///添加物品到背包 (可以加物品和减物品)
	Pack_AddItemToUserPack(uId string, itemId int32, addnum int32) (err error)
	//修改用户背包格子的标识
	Pack_ModifyPackGridIsNewItem(uId string, grids []int32) (err error)
}

///查询用户背包数据
func (this *Cache) 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, -1)
		} else if err == mgo.MongodbNil {
			err = nil
		}
	}
	return
}

///添加或则减少物品到用户背包
func (this *Cache) Pack_AddItemToUserPack(uId string, itemId int32, addnum int32) (err error) {
	var (
		pack    *pb.DB_UserPackData
		modifys []*pb.DB_GridData
		leftnum int64
		num     int64
		isNew   bool
	)
	if addnum == 0 {
		return
	}
	if pack, err = this.Pack_QueryUserPack(uId); err != nil {
		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
				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)
					}
				}
			}
		}
	}
	if leftnum < 0 { //背包物品不够
		err = ItemNotEnoughError
		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 {
				modifys = append(modifys, &pb.DB_GridData{
					GridId:    index,
					IsEmpty:   false,
					ItemId:    itemId,
					Amount:    uint32(leftnum),
					IsNewItem: isNew,
				})
				leftnum = 0
				break
			} else {
				leftnum -= GridCapMaxNum
				modifys = append(modifys, &pb.DB_GridData{
					GridId:    index,
					IsEmpty:   false,
					ItemId:    itemId,
					Amount:    uint32(GridCapMaxNum),
					IsNewItem: isNew,
				})
				index++
			}
		}
	}
	if pack, err = db.Defsys.Pack_UpdateGridToUserPack(uId, modifys...); err == nil {
		this.redis.Set(fmt.Sprintf(Redis_PackCache, uId), pack, -1)
	}
	return
}

///修改指定格子的物品数量
func (this *Cache) 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, -1)
			}
		}
	}
	return
}

///修改目标格子的新获取标识
func (this *Cache) 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, -1)
	}
	return
}