《MMO 服务器开发》8.3 装备与强化

// file: internal/inventory/equip.go
// tier: L1
// verify: go test ./internal/inventory/
package inventory

import "math/rand/v2"

// Equipped 返回某个装备位上的装备（值拷贝）。
func (s *bagState) Equipped(slot EquipSlot) (ItemStack, bool) {
	st, ok := s.equip[slot]
	if !ok {
		return ItemStack{}, false
	}
	return *st, true
}

// Equipped 读某装备位当前装备。
func (b *Bag) Equipped(slot EquipSlot) (ItemStack, bool) {
	return b.state.Load().Equipped(slot)
}

// Equip 把背包里的某件装备穿上。目标槽位已有装备时，旧装备换下放回背包。
func (b *Bag) Equip(inst ItemInstID) error {
	return b.Do(0, func(tx *Tx) error { return tx.Equip(inst) })
}

// Equip 在事务内执行穿戴。
func (t *Tx) Equip(inst ItemInstID) error {
	slot, ok := t.st.index[inst]
	if !ok {
		return ErrNotInBag
	}
	st := t.st.slots[slot]
	def, ok := t.cat.Get(st.ID)
	if !ok {
		return ErrUnknown
	}
	if def.Slot == SlotNone {
		return ErrNotEquip
	}
	// 先把旧装备放回背包；放不下就返回错误，整笔事务回滚。
	if old := t.st.equip[def.Slot]; old != nil {
		eslot := t.st.firstEmpty()
		if eslot < 0 {
			return ErrNoSpace
		}
		t.st.slots[eslot] = old
		t.st.index[old.Inst] = eslot
	}
	t.st.clearSlot(slot) // 从背包摘除
	t.st.equip[def.Slot] = st
	return nil
}

// Unequip 脱下某个装备位上的装备，放回背包。
func (b *Bag) Unequip(slot EquipSlot) error {
	return b.Do(0, func(tx *Tx) error { return tx.Unequip(slot) })
}

// Unequip 在事务内执行脱下。
func (t *Tx) Unequip(slot EquipSlot) error {
	st := t.st.equip[slot]
	if st == nil {
		return ErrNotEquip
	}
	bslot := t.st.firstEmpty()
	if bslot < 0 {
		return ErrNoSpace
	}
	t.st.slots[bslot] = st
	t.st.index[st.Inst] = bslot
	delete(t.st.equip, slot)
	return nil
}

// EnhanceRule 描述一次强化尝试的规则。
type EnhanceRule struct {
	Rate      float64 // 成功率，0~1
	CostID    ItemID  // 消耗材料
	CostCount int     // 消耗数量
	SafeLevel int     // 当前等级 ≤ 该值时，失败只耗材料、不掉级
}

// EnhanceTable 按当前强化等级给出规则：下标即当前等级。
type EnhanceTable []EnhanceRule

// EnhanceResult 是一次强化的结果。
type EnhanceResult struct {
	Success bool
	From    int // 强化前等级
	To      int // 强化后等级
}

// Enhance 尝试把 inst 强化一级。随机源由调用方注入，保证同一输入可复现。
func (b *Bag) Enhance(rng *rand.Rand, table EnhanceTable, inst ItemInstID) (EnhanceResult, error) {
	var res EnhanceResult
	err := b.Do(0, func(tx *Tx) error {
		slot, ok := tx.st.index[inst]
		if !ok {
			return ErrNotInBag
		}
		st := tx.st.slots[slot]
		def, ok := tx.cat.Get(st.ID)
		if !ok {
			return ErrUnknown
		}
		if def.Slot == SlotNone {
			return ErrNotEquip
		}
		lv := st.Enhance
		if lv >= len(table) {
			return ErrMaxEnhance
		}
		rule := table[lv]
		// 先在同一事务里扣材料：不够则整笔回滚，等级不会被改动。
		if err := tx.Remove(rule.CostID, rule.CostCount); err != nil {
			return err
		}
		res.From = lv
		if rng.Float64() < rule.Rate {
			st.Enhance = lv + 1
			res.Success, res.To = true, lv+1
			return nil
		}
		// 失败：高于安全等级掉一级，否则原地不动。
		if lv > rule.SafeLevel {
			st.Enhance = lv - 1
		}
		res.To = st.Enhance
		return nil
	})
	if err != nil {
		return EnhanceResult{}, err
	}
	return res, nil
}

// file: internal/inventory/equip_test.go
// tier: L1
// verify: go test ./internal/inventory/
package inventory

import (
	"math/rand/v2"
	"testing"
)

func TestEquipSwap(t *testing.T) {
	b := NewBag(testCatalog(), 4)
	_ = b.Do(0, func(tx *Tx) error { return tx.Add(3001, 2) }) // 两把铁剑
	insts := b.Snapshot()
	if len(insts) != 2 {
		t.Fatalf("应有两把铁剑，实得 %d", len(insts))
	}
	if err := b.Equip(insts[0].Inst); err != nil {
		t.Fatalf("equip: %v", err)
	}
	// 再穿第二把：第一把应被换下回到背包。
	if err := b.Equip(insts[1].Inst); err != nil {
		t.Fatalf("equip: %v", err)
	}
	eq, ok := b.Equipped(SlotWeapon)
	if !ok || eq.Inst != insts[1].Inst {
		t.Fatalf("武器位应是第二把，实得 %d", eq.Inst)
	}
	// 背包里应只剩被换下的第一把。
	if got := b.Count(3001); got != 1 {
		t.Fatalf("背包 count=%d，期望 1", got)
	}
	if err := b.Unequip(SlotWeapon); err != nil {
		t.Fatalf("unequip: %v", err)
	}
	if got := b.Count(3001); got != 2 {
		t.Fatalf("脱下后背包 count=%d，期望 2", got)
	}
}

func TestEquipRejectsNonEquipment(t *testing.T) {
	b := NewBag(testCatalog(), 4)
	_ = b.Do(0, func(tx *Tx) error { return tx.Add(1001, 1) })
	inst := b.Snapshot()[0].Inst
	if err := b.Equip(inst); err != ErrNotEquip {
		t.Fatalf("err=%v，期望 ErrNotEquip", err)
	}
}

func TestEnhanceDeterministic(t *testing.T) {
	cat := NewCatalog(
		ItemDef{ID: 3001, Name: "铁剑", Type: TypeEquipment, MaxStack: 1, Slot: SlotWeapon},
		ItemDef{ID: 4001, Name: "强化石", Type: TypeMaterial, MaxStack: 999},
	)
	b := NewBag(cat, 8)
	_ = b.Do(0, func(tx *Tx) error {
		if err := tx.Add(3001, 1); err != nil {
			return err
		}
		return tx.Add(4001, 100)
	})
	inst := b.Snapshot()[0].Inst
	table := EnhanceTable{
		{Rate: 1.0, CostID: 4001, CostCount: 2, SafeLevel: 0}, // +0→+1 必成
		{Rate: 0.0, CostID: 4001, CostCount: 3, SafeLevel: 0}, // +1→+2 必败
	}
	rng := rand.New(rand.NewPCG(7, 11))
	// 必成。
	res, err := b.Enhance(rng, table, inst)
	if err != nil || !res.Success || res.To != 1 {
		t.Fatalf("第一次应必成：%+v err=%v", res, err)
	}
	// 必败且高于安全等级 → 掉回 0。
	res, err = b.Enhance(rng, table, inst)
	if err != nil || res.Success || res.To != 0 {
		t.Fatalf("第二次应必败掉级：%+v err=%v", res, err)
	}
	// 材料共扣 2+3=5，剩 95。
	if got := b.Count(4001); got != 95 {
		t.Fatalf("材料 count=%d，期望 95", got)
	}
}

func TestEnhanceInsufficientMaterialRollsBack(t *testing.T) {
	cat := NewCatalog(
		ItemDef{ID: 3001, Name: "铁剑", Type: TypeEquipment, MaxStack: 1, Slot: SlotWeapon},
		ItemDef{ID: 4001, Name: "强化石", Type: TypeMaterial, MaxStack: 999},
	)
	b := NewBag(cat, 8)
	_ = b.Do(0, func(tx *Tx) error {
		if err := tx.Add(3001, 1); err != nil {
			return err
		}
		return tx.Add(4001, 1) // 只有 1 颗，不够强化
	})
	inst := b.Snapshot()[0].Inst
	table := EnhanceTable{{Rate: 1.0, CostID: 4001, CostCount: 5, SafeLevel: 0}}
	rng := rand.New(rand.NewPCG(1, 2))
	if _, err := b.Enhance(rng, table, inst); err != ErrNotEnough {
		t.Fatalf("err=%v，期望 ErrNotEnough", err)
	}
	// 事务回滚：材料没被扣，等级没变。
	if got := b.Count(4001); got != 1 {
		t.Fatalf("材料 count=%d，期望 1（应回滚）", got)
	}
	if eq := b.Snapshot()[0]; eq.Enhance != 0 {
		t.Fatalf("强化等级=%d，期望 0", eq.Enhance)
	}
}