473 lines
11 KiB
Go
473 lines
11 KiB
Go
// Package inventory 背包模型与规则表（场景/物品与背包.md §3、UI与输入.md §4）。
|
||
//
|
||
// 规则表（CanPlace / ClickLeft / ClickRight / ShiftMove / Merge）为**单一来源**：
|
||
// 客户端与服务器共用同一实现，防双端不一致（多人同步.md §5）。
|
||
package inventory
|
||
|
||
import (
|
||
"mc/internal/item"
|
||
)
|
||
|
||
// 背包槽位常量（UI还原.md §3.3、物品与背包.md §3）。
|
||
const (
|
||
HotbarSize = 9
|
||
MainSize = 27
|
||
StorageSize = HotbarSize + MainSize // 0–35，Add/Remove 只写这里
|
||
ArmorSize = 4
|
||
OffhandSize = 1
|
||
TotalSize = StorageSize + ArmorSize + OffhandSize // 41
|
||
SlotHelmet = 36
|
||
SlotChest = 37
|
||
SlotLegs = 38
|
||
SlotBoots = 39
|
||
SlotOffhand = 40
|
||
MaxCraftBulk = 64 // Shift 批量合成单次上限（工作台与合成表.md §5）
|
||
)
|
||
|
||
// Inventory 背包（主线程所有权，无需锁——架构.md §4）。
|
||
type Inventory struct {
|
||
Slots []item.Stack // 41 槽：0–8 热键栏、9–35 主区、36–39 盔甲、40 副手
|
||
Selected int // 热键栏选中索引 0–8
|
||
reg *item.Registry
|
||
}
|
||
|
||
// New 创建空背包。
|
||
func New(reg *item.Registry) *Inventory {
|
||
return &Inventory{Slots: make([]item.Stack, TotalSize), reg: reg}
|
||
}
|
||
|
||
// CanMerge 两栈是否可合并：同名、同耐久、数量未满（物品与背包.md §3）。
|
||
func CanMerge(a, b item.Stack) bool {
|
||
if a.Empty() || b.Empty() || a.Name != b.Name {
|
||
return false
|
||
}
|
||
if a.Durability != b.Durability {
|
||
return false
|
||
}
|
||
return int(a.Count)+int(b.Count) <= 127
|
||
}
|
||
|
||
// Merge 合并两栈：返回合并结果与剩余量（调用方负责写回槽位）。
|
||
func Merge(limit uint8, a, b item.Stack) (item.Stack, item.Stack) {
|
||
total := int(a.Count) + int(b.Count)
|
||
if total <= int(limit) {
|
||
a.Count = uint8(total)
|
||
return a, item.Stack{}
|
||
}
|
||
a.Count = limit
|
||
b.Count = uint8(total - int(limit))
|
||
return a, b
|
||
}
|
||
|
||
// CanPlace 槽位是否允许放入该栈（盔甲/副手按 Equip 限制，其余存储槽均可）。
|
||
func CanPlace(reg *item.Registry, slot int, s item.Stack) bool {
|
||
if s.Empty() {
|
||
return true
|
||
}
|
||
want := ""
|
||
switch slot {
|
||
case SlotHelmet:
|
||
want = "helmet"
|
||
case SlotChest:
|
||
want = "chestplate"
|
||
case SlotLegs:
|
||
want = "leggings"
|
||
case SlotBoots:
|
||
want = "boots"
|
||
case SlotOffhand:
|
||
want = "offhand"
|
||
default:
|
||
return true
|
||
}
|
||
return item.EquipOf(s.Name, reg) == want
|
||
}
|
||
|
||
// ClickLeft 左键：拿起整栈 / 放下 / 同物品合并 / 交换。canPlace 为 false 时不改槽。
|
||
func ClickLeft(slot, held item.Stack, limit uint8, canPlace bool) (item.Stack, item.Stack) {
|
||
switch {
|
||
case held.Empty():
|
||
return item.Stack{}, slot
|
||
case !canPlace:
|
||
return slot, held
|
||
case slot.Empty():
|
||
return held, item.Stack{}
|
||
case slot.Name == held.Name:
|
||
merged, remain := Merge(limit, slot, held)
|
||
return merged, remain
|
||
default:
|
||
return held, slot
|
||
}
|
||
}
|
||
|
||
// ClickRight 右键：空手拿一半（向上取整）；手持时向空槽或同物品放 1 个。
|
||
func ClickRight(slot, held item.Stack, limit uint8, canPlace bool) (item.Stack, item.Stack) {
|
||
if held.Empty() {
|
||
if slot.Empty() {
|
||
return slot, held
|
||
}
|
||
take := (int(slot.Count) + 1) / 2
|
||
held = slot
|
||
held.Count = uint8(take)
|
||
slot.Count -= uint8(take)
|
||
if slot.Count == 0 {
|
||
slot = item.Stack{}
|
||
}
|
||
return slot, held
|
||
}
|
||
if !canPlace {
|
||
return slot, held
|
||
}
|
||
one := held
|
||
one.Count = 1
|
||
switch {
|
||
case slot.Empty():
|
||
slot = one
|
||
held.Count--
|
||
case slot.Name == held.Name && slot.Count < limit:
|
||
slot.Count++
|
||
held.Count--
|
||
default:
|
||
return slot, held
|
||
}
|
||
if held.Count == 0 {
|
||
held = item.Stack{}
|
||
}
|
||
return slot, held
|
||
}
|
||
|
||
func (inv *Inventory) storageEnd() int {
|
||
if len(inv.Slots) < StorageSize {
|
||
return len(inv.Slots)
|
||
}
|
||
return StorageSize
|
||
}
|
||
|
||
// Add 把物品栈放入存储区（0–35；先合并再空槽），返回剩余。
|
||
func (inv *Inventory) Add(s item.Stack) item.Stack {
|
||
if s.Empty() {
|
||
return s
|
||
}
|
||
limit := s.Limit(inv.reg)
|
||
end := inv.storageEnd()
|
||
for i := 0; i < end; i++ {
|
||
if inv.Slots[i].Empty() {
|
||
continue
|
||
}
|
||
if inv.Slots[i].Name == s.Name && inv.Slots[i].Durability == s.Durability && inv.Slots[i].Count < limit {
|
||
merged, remain := Merge(limit, inv.Slots[i], s)
|
||
inv.Slots[i] = merged
|
||
s = remain
|
||
if s.Empty() {
|
||
return s
|
||
}
|
||
}
|
||
}
|
||
for i := 0; i < end; i++ {
|
||
if inv.Slots[i].Empty() {
|
||
inv.Slots[i] = s
|
||
return item.Stack{}
|
||
}
|
||
}
|
||
return s
|
||
}
|
||
|
||
// Fits 存储区能否完全放下该栈（不修改）。
|
||
func (inv *Inventory) Fits(s item.Stack) bool {
|
||
if s.Empty() {
|
||
return true
|
||
}
|
||
limit := s.Limit(inv.reg)
|
||
left := int(s.Count)
|
||
end := inv.storageEnd()
|
||
for i := 0; i < end; i++ {
|
||
st := inv.Slots[i]
|
||
if st.Empty() {
|
||
return true
|
||
}
|
||
if st.Name == s.Name && st.Durability == s.Durability && st.Count < limit {
|
||
room := int(limit) - int(st.Count)
|
||
if room >= left {
|
||
return true
|
||
}
|
||
left -= room
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// Remove 从存储区移除指定物品 count 个；不足返回 false。
|
||
func (inv *Inventory) Remove(name string, count int) bool {
|
||
if count <= 0 {
|
||
return false
|
||
}
|
||
have := 0
|
||
end := inv.storageEnd()
|
||
for i := 0; i < end; i++ {
|
||
if inv.Slots[i].Name == name {
|
||
have += int(inv.Slots[i].Count)
|
||
}
|
||
}
|
||
if have < count {
|
||
return false
|
||
}
|
||
left := count
|
||
for i := 0; i < end; i++ {
|
||
if inv.Slots[i].Name != name {
|
||
continue
|
||
}
|
||
if int(inv.Slots[i].Count) <= left {
|
||
left -= int(inv.Slots[i].Count)
|
||
inv.Slots[i] = item.Stack{}
|
||
} else {
|
||
inv.Slots[i].Count -= uint8(left)
|
||
left = 0
|
||
}
|
||
if left == 0 {
|
||
return true
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// CountItem 存储区中该物品数量（不含盔甲/副手）。
|
||
func (inv *Inventory) CountItem(name string) int {
|
||
n := 0
|
||
end := inv.storageEnd()
|
||
for i := 0; i < end; i++ {
|
||
if inv.Slots[i].Name == name {
|
||
n += int(inv.Slots[i].Count)
|
||
}
|
||
}
|
||
return n
|
||
}
|
||
|
||
// TakeOne 从存储区取出 1 个指定物品；不足返回 false。
|
||
func (inv *Inventory) TakeOne(name string) bool {
|
||
return inv.Remove(name, 1)
|
||
}
|
||
|
||
// ClickSlot 对背包槽执行左/右键（含 CanPlace）。
|
||
func (inv *Inventory) ClickSlot(idx int, held item.Stack, right bool) item.Stack {
|
||
if idx < 0 || idx >= len(inv.Slots) {
|
||
return held
|
||
}
|
||
cur := inv.Slots[idx]
|
||
limit := held.Limit(inv.reg)
|
||
if held.Empty() {
|
||
limit = cur.Limit(inv.reg)
|
||
}
|
||
ok := CanPlace(inv.reg, idx, held)
|
||
var ns, nh item.Stack
|
||
if right {
|
||
ns, nh = ClickRight(cur, held, limit, ok)
|
||
} else {
|
||
ns, nh = ClickLeft(cur, held, limit, ok)
|
||
}
|
||
inv.Slots[idx] = ns
|
||
return nh
|
||
}
|
||
|
||
// ShiftFromInv 物品栏内 Shift：主区 ↔ 热键栏；盔甲/副手 → 存储区。
|
||
func (inv *Inventory) ShiftFromInv(idx int) bool {
|
||
if idx < 0 || idx >= len(inv.Slots) || inv.Slots[idx].Empty() {
|
||
return false
|
||
}
|
||
src := inv.Slots[idx]
|
||
inv.Slots[idx] = item.Stack{}
|
||
var rem item.Stack
|
||
switch {
|
||
case idx < HotbarSize:
|
||
rem = addRange(inv, src, HotbarSize, StorageSize)
|
||
case idx < StorageSize:
|
||
rem = addRange(inv, src, 0, HotbarSize)
|
||
default:
|
||
rem = inv.Add(src)
|
||
}
|
||
if !rem.Empty() && CanPlace(inv.reg, idx, rem) {
|
||
inv.Slots[idx] = rem
|
||
}
|
||
return rem.Empty() || rem.Count != src.Count
|
||
}
|
||
|
||
// ShiftIntoStorage 把一栈移入存储区（工作台网格 → 背包）。
|
||
func (inv *Inventory) ShiftIntoStorage(s item.Stack) item.Stack {
|
||
return inv.Add(s)
|
||
}
|
||
|
||
// ShiftIntoSlots 把一栈尽量放入 dest 切片的空/可合并槽（背包 → 合成网格）。
|
||
func ShiftIntoSlots(reg *item.Registry, dest []item.Stack, s item.Stack) item.Stack {
|
||
if s.Empty() {
|
||
return s
|
||
}
|
||
limit := s.Limit(reg)
|
||
for i := range dest {
|
||
if dest[i].Empty() || dest[i].Name != s.Name || dest[i].Durability != s.Durability {
|
||
continue
|
||
}
|
||
merged, remain := Merge(limit, dest[i], s)
|
||
dest[i] = merged
|
||
s = remain
|
||
if s.Empty() {
|
||
return s
|
||
}
|
||
}
|
||
for i := range dest {
|
||
if dest[i].Empty() {
|
||
dest[i] = s
|
||
return item.Stack{}
|
||
}
|
||
}
|
||
return s
|
||
}
|
||
|
||
func addRange(inv *Inventory, s item.Stack, from, to int) item.Stack {
|
||
if s.Empty() || from < 0 || to > len(inv.Slots) || from >= to {
|
||
return s
|
||
}
|
||
limit := s.Limit(inv.reg)
|
||
for i := from; i < to; i++ {
|
||
if inv.Slots[i].Empty() || inv.Slots[i].Name != s.Name || inv.Slots[i].Durability != s.Durability {
|
||
continue
|
||
}
|
||
if inv.Slots[i].Count >= limit {
|
||
continue
|
||
}
|
||
merged, remain := Merge(limit, inv.Slots[i], s)
|
||
inv.Slots[i] = merged
|
||
s = remain
|
||
if s.Empty() {
|
||
return s
|
||
}
|
||
}
|
||
for i := from; i < to; i++ {
|
||
if inv.Slots[i].Empty() {
|
||
inv.Slots[i] = s
|
||
return item.Stack{}
|
||
}
|
||
}
|
||
return s
|
||
}
|
||
|
||
// SlotPtr 槽位指针（拖拽均分用）；越界返回 nil。
|
||
func SlotPtr(slots []item.Stack, i int) *item.Stack {
|
||
if i < 0 || i >= len(slots) {
|
||
return nil
|
||
}
|
||
return &slots[i]
|
||
}
|
||
|
||
// CanAcceptDrag 拖拽目标：空槽或同物品未满。
|
||
func CanAcceptDrag(reg *item.Registry, slot, held item.Stack, canPlace bool) bool {
|
||
if held.Empty() || !canPlace {
|
||
return false
|
||
}
|
||
if slot.Empty() {
|
||
return true
|
||
}
|
||
return slot.Name == held.Name && slot.Durability == held.Durability && slot.Count < held.Limit(reg)
|
||
}
|
||
|
||
// SpreadEven 把 held 等分到 dest（已过滤可放入的槽）。返回剩余手持。
|
||
// dest 为槽指针列表；n=0 不改。
|
||
func SpreadEven(reg *item.Registry, held item.Stack, dest []*item.Stack) item.Stack {
|
||
if held.Empty() || len(dest) == 0 {
|
||
return held
|
||
}
|
||
limit := held.Limit(reg)
|
||
n := len(dest)
|
||
each := int(held.Count) / n
|
||
if each < 1 {
|
||
return held
|
||
}
|
||
if each > int(limit) {
|
||
each = int(limit)
|
||
}
|
||
left := int(held.Count)
|
||
for _, p := range dest {
|
||
if p == nil || left <= 0 {
|
||
continue
|
||
}
|
||
put := each
|
||
if !p.Empty() {
|
||
room := int(limit) - int(p.Count)
|
||
if put > room {
|
||
put = room
|
||
}
|
||
}
|
||
if put <= 0 {
|
||
continue
|
||
}
|
||
if p.Empty() {
|
||
*p = held
|
||
p.Count = uint8(put)
|
||
} else {
|
||
p.Count += uint8(put)
|
||
}
|
||
left -= put
|
||
}
|
||
if left <= 0 {
|
||
return item.Stack{}
|
||
}
|
||
held.Count = uint8(left)
|
||
return held
|
||
}
|
||
|
||
// SpreadOne 向单槽放 1 个（右键拖）。
|
||
func SpreadOne(reg *item.Registry, slot, held item.Stack, canPlace bool) (item.Stack, item.Stack) {
|
||
return ClickRight(slot, held, held.Limit(reg), canPlace)
|
||
}
|
||
|
||
// Gather 从 sources 把与 name 同类的物品聚到 held，直到堆叠上限。
|
||
func Gather(reg *item.Registry, held item.Stack, name string, sources []item.Stack) (item.Stack, []item.Stack) {
|
||
if name == "" {
|
||
return held, sources
|
||
}
|
||
if held.Empty() {
|
||
held = item.Stack{Name: name, Count: 0}
|
||
}
|
||
if held.Name != name {
|
||
return held, sources
|
||
}
|
||
limit := held.Limit(reg)
|
||
for i := range sources {
|
||
if sources[i].Empty() || sources[i].Name != name || sources[i].Durability != held.Durability {
|
||
continue
|
||
}
|
||
need := int(limit) - int(held.Count)
|
||
if need <= 0 {
|
||
break
|
||
}
|
||
take := int(sources[i].Count)
|
||
if take > need {
|
||
take = need
|
||
}
|
||
held.Count += uint8(take)
|
||
if take >= int(sources[i].Count) {
|
||
sources[i] = item.Stack{}
|
||
} else {
|
||
sources[i].Count -= uint8(take)
|
||
}
|
||
}
|
||
if held.Count == 0 {
|
||
held = item.Stack{}
|
||
}
|
||
return held, sources
|
||
}
|
||
|
||
// GatherStorage 从存储区 0–35 聚堆到 held。
|
||
func (inv *Inventory) GatherStorage(held item.Stack, name string) item.Stack {
|
||
end := inv.storageEnd()
|
||
src := inv.Slots[:end]
|
||
held, src = Gather(inv.reg, held, name, src)
|
||
copy(inv.Slots[:end], src)
|
||
return held
|
||
}
|
||
|
||
// SelectedStack 返回选中槽（只读）。
|
||
func (inv *Inventory) SelectedStack() item.Stack {
|
||
if inv.Selected < 0 || inv.Selected >= HotbarSize {
|
||
return item.Stack{}
|
||
}
|
||
return inv.Slots[inv.Selected]
|
||
}
|