《MMO 服务器开发》13.3 插值与平滑

服务端快照:      S0@t=0     S1@t=50    S2@t=100   S3@t=150
渲染时刻 t=120:  └──────────┴──────────┴────┐
                                    ┌───────┘ 落在 S2(100) 与 S3(150) 之间
                                    │
                          插值 = S2 + (S3 - S2) * (120-100)/50

// file: internal/predict/interpolate.go
// tier: L1
// verify: go test ./internal/predict/ -run 'TestInterpolate|TestExtrapolate|TestSmoothCorrection' -v

package predict

// Snapshot is one authoritative state sample tagged with the server tick it
// belongs to. Remote entities are rendered from a short buffer of these.
type Snapshot struct {
	Tick uint32
	Pos  Vec2
	Vel  Vec2
}

// Interpolate renders a remote entity at renderTick by lerping between the two
// snapshots that bracket it. Rendering in the past -- behind the newest sample,
// by the interpolation delay -- means there is always a "next" sample to move
// toward, so the entity glides instead of stepping.
func Interpolate(buf []Snapshot, renderTick float64) Vec2 {
	if len(buf) == 0 {
		return Vec2{}
	}
	if renderTick <= float64(buf[0].Tick) {
		return buf[0].Pos
	}
	last := buf[len(buf)-1]
	if renderTick >= float64(last.Tick) {
		return Extrapolate(last, renderTick-float64(last.Tick))
	}
	for i := 1; i < len(buf); i++ {
		a, b := buf[i-1], buf[i]
		if renderTick <= float64(b.Tick) {
			t := (renderTick - float64(a.Tick)) / float64(b.Tick-a.Tick)
			return lerp(a.Pos, b.Pos, t)
		}
	}
	return last.Pos
}

// Extrapolate projects a snapshot forward by dt ticks using its velocity. It is
// the fallback when the render clock has run past the newest sample: cheaper
// than a stall, but wrong whenever the entity changes direction, so it should
// be limited to a few ticks of lookahead.
func Extrapolate(s Snapshot, dt float64) Vec2 {
	return Vec2{X: s.Pos.X + s.Vel.X*dt, Y: s.Pos.Y + s.Vel.Y*dt}
}

// SmoothCorrection moves a rendered position toward the corrected one by at most
// alpha of the remaining gap per tick. Instead of snapping to the server's
// answer, the error is spread over several frames and decays geometrically.
func SmoothCorrection(current, target Vec2, alpha float64) Vec2 {
	if alpha <= 0 {
		return current
	}
	if alpha >= 1 {
		return target
	}
	return lerp(current, target, alpha)
}

func lerp(a, b Vec2, t float64) Vec2 {
	return Vec2{X: a.X + (b.X-a.X)*t, Y: a.Y + (b.Y-a.Y)*t}
}

// snippet: internal/predict/interpolate_test.go（节选）

// TestInterpolateBrackets checks that a render clock inside the buffer lerps
// between the bracketing snapshots, and that a clock outside the buffer clamps
// to the nearest sample instead of inventing motion.
func TestInterpolateBrackets(t *testing.T) {
	buf := []Snapshot{
		{Tick: 100, Pos: Vec2{X: 0}},
		{Tick: 102, Pos: Vec2{X: 10}},
	}
	if got := Interpolate(buf, 101); got.X != 5 {
		t.Fatalf("midpoint = %v, want 5", got.X)
	}
	if got := Interpolate(buf, 100); got.X != 0 {
		t.Fatalf("on first sample = %v, want 0", got.X)
	}
	if got := Interpolate(buf, 99); got.X != 0 {
		t.Fatalf("before buffer = %v, want 0 (clamped)", got.X)
	}
}

// TestExtrapolatePastNewest checks the fallback path: once the render clock is
// ahead of the newest sample, velocity carries the entity forward.
func TestExtrapolatePastNewest(t *testing.T) {
	buf := []Snapshot{
		{Tick: 100, Pos: Vec2{X: 0}, Vel: Vec2{X: 5}},
		{Tick: 101, Pos: Vec2{X: 5}, Vel: Vec2{X: 5}},
	}
	if got := Interpolate(buf, 102); got.X != 10 {
		t.Fatalf("extrapolated = %v, want 10", got.X)
	}
}

// TestSmoothCorrectionFadesError checks that a correction is spread over frames
// and decays to (near) zero rather than snapping in one tick.
func TestSmoothCorrectionFadesError(t *testing.T) {
	cur := Vec2{X: 0}
	target := Vec2{X: 10}
	cur = SmoothCorrection(cur, target, 0.25)
	if cur.X != 2.5 {
		t.Fatalf("after one step = %v, want 2.5", cur.X)
	}
	for i := 0; i < 40; i++ {
		cur = SmoothCorrection(cur, target, 0.25)
	}
	if diff := target.X - cur.X; diff > 0.01 {
		t.Fatalf("residual = %v, want ~0", diff)
	}
}

每渲染帧（本地 60Hz）:
  1. 计算 renderTick = now - interpolationDelay      // 活在过去
  2. 远端实体: pos = Interpolate(snapshotBuf, renderTick)
  3. 本机玩家: pos = p.Pos                            // 预测位置，不过插值
  4. 若本帧收到和解: err = dist(rendered, p.Pos)
       err 小  -> rendered = SmoothCorrection(rendered, p.Pos, alpha)
       err 大  -> rendered = p.Pos                    // 瞬移，不平滑
  5. 用 rendered 画到屏幕