《MMO 服务器开发》5.1 服务器权威移动

// file: internal/move/vec2.go
// tier: L1
// verify: go test ./internal/move/
package move

import "math"

// GridSize 是逻辑坐标的格边长。AOI 九宫格、寻路网格与移动校验共用这一口径，
// 保证「一格」在三个子系统里是同一个物理尺度，不会出现 AOI 一格八米、
// 寻路一格十米的错位。
const GridSize = 8.0

// Vec2 是服务器的浮点逻辑坐标，与客户端像素坐标分离。
// 服务端只认逻辑坐标，渲染缩放、镜头偏移全部由客户端自己做。
type Vec2 struct{ X, Y float64 }

func (a Vec2) Add(b Vec2) Vec2      { return Vec2{a.X + b.X, a.Y + b.Y} }
func (a Vec2) Sub(b Vec2) Vec2      { return Vec2{a.X - b.X, a.Y - b.Y} }
func (a Vec2) Scale(s float64) Vec2 { return Vec2{a.X * s, a.Y * s} }
func (a Vec2) Len() float64         { return math.Hypot(a.X, a.Y) }
func (a Vec2) LenSq() float64       { return a.X*a.X + a.Y*a.Y }

// Normalize 返回同方向的单位向量；零向量返回零向量而不是 NaN。
// 浮点坐标里 0/0 会变成 NaN，一旦写进权威位置就再也拉不回来。
func (a Vec2) Normalize() Vec2 {
	if l := a.Len(); l > 0 {
		return Vec2{a.X / l, a.Y / l}
	}
	return Vec2{}
}

// Distance 是两点欧氏距离。
func Distance(a, b Vec2) float64 { return a.Sub(b).Len() }

// CellOf 把逻辑坐标映射到格坐标，供 AOI 与寻路网格共用。
func CellOf(p Vec2) (int, int) {
	return int(math.Floor(p.X / GridSize)), int(math.Floor(p.Y / GridSize))
}

// CellCenter 是格坐标的中心点，寻路结果转成逻辑坐标时用。
func CellCenter(x, y int) Vec2 {
	return Vec2{X: (float64(x) + 0.5) * GridSize, Y: (float64(y) + 0.5) * GridSize}
}

// file: internal/move/mover.go
// tier: L1
// verify: go test ./internal/move/
package move

import (
	"errors"
	"sort"
)

// CmdMoveReq 0x0201：客户端发来的「我要去某点」请求。
// 载荷里是目标点，不是坐标本身——坐标永远由服务器算。
const CmdMoveReq uint16 = 0x0201

// CmdMoveResp 0x0202：服务器对 MoveReq 的应答，拒绝时带原因码。
const CmdMoveResp uint16 = 0x0202

// TickRate 是服务器移动模拟的固定频率（Hz）。逻辑推进与网络收发解耦：
// 无论一帧收到多少条 MoveReq，位置都只按固定步长推进。
const TickRate = 20

// TickSeconds 是每个 tick 的逻辑时长（20Hz → 50ms）。
const TickSeconds = 1.0 / TickRate

// MaxRequestDistance 是单次 MoveReq 允许的目标点最远距离。
// 客户端只能「点一下附近」，不能一次传一个跨半张地图的坐标。
const MaxRequestDistance = 3 * GridSize

var (
	ErrGoalTooFar = errors.New("move: 目标点超出单次请求上限")
	ErrBadSpeed   = errors.New("move: 速度非正")
)

// Mover 是单个实体的权威移动状态机。
// 关键：Pos 只能被 Step 改写，客户端无法直接写它。
type Mover struct {
	Pos    Vec2    // 权威位置（服务器独占）
	Speed  float64 // 逻辑单位 / 秒
	Goal   Vec2    // 当前移动目标
	Moving bool
}

// NewMover 创建位于 pos、以 speed 逻辑单位/秒移动的实体。
func NewMover(pos Vec2, speed float64) *Mover {
	return &Mover{Pos: pos, Speed: speed}
}

