《MMO 服务器开发》9.1 属性计算与加成来源

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

// AttrID 是属性编号，落在配置表里，不是字符串名。
type AttrID uint16

const (
	AttrMaxHP AttrID = 1
	AttrMaxMP AttrID = 2
	AttrATK   AttrID = 3
	AttrDEF   AttrID = 4
)

// Scale 是百分比固定点标度：万分之几。用整数避免浮点误差在多个来源叠加时累积。
const Scale int64 = 10000

// Op 决定一条加成参与哪一层聚合。
type Op uint8

const (
	OpAdd        Op = iota // 平加：进入 base + Σadd
	OpPercentAdd           // 加算百分比：同类求和后一次性乘
	OpPercentMul           // 乘算百分比：各自独立连乘
)

// Source 标记加成来自哪里，用于审计与整组移除。
type Source uint8

const (
	SrcBase Source = iota
	SrcEquip
	SrcBuff
	SrcTitle
)

// Modifier 是一条加成来源。Group 用于同类取最强：同一属性上 Group 相同、
// Op 为 OpAdd 的修正只保留最大值（例如多份食物 buff 只吃最高那份）。
type Modifier struct {
	Source Source
	Group  string
	Attr   AttrID
	Op     Op
	Value  int64
}

// AttributeSet 保存基础属性与全部加成，Compute 时才聚合成最终值。
type AttributeSet struct {
	base  map[AttrID]int64
	mods  []Modifier
	final map[AttrID]int64
	dirty bool
}

func NewAttributeSet() *AttributeSet {
	return &AttributeSet{base: map[AttrID]int64{}, final: map[AttrID]int64{}, dirty: true}
}

// SetBase 设置某个属性的基础值（来自等级曲线，见 9.2）。
func (s *AttributeSet) SetBase(a AttrID, v int64) {
	s.base[a] = v
	s.dirty = true
}

// Add 追加一条加成。装备穿上、buff 生效都走这里。
func (s *AttributeSet) Add(m Modifier) {
	s.mods = append(s.mods, m)
	s.dirty = true
}

// Remove 按「来源 + 组」整组移除。卸装备、buff 到期的正确粒度是整组，
// 而不是按数值删——同一件装备可能对多个属性各有加成。
func (s *AttributeSet) Remove(source Source, group string) {
	out := s.mods[:0]
	for _, m := range s.mods {
		if m.Source == source && m.Group == group {
			continue
		}
		out = append(out, m)
	}
	s.mods = out
	s.dirty = true
}

// Compute 返回某属性的最终值。任何 Add/Remove/SetBase 之后首次查询会触发一次全量重建。
func (s *AttributeSet) Compute(a AttrID) int64 {
	if s.dirty {
		s.rebuild()
	}
	return s.final[a]
}

// rebuild 只在脏标记置位时跑一次，把全部属性算好放进缓存。
func (s *AttributeSet) rebuild() {
	s.final = make(map[AttrID]int64, len(s.base))
	for a := range s.base {
		s.final[a] = s.computeOne(a)
	}
	// 只在加成里出现、没有基础值的属性也要算（例如纯 buff 提供的暴击率）。
	for _, m := range s.mods {
		if _, ok := s.final[m.Attr]; !ok {
			s.final[m.Attr] = s.computeOne(m.Attr)
		}
	}
	s.dirty = false
}

// computeOne 按「平加 → 加算百分比 → 乘算百分比」三层聚合。
func (s *AttributeSet) computeOne(a AttrID) int64 {
	// 先求每个 Group 里 OpAdd 的最大值，用于同类取最强。
	best := map[string]int64{}
	for _, m := range s.mods {
		if m.Attr != a || m.Op != OpAdd || m.Group == "" {
			continue
		}
		if v, ok := best[m.Group]; !ok || m.Value > v {
			best[m.Group] = m.Value
		}
	}
	var add, pctAdd int64
	mul := Scale // 10000 表示 1.0
	applied := map[string]bool{}
	for _, m := range s.mods {
		if m.Attr != a {
			continue
		}
		switch m.Op {
		case OpAdd:
			if m.Group != "" {
				if applied[m.Group] {
					continue
				}
				applied[m.Group] = true
				add += best[m.Group]
				continue
			}
			add += m.Value
		case OpPercentAdd:
			pctAdd += m.Value
		case OpPercentMul:
			mul = mul * (Scale + m.Value) / Scale
		}
	}
	v := s.base[a] + add
	v = v * (Scale + pctAdd) / Scale
	v = v * mul / Scale
	if v < 0 {
		v = 0
	}
	return v
}

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

import (
	"encoding/binary"
	"errors"
	"sort"
)

// CmdAttrSync 复用卷一世界域的命令号 0x0103，不另起炉灶。
const CmdAttrSync uint16 = 0x0103

const (
	HeaderSize = 11 // length(4) + cmd(2) + seq(4) + flags(1)
	FlagsNone  = 0
)

var ErrShortFrame = errors.New("attr: 帧长度不足")

// AttrDelta 是同步里的一项：只发发生变化的属性。
type AttrDelta struct {
	ID    AttrID
	Value int64
}

// EncodeAttrSync 把变化集编成一条完整帧：11 字节头 + 计数(2) + 每项 10 字节。
// 进世界时发一次全量快照，之后只走增量——属性每秒都可能因 buff 抖动，
// 全量重发会把带宽吃光。
func EncodeAttrSync(seq uint32, deltas []AttrDelta) []byte {
	// 先排序，保证同一集合编出同一串字节，便于测试与抓包比对。
	sort.Slice(deltas, func(i, j int) bool { return deltas[i].ID < deltas[j].ID })
	payload := make([]byte, 0, 2+len(deltas)*10)
	payload = binary.BigEndian.AppendUint16(payload, uint16(len(deltas)))
	for _, d := range deltas {
		payload = binary.BigEndian.AppendUint16(payload, uint16(d.ID))
		payload = binary.BigEndian.AppendUint64(payload, uint64(d.Value))
	}
	out := make([]byte, HeaderSize, HeaderSize+len(payload))
	binary.BigEndian.PutUint32(out[0:], uint32(7+len(payload))) // length = cmd+seq+flags+payload
	binary.BigEndian.PutUint16(out[4:], CmdAttrSync)
	binary.BigEndian.PutUint32(out[6:], seq)
	out[10] = FlagsNone
	return append(out, payload...)
}

// DecodeAttrSync 解析 EncodeAttrSync 的产物，越界返回错误而非 panic。
func DecodeAttrSync(frame []byte) (uint32, []AttrDelta, error) {
	if len(frame) < HeaderSize {
		return 0, nil, ErrShortFrame
	}
	if cmd := binary.BigEndian.Uint16(frame[4:]); cmd != CmdAttrSync {
		return 0, nil, errors.New("attr: 命令号不是 CmdAttrSync")
	}
	seq := binary.BigEndian.Uint32(frame[6:])
	body := frame[HeaderSize:]
	if len(body) < 2 {
		return 0, nil, ErrShortFrame
	}
	n := int(binary.BigEndian.Uint16(body))
	body = body[2:]
	if len(body) < n*10 {
		return 0, nil, ErrShortFrame
	}
	deltas := make([]AttrDelta, n)
	for i := 0; i < n; i++ {
		deltas[i] = AttrDelta{
			ID:    AttrID(binary.BigEndian.Uint16(body[i*10:])),
			Value: int64(binary.BigEndian.Uint64(body[i*10+2:])),
		}
	}
	return seq, deltas, nil
}

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

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