《MMO 服务器开发》9.2 等级与成长状态机

// file: internal/attr/progression.go
// tier: L1
// verify: go test ./internal/attr/
package attr

import "errors"

var (
	ErrNegativeExp  = errors.New("attr: 经验增量为负")
	ErrIllegalPhase = errors.New("attr: 非法的成长相位迁移")
)

// Phase 是成长状态机的相位。
type Phase uint8

const (
	PhaseIdle    Phase = iota // 未满级，等待经验
	PhaseLevelUp              // 本次命令触发升级，待重算属性并发奖
	PhaseMax                  // 已满级，经验不再累积
)

func (p Phase) String() string {
	switch p {
	case PhaseIdle:
		return "idle"
	case PhaseLevelUp:
		return "levelup"
	case PhaseMax:
		return "max"
	default:
		return "unknown"
	}
}

// Curve 是等级经验曲线：Need(level) 是从 level 升到 level+1 所需经验。
type Curve struct {
	max  int32
	need []int64 // need[level]，下标即等级
}

// NewCurve 造一条确定性曲线：need(level) = 100*level + 50*level^2。
// 二次项让升级越来越慢，这是最常见的成长手感。
func NewCurve(max int32) *Curve {
	need := make([]int64, max+1)
	for l := int32(1); l <= max; l++ {
		need[l] = 100*int64(l) + 50*int64(l)*int64(l)
	}
	return &Curve{max: max, need: need}
}

func (c *Curve) MaxLevel() int32 { return c.max }

// Need 返回当前等级升下一级所需经验；满级返回 0。
func (c *Curve) Need(level int32) int64 {
	if level < 1 || level >= c.max {
		return 0
	}
	return c.need[level]
}

// Progression 是等级、当前等级内经验，以及成长相位。
type Progression struct {
	Level int32
	Exp   int64 // 当前等级内已积累的经验
	Phase Phase
	curve *Curve
}

func NewProgression(c *Curve) *Progression {
	return &Progression{Level: 1, Exp: 0, Phase: PhaseIdle, curve: c}
}

// Result 描述一次 Gain 造成的迁移。
type Result struct {
	FromLevel, ToLevel int32
	FromPhase, ToPhase Phase
	LevelsGained       int32
	CarryExp           int64 // 结转进当前等级的经验
	Capped             bool  // 本次是否撞到满级
}

// Gain 是唯一改变成长状态的入口，驱动状态机完成一次（可能连升多级）迁移。
func (p *Progression) Gain(amount int64) (Result, error) {
	if amount < 0 {
		return Result{}, ErrNegativeExp
	}
	// 上一次升级还没结算完，不允许再灌经验：属性还没重算，灌进去就会算错。
	if p.Phase == PhaseLevelUp {
		return Result{}, ErrIllegalPhase
	}
	res := Result{FromLevel: p.Level, FromPhase: p.Phase}
	if p.Phase == PhaseMax {
		res.ToLevel, res.ToPhase = p.Level, PhaseMax
		return res, nil // 满级后经验直接丢弃
	}
	p.Exp += amount
	for p.Level < p.curve.MaxLevel() {
		need := p.curve.Need(p.Level)
		if p.Exp < need {
			break
		}
		p.Exp -= need
		p.Level++
		res.LevelsGained++
	}
	switch {
	case p.Level >= p.curve.MaxLevel():
		p.Level = p.curve.MaxLevel()
		p.Phase = PhaseMax
		res.Capped = true
	case res.LevelsGained > 0:
		p.Phase = PhaseLevelUp
	default:
		p.Phase = PhaseIdle
	}
	res.ToLevel, res.ToPhase = p.Level, p.Phase
	res.CarryExp = p.Exp
	return res, nil
}

// CompleteLevelUp 在重算属性、发放升级奖励之后调用，把状态机推回 Idle。
func (p *Progression) CompleteLevelUp() error {
	if p.Phase != PhaseLevelUp {
		return ErrIllegalPhase
	}
	p.Phase = PhaseIdle
	return nil
}

// file: internal/attr/levelattr.go
// tier: L1
// verify: go test ./internal/attr/
package attr

// Growth 描述每升一级基础属性的增量，以及 1 级时的初始值。
// 它把 9.2 的等级喂进 9.1 的 SetBase，是「成长」与「属性」两套机制的接缝。
type Growth struct {
	BaseHP, HPPerLevel   int64
	BaseMP, MPPerLevel   int64
	BaseATK, ATKPerLevel int64
	BaseDEF, DEFPerLevel int64
}

// ApplyTo 把某等级的基础属性写进 AttributeSet。注意它只改 base，
// 装备与 buff 的加成仍挂在 AttributeSet 上，重算时不会被冲掉。
func (g Growth) ApplyTo(s *AttributeSet, level int32) {
	lv := int64(level)
	s.SetBase(AttrMaxHP, g.BaseHP+g.HPPerLevel*lv)
	s.SetBase(AttrMaxMP, g.BaseMP+g.MPPerLevel*lv)
	s.SetBase(AttrATK, g.BaseATK+g.ATKPerLevel*lv)
	s.SetBase(AttrDEF, g.BaseDEF+g.DEFPerLevel*lv)
}

// snippet: internal/attr/progression_test.go（摘录）
func TestGainMultiLevelCarry(t *testing.T) {
	p := NewProgression(NewCurve(20))
	res, err := p.Gain(10000)
	if err != nil {
		t.Fatalf("Gain: %v", err)
	}
	if p.Level != 8 || res.LevelsGained != 7 {
		t.Fatalf("Level=%d gained=%d, 期望 8 / 7", p.Level, res.LevelsGained)
	}
	if res.CarryExp != 200 || p.Exp != 200 {
		t.Fatalf("结转 = %d, 期望 200", p.Exp)
	}
	if p.Phase != PhaseLevelUp {
		t.Fatalf("Phase=%v, 期望 levelup", p.Phase)
	}
	// 升级未结算前不允许再灌经验
	if _, err := p.Gain(1); !errors.Is(err, ErrIllegalPhase) {
		t.Fatalf("升级中 Gain = %v, 期望 ErrIllegalPhase", err)
	}
	if err := p.CompleteLevelUp(); err != nil {
		t.Fatalf("CompleteLevelUp: %v", err)
	}
	if p.Phase != PhaseIdle {
		t.Fatalf("结算后 Phase=%v, 期望 idle", p.Phase)
	}
}

$ go vet ./...
（无输出）

$ go test ./internal/attr/
ok  	aegis/internal/attr	0.4s     （15 个 test 全绿）