《MMO 服务器开发》5.3 移动校验与防穿墙

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

import "math"

// RejectReason 是服务器拒绝一次移动的机器可读原因码。
// 客户端据此决定是「静默回拉」还是「弹提示」。
type RejectReason uint8

const (
	Accept         RejectReason = 0 // 通过
	RejectSpeed    RejectReason = 1 // 速度超限（加速外挂）
	RejectWall     RejectReason = 2 // 路径穿墙
	RejectReplay   RejectReason = 3 // 序号回退（重放 / 乱序）
	RejectOutOfMap RejectReason = 4 // 越界
)

// SpeedTolerance 是允许的速度上限系数。网络抖动会让两次上报的 dt 略有出入，
// 留 15% 余量；超过即判为加速外挂。
const SpeedTolerance = 1.15

// ValidateSpeed 检查从 from 到 to 在 dt 秒内是否物理可能。
func ValidateSpeed(from, to Vec2, dt, maxSpeed float64) RejectReason {
	if dt <= 0 {
		return RejectSpeed
	}
	allow := maxSpeed * SpeedTolerance * dt
	if Distance(from, to) > allow+1e-9 {
		return RejectSpeed
	}
	return Accept
}

// LineOfSight 用 DDA 走格判断 a→b 之间是否全程可行走。
// 这是防穿墙的核心：客户端可以谎报一个「瞬移穿墙」的落点，
// 但服务器只要发现起终点连线穿过不可走格，就直接拒绝。
func LineOfSight(g *Grid, a, b Vec2) bool {
	ax, ay := CellOf(a)
	bx, by := CellOf(b)
	if !g.Walkable(ax, ay) || !g.Walkable(bx, by) {
		return false
	}
	x, y := ax, ay
	dx := b.X - a.X
	dy := b.Y - a.Y
	stepX, stepY := 1, 1
	if dx < 0 {
		stepX = -1
	}
	if dy < 0 {
		stepY = -1
	}
	// 到下一条格线的参数增量与每跨一格的时间增量。
	tMaxX, tDeltaX := math.Inf(1), math.Inf(1)
	if dx != 0 {
		edge := float64(x+1) * GridSize
		if stepX < 0 {
			edge = float64(x) * GridSize
		}
		tMaxX = (edge - a.X) / dx
		tDeltaX = GridSize / math.Abs(dx)
	}
	tMaxY, tDeltaY := math.Inf(1), math.Inf(1)
	if dy != 0 {
		edge := float64(y+1) * GridSize
		if stepY < 0 {
			edge = float64(y) * GridSize
		}
		tMaxY = (edge - a.Y) / dy
		tDeltaY = GridSize / math.Abs(dy)
	}

	for i := 0; i < g.W*2+g.H*2+2; i++ { // 步数上限，防浮点死循环
		if x == bx && y == by {
			return true
		}
		if tMaxX < tMaxY {
			x += stepX
			tMaxX += tDeltaX
		} else {
			y += stepY
			tMaxY += tDeltaY
		}
		if !g.Walkable(x, y) {
			return false
		}
	}
	return true
}

// MoveGuard 逐实体记录上一次接受的移动，用于拦截重放、超速与穿墙。
type MoveGuard struct {
	LastPos  Vec2
	LastSeq  uint32
	MaxSpeed float64
}

// NewMoveGuard 创建守卫，pos 为当前权威位置，maxSpeed 为该实体的速度上限。
func NewMoveGuard(pos Vec2, maxSpeed float64) *MoveGuard {
	return &MoveGuard{LastPos: pos, MaxSpeed: maxSpeed}
}

// Check 依次做三道校验：序号单调 → 速度上限 → 视线不穿墙。
// 任一步失败都返回对应原因码，且**不更新 LastPos**——被拒的移动
// 绝不能污染下一次校验的基准，否则一次伪造就能把后续合法移动一起带偏。
func (g *MoveGuard) Check(seq uint32, to Vec2, dt float64, grid *Grid) RejectReason {
	if seq <= g.LastSeq {
		return RejectReplay
	}
	if r := ValidateSpeed(g.LastPos, to, dt, g.MaxSpeed); r != Accept {
		return r
	}
	if grid != nil {
		if cx, cy := CellOf(to); !grid.In(cx, cy) {
			return RejectOutOfMap
		}
		if !LineOfSight(grid, g.LastPos, to) {
			return RejectWall
		}
	}
	g.LastSeq = seq
	g.LastPos = to
	return Accept
}

// snippet: 服务器处理 MoveReq 后的应答（0x0202）
// 载荷：seq(4,BE) | reason(1) | x(4,BE) | y(4,BE)
func (h *Handler) onMoveReq(p *Player, seq uint32, goal Vec2, dt float64) {
	guard := h.guards[p.ID]
	if r := guard.Check(seq, goal, dt, h.grid); r != Accept {
		// 拒绝：把权威位置回给客户端，让它自行回拉，不轻易断线。
		h.send(p, CmdMoveResp, encodeMoveResp(seq, r, guard.LastPos))
		return
	}
	h.movers[p.ID].Goal = goal
	h.send(p, CmdMoveResp, encodeMoveResp(seq, Accept, goal))
}

// snippet: internal/move/validate_test.go（摘录）
func TestLineOfSightBlockedByWall(t *testing.T) {
	g := wallGrid() // 一整堵竖墙在 x=5
	// 墙同侧：可见。
	if !LineOfSight(g, CellCenter(3, 0), CellCenter(4, 4)) {
		t.Fatal("同侧应可见")
	}
	// 跨墙：不可见，正是「穿墙」要拦的情形。
	if LineOfSight(g, CellCenter(4, 0), CellCenter(6, 0)) {
		t.Fatal("跨墙应不可见")
	}
}

func TestMoveGuardRejectsReplayAndWall(t *testing.T) {
	g := wallGrid()
	guard := NewMoveGuard(CellCenter(4, 0), 100)
	if r := guard.Check(1, CellCenter(4, 1), 1.0, g); r != Accept {
		t.Fatalf("首次合法移动 = %v，期望 Accept", r)
	}
	// 同一个序号再来一次：重放。
	if r := guard.Check(1, CellCenter(4, 2), 1.0, g); r != RejectReplay {
		t.Fatalf("重放 = %v，期望 RejectReplay", r)
	}
	// 序号前进，但落点在墙另一侧：穿墙。
	if r := guard.Check(2, CellCenter(6, 1), 1.0, g); r != RejectWall {
		t.Fatalf("穿墙 = %v，期望 RejectWall", r)
	}
	// 被拒的移动不得污染基准位置。
	if guard.LastPos != CellCenter(4, 1) {
		t.Fatalf("被拒后基准被污染: %+v", guard.LastPos)
	}
}

$ go test ./internal/move/
ok  	aegis/internal/move	0.293s     （14 个 test 全绿，含 4 个校验相关）

$ go test ./internal/move/ -bench BenchmarkLineOfSight -benchtime=200x -run '^$'
BenchmarkLineOfSight-10   200   15.62 ns/op   0 B/op   0 allocs/op