// Request 处理一条 MoveReq：把目标点写进 Goal。
// 目标点过远直接拒绝，而不是「截断到边界」——截断会让客户端与服务器
// 对终点的理解不一致，反而制造持续的位置漂移。
func (m *Mover) Request(goal Vec2) error {
	if m.Speed <= 0 {
		return ErrBadSpeed
	}
	if Distance(m.Pos, goal) > MaxRequestDistance {
		return ErrGoalTooFar
	}
	m.Goal = goal
	m.Moving = Distance(m.Pos, goal) > 1e-9
	return nil
}

// Step 推进 dt 秒，返回本 tick 的位移（供 AOI 与广播判断是否需要通知）。
// 到达目标时吸附到 Goal 并停下，不做过冲。
func (m *Mover) Step(dt float64) Vec2 {
	if !m.Moving || dt <= 0 {
		return Vec2{}
	}
	to := m.Goal.Sub(m.Pos)
	dist := to.Len()
	if dist == 0 {
		m.Moving = false
		return Vec2{}
	}
	step := m.Speed * dt
	var next Vec2
	if step >= dist {
		next = m.Goal
		m.Moving = false
	} else {
		next = m.Pos.Add(to.Scale(step / dist))
	}
	delta := next.Sub(m.Pos)
	m.Pos = next
	return delta
}

// World 用固定步长统一推进所有实体。
type World struct {
	Movers map[uint64]*Mover
	moved  []uint64 // 复用切片，避免每 tick 分配
}

// NewWorld 创建空世界。
func NewWorld() *World {
	return &World{Movers: make(map[uint64]*Mover)}
}

// StepAll 用同一个 dt 推进所有实体，返回本 tick 真正产生位移的实体 ID。
// 只广播「动了的」是移动同步省带宽的第一原则。返回结果排过序，
// 保证同一份输入在任何机器上产生同一份广播顺序，便于回放与对账。
func (w *World) StepAll(dt float64) []uint64 {
	w.moved = w.moved[:0]
	for id, m := range w.Movers {
		if d := m.Step(dt); d != (Vec2{}) {
			w.moved = append(w.moved, id)
		}
	}
	sort.Slice(w.moved, func(i, j int) bool { return w.moved[i] < w.moved[j] })
	return w.moved
}

// file: internal/move/wire.go
// tier: L1
// verify: go test ./internal/move/
package move

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

// ErrShortPayload 表示 MoveReq 载荷长度不足。
var ErrShortPayload = errors.New("move: 载荷长度不足")

// EncodeMoveReq 把「我要去哪」编成 CmdMoveReq 0x0201 的载荷。
// 载荷只装目标点与客户端时间戳，不装「我在哪」——这是权威移动在协议层的体现。
// 帧头 11 字节（length|cmd|seq|flags）见卷一，这里只负责载荷。
func EncodeMoveReq(goal Vec2, clientTimeMs uint32) []byte {
	buf := make([]byte, 0, 20)
	buf = binary.BigEndian.AppendUint64(buf, math.Float64bits(goal.X))
	buf = binary.BigEndian.AppendUint64(buf, math.Float64bits(goal.Y))
	buf = binary.BigEndian.AppendUint32(buf, clientTimeMs)
	return buf
}

// DecodeMoveReq 解析载荷。任何越界都返回错误，绝不 panic——
// 越界输入来自网络，是攻击者可控的。
func DecodeMoveReq(b []byte) (Vec2, uint32, error) {
	if len(b) < 20 {
		return Vec2{}, 0, ErrShortPayload
	}
	x := math.Float64frombits(binary.BigEndian.Uint64(b[0:8]))
	y := math.Float64frombits(binary.BigEndian.Uint64(b[8:16]))
	return Vec2{x, y}, binary.BigEndian.Uint32(b[16:20]), nil
}

$ go test ./internal/move/
ok  	aegis/internal/move	0.293s     （14 个 test 全绿）

$ go test ./internal/move/ -bench BenchmarkStepAll -benchtime=200x
BenchmarkStepAll-10   200   83204 ns/op   0 B/op   0 allocs/op