《游戏服务端编程实践》9.1.2 装备系统与强化

// file: ch09/bag/equip.go
// tier: L1
// verify: go test ./ch09/bag/

package bag

import (
	"errors"
	"fmt"
)

type SlotType string

const (
	SlotWeapon    SlotType = "weapon"
	SlotArmor     SlotType = "armor"
	SlotAccessory SlotType = "accessory"
)

// EquipDef 描述装备定义：槽位、穿戴等级、属性修正与绑定规则。
type EquipDef struct {
	ItemID       string
	Slot         SlotType
	LevelReq     int
	Attrs        map[string]int
	BoundOnEquip bool
}

var (
	ErrUnknownEquip      = errors.New("equip: unknown equipment")
	ErrSlotOccupied      = errors.New("equip: slot occupied")
	ErrLevelTooLow       = errors.New("equip: level too low")
	ErrEmptyEquipSlot    = errors.New("equip: equipment slot is empty")
	ErrBadEnhanceConfig  = errors.New("enhance: bad config")
	ErrMaxLevel          = errors.New("enhance: already at max level")
	ErrNotEnoughMaterial = errors.New("enhance: not enough material")
)

// EquipSet 用槽位映射保存已穿戴装备，属性总是从当前槽位重算，
// 因此反复穿戴/脱下不会产生重复加成。
type EquipSet struct {
	defs  map[string]EquipDef
	slots map[SlotType]Item
}

func NewEquipSet(defs []EquipDef) *EquipSet {
	byID := make(map[string]EquipDef, len(defs))
	for _, d := range defs {
		byID[d.ItemID] = d
	}
	return &EquipSet{defs: byID, slots: make(map[SlotType]Item)}
}

// Equip 穿戴一件装备。装备必须是单件、等级达标、目标槽位为空。
// 绑定规则在穿戴时生效，返回的 Item 是已绑定的副本，调用方应据此
// 在同一事务里更新背包。
func (s *EquipSet) Equip(it Item, level int) (Item, error) {
	def, ok := s.defs[it.ItemID]
	if !ok {
		return Item{}, fmt.Errorf("%w: %s", ErrUnknownEquip, it.ItemID)
	}
	if it.Count != 1 {
		return Item{}, ErrBadCount
	}
	if level < def.LevelReq {
		return Item{}, fmt.Errorf("%w: need %d, got %d", ErrLevelTooLow, def.LevelReq, level)
	}
	if _, busy := s.slots[def.Slot]; busy {
		return Item{}, fmt.Errorf("%w: %s", ErrSlotOccupied, def.Slot)
	}
	if def.BoundOnEquip {
		it.Bound = true
	}
	s.slots[def.Slot] = it
	return it, nil
}

// Unequip 脱下指定槽位，返回装备实例；绑定状态保留。
func (s *EquipSet) Unequip(slot SlotType) (Item, error) {
	it, ok := s.slots[slot]
	if !ok {
		return Item{}, ErrEmptyEquipSlot
	}
	delete(s.slots, slot)
	return it, nil
}

func (s *EquipSet) Equipped(slot SlotType) (Item, bool) {
	it, ok := s.slots[slot]
	return it, ok
}

// Attrs 每次从已穿戴装备重新求和，是属性系统的唯一入口。
func (s *EquipSet) Attrs() map[string]int {
	out := make(map[string]int)
	for _, it := range s.slots {
		def := s.defs[it.ItemID]
		for k, v := range def.Attrs {
			out[k] += v
		}
	}
	return out
}

// Rand 只暴露 Float64，测试可以注入确定性随机源。
type Rand interface {
	Float64() float64
}

type RandFunc func() float64

func (f RandFunc) Float64() float64 { return f() }

type EnhanceConfig struct {
	BaseRate         float64
	Step             float64
	MinRate          float64
	MaxLevel         int
	MaterialCount    int
	ConsumeOnFailure bool
	DropOnFailure    bool
	GuaranteeAfter   int
}

type EnhanceState struct {
	Level      int
	FailStreak int
	Materials  int
}

type EnhanceResult struct {
	Success       bool
	From          int
	To            int
	Rate          float64
	Roll          float64
	UsedFailsafe  bool
	MaterialsUsed int
}

type Enhancer struct {
	cfg EnhanceConfig
	rng Rand
}

func NewEnhancer(cfg EnhanceConfig, rng Rand) (*Enhancer, error) {
	if rng == nil {
		return nil, fmt.Errorf("%w: random source is required", ErrBadEnhanceConfig)
	}
	if cfg.MaxLevel <= 0 || cfg.MaterialCount < 0 || cfg.GuaranteeAfter < 0 ||
		cfg.BaseRate < 0 || cfg.BaseRate > 1 || cfg.MinRate < 0 || cfg.MinRate > 1 ||
		cfg.Step < 0 {
		return nil, ErrBadEnhanceConfig
	}
	return &Enhancer{cfg: cfg, rng: rng}, nil
}

func (e *Enhancer) Rate(level int) float64 {
	rate := e.cfg.BaseRate - e.cfg.Step*float64(level)
	if rate < e.cfg.MinRate {
		rate = e.cfg.MinRate
	}
	if rate < 0 {
		return 0
	}
	if rate > 1 {
		return 1
	}
	return rate
}

// Enhance 是纯状态迁移：输入旧状态，返回新状态与结果，不修改外部对象。
// 材料不足或已满级时状态原样返回；成功时扣材料与升级同时发生在返回值里。
func (e *Enhancer) Enhance(st EnhanceState) (EnhanceState, EnhanceResult, error) {
	res := EnhanceResult{From: st.Level, Rate: e.Rate(st.Level)}
	if st.Level >= e.cfg.MaxLevel {
		return st, res, ErrMaxLevel
	}
	if st.Materials < e.cfg.MaterialCount {
		return st, res, ErrNotEnoughMaterial
	}

	if e.cfg.GuaranteeAfter > 0 && st.FailStreak >= e.cfg.GuaranteeAfter {
		res.UsedFailsafe = true
		res.Success = true
	} else {
		res.Roll = e.rng.Float64()
		res.Success = res.Roll < res.Rate
	}

	if res.Success {
		st.Level++
		st.FailStreak = 0
		st.Materials -= e.cfg.MaterialCount
		res.MaterialsUsed = e.cfg.MaterialCount
	} else {
		if e.cfg.ConsumeOnFailure {
			st.Materials -= e.cfg.MaterialCount
			res.MaterialsUsed = e.cfg.MaterialCount
		}
		st.FailStreak++
		if e.cfg.DropOnFailure && st.Level > 0 {
			st.Level--
		}
	}
	res.To = st.Level
	return st, res, nil
}