《游戏服务端编程实践》8.2.2 Buff / 技能系统建模

// file: ch08/skill/buff.go
// tier: L1
// verify: go test ./ch08/skill/

package skill

import (
	"errors"
	"fmt"
	"sort"
)

var ErrInvalidBuff = errors.New("invalid buff")

type StackRule int

const (
	// StackAdd 叠加层数并刷新持续时间，层数受 MaxStacks 限制。
	StackAdd StackRule = iota
	// StackRefresh 不改变层数，只把持续时间重置为新值。
	StackRefresh
	// StackReplace 仅在强度不弱于旧实例时整体覆盖。
	StackReplace
	// StackIgnore 已存在同源实例时直接忽略。
	StackIgnore
)

func (r StackRule) String() string {
	switch r {
	case StackAdd:
		return "add"
	case StackRefresh:
		return "refresh"
	case StackReplace:
		return "replace"
	case StackIgnore:
		return "ignore"
	default:
		return "unknown"
	}
}

type Effect struct {
	Stat string
	Add  int
}

// Buff 只描述数据和叠加规则，具体效果由 Effect 列表表达，二者解耦。
type Buff struct {
	ID        int32
	Source    uint64
	Name      string
	Stacks    int
	MaxStacks int
	Duration  int
	Remaining int
	Rule      StackRule
	PerSource bool
	Effects   []Effect
}

// BuffSet 用切片保存结算顺序，避免 map 遍历带来的不确定性。
type BuffSet struct {
	items []Buff
}

func NewBuffSet() *BuffSet { return &BuffSet{} }

func (s *BuffSet) Len() int { return len(s.items) }

func (s *BuffSet) Snapshot() []Buff {
	out := make([]Buff, len(s.items))
	copy(out, s.items)
	for i := range out {
		out[i].Effects = append([]Effect(nil), out[i].Effects...)
	}
	return out
}

// Active 返回指定 Buff ID 的第一个实例，用于查询展示。
func (s *BuffSet) Active(id int32) (Buff, bool) {
	for _, b := range s.items {
		if b.ID == id {
			return b, true
		}
	}
	return Buff{}, false
}

func (s *BuffSet) find(b Buff) int {
	for i := range s.items {
		if s.items[i].ID != b.ID {
			continue
		}
		if (b.PerSource || s.items[i].PerSource) && s.items[i].Source != b.Source {
			continue
		}
		return i
	}
	return -1
}

// Apply 按叠加规则写入 Buff，返回最终实例以及状态是否发生变化。
func (s *BuffSet) Apply(b Buff) (Buff, bool, error) {
	if b.ID == 0 || b.Duration <= 0 || b.Stacks <= 0 {
		return Buff{}, false, fmt.Errorf("%w: id=%d duration=%d stacks=%d", ErrInvalidBuff, b.ID, b.Duration, b.Stacks)
	}
	if b.MaxStacks <= 0 {
		b.MaxStacks = b.Stacks
	}
	if b.Stacks > b.MaxStacks {
		b.Stacks = b.MaxStacks
	}
	if b.Remaining <= 0 {
		b.Remaining = b.Duration
	}
	i := s.find(b)
	if i < 0 {
		s.items = append(s.items, b)
		return b, true, nil
	}
	cur := s.items[i]
	switch b.Rule {
	case StackAdd:
		cur.Stacks += b.Stacks
		if cur.Stacks > b.MaxStacks {
			cur.Stacks = b.MaxStacks
		}
		if b.MaxStacks > cur.MaxStacks {
			cur.MaxStacks = b.MaxStacks
		}
		cur.Duration = b.Duration
		cur.Remaining = b.Duration
	case StackRefresh:
		cur.Duration = b.Duration
		cur.Remaining = b.Duration
	case StackReplace:
		if b.Stacks < cur.Stacks || b.Duration < cur.Remaining {
			return cur, false, nil
		}
		cur.Stacks = b.Stacks
		cur.MaxStacks = b.MaxStacks
		cur.Duration = b.Duration
		cur.Remaining = b.Remaining
		cur.Effects = append([]Effect(nil), b.Effects...)
	case StackIgnore:
		return cur, false, nil
	default:
		return cur, false, fmt.Errorf("%w: unknown rule %d", ErrInvalidBuff, b.Rule)
	}
	s.items[i] = cur
	return cur, true, nil
}

// Tick 按切片顺序扣减持续时间，并按同一顺序返回到期实例。
func (s *BuffSet) Tick(frames int) []Buff {
	if frames <= 0 {
		return nil
	}
	kept := s.items[:0]
	var expired []Buff
	for _, b := range s.items {
		b.Remaining -= frames
		if b.Remaining <= 0 {
			b.Remaining = 0
			expired = append(expired, b)
			continue
		}
		kept = append(kept, b)
	}
	s.items = kept
	return expired
}

// Mods 把全部 Buff 的属性加成聚合为稳定排序的结果，层数参与乘法。
func (s *BuffSet) Mods() []Effect {
	var out []Effect
	for _, b := range s.items {
		for _, e := range b.Effects {
			add := e.Add * b.Stacks
			merged := false
			for i := range out {
				if out[i].Stat == e.Stat {
					out[i].Add += add
					merged = true
					break
				}
			}
			if !merged {
				out = append(out, Effect{Stat: e.Stat, Add: add})
			}
		}
	}
	sort.SliceStable(out, func(i, j int) bool { return out[i].Stat < out[j].Stat })
	return out
}

cd .local/checks/gs-practice-lab && gofmt -l ch08/skill && go vet ./ch08/skill/ && go test ./ch08/skill/ -count=1

ok  	gspractice/ch08/skill	0.293s