《MMO 服务器开发》12.1 状态同步与帧同步的服务端视角

// file: internal/sync/world.go
// tier: L1
// verify: go test ./internal/sync/ -run 'TestLockstepConverges|TestStateSyncAuthoritative|TestFloatOrderMatters' -v

package sync

import (
	"math"
	"sort"
)

// Vec2 is a 2-D position or velocity. float32 keeps the wire form small and,
// more importantly, makes the arithmetic bit-identical on every replica.
type Vec2 struct{ X, Y float32 }

// Entity is one simulated object. Players and NPCs share the struct; only the
// existence of a controlling Input differs.
type Entity struct {
	ID   uint32
	Pos  Vec2
	Vel  Vec2
	HP   int16
	Kind uint8 // 1 = player, 2 = npc
}

// EntityState is one entity reduced to the fields that go on the wire.
type EntityState struct {
	ID   uint32
	Pos  Vec2
	Vel  Vec2
	HP   int16
	Kind uint8
}

// Input is one player's intent for a single frame. It is the only thing a
// lockstep client ever sends: never a position, never a result.
type Input struct {
	PlayerID uint32
	MoveX    int8
	MoveY    int8
	Fire     bool
}

// World is the deterministic simulation. Every replica runs the same Step over
// the same Inputs in the same order and must arrive at the same state.
type World struct {
	Tick  uint32
	byID  map[uint32]*Entity
	order []uint32 // sorted entity IDs: a stable iteration order
}

// NewWorld returns an empty world.
func NewWorld() *World {
	return &World{byID: make(map[uint32]*Entity)}
}

// Spawn adds or replaces an entity, keeping the iteration order sorted.
func (w *World) Spawn(e Entity) {
	if _, ok := w.byID[e.ID]; !ok {
		w.order = append(w.order, e.ID)
		sort.Slice(w.order, func(i, j int) bool { return w.order[i] < w.order[j] })
	}
	cp := e
	w.byID[e.ID] = &cp
}

// Step advances the world by exactly one tick. It is deliberately two phases:
// apply every input, then integrate every entity. Interleaving the two would
// make the result depend on input arrival order, which is exactly the
// nondeterminism a lockstep server cannot tolerate.
func (w *World) Step(inputs []Input) {
	for _, in := range inputs {
		e, ok := w.byID[in.PlayerID]
		if !ok {
			continue
		}
		e.Vel = Vec2{X: float32(in.MoveX) * 0.5, Y: float32(in.MoveY) * 0.5}
		if in.Fire && e.HP > 0 {
			e.HP--
		}
	}
	// Iterate the sorted ID slice, never the map: Go randomises map iteration
	// order, and that alone desyncs two otherwise identical replicas.
	for _, id := range w.order {
		e := w.byID[id]
		e.Pos.X += e.Vel.X
		e.Pos.Y += e.Vel.Y
	}
	w.Tick++
}

// Replicate returns the authoritative state of every entity, in ID order.
func (w *World) Replicate() []EntityState {
	out := make([]EntityState, 0, len(w.order))
	for _, id := range w.order {
		e := w.byID[id]
		out = append(out, EntityState{ID: e.ID, Pos: e.Pos, Vel: e.Vel, HP: e.HP, Kind: e.Kind})
	}
	return out
}

// Digest is a cheap, order-sensitive fingerprint of the whole world. Two
// replicas are in sync iff their Digests match.
func (w *World) Digest() uint64 {
	const prime = 1099511628211
	var h uint64 = 1469598103934665603
	mix := func(v uint64) {
		h ^= v
		h *= prime
	}
	for _, id := range w.order {
		e := w.byID[id]
		mix(uint64(id))
		mix(uint64(math.Float32bits(e.Pos.X)))
		mix(uint64(math.Float32bits(e.Pos.Y)))
		mix(uint64(math.Float32bits(e.Vel.X)))
		mix(uint64(math.Float32bits(e.Vel.Y)))
		mix(uint64(uint16(e.HP)))
		mix(uint64(e.Kind))
	}
	return h
}

// file: internal/sync/lockstep.go
// tier: L1
// verify: go test ./internal/sync/ -run 'TestLockstepConverges' -v

package sync

import "sort"

// LockstepFrame is one frozen frame of inputs, as broadcast to every client.
type LockstepFrame struct {
	Frame  uint32
	Inputs []Input
}

// LockstepServer collects one input per player per frame and broadcasts the
// batch. It advances no simulation: the authoritative state lives on the
// clients, and the server is a relay plus a clock.
type LockstepServer struct {
	Frame   uint32
	Expect  int
	pending map[uint32]Input
}

// NewLockstepServer builds a server that waits for `players` inputs per frame.
func NewLockstepServer(players int) *LockstepServer {
	return &LockstepServer{Expect: players, pending: make(map[uint32]Input)}
}

// Submit records one player's input for the current frame. A duplicate from the
// same player in the same frame is dropped, which is what makes a resend after
// packet loss harmless.
func (s *LockstepServer) Submit(in Input) bool {
	if _, dup := s.pending[in.PlayerID]; dup {
		return false
	}
	s.pending[in.PlayerID] = in
	return true
}

// Ready reports whether every expected player has submitted.
func (s *LockstepServer) Ready() bool { return len(s.pending) >= s.Expect }

// Advance freezes the current frame. It returns false while the frame is still
// short of inputs; that is the server's entire stall policy: no input, no tick.
func (s *LockstepServer) Advance() (LockstepFrame, bool) {
	if !s.Ready() {
		return LockstepFrame{}, false
	}
	ids := make([]uint32, 0, len(s.pending))
	for id := range s.pending {
		ids = append(ids, id)
	}
	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
	f := LockstepFrame{Frame: s.Frame}
	for _, id := range ids {
		f.Inputs = append(f.Inputs, s.pending[id])
	}
	s.Frame++
	s.pending = make(map[uint32]Input)
	return f, true
}

// file: internal/sync/statesync.go
// tier: L1
// verify: go test ./internal/sync/ -run 'TestStateSyncAuthoritative' -v

package sync

// StateSyncServer owns the one true World. Clients send intent; the server
// simulates and broadcasts results. A client is a renderer, never a replica.
type StateSyncServer struct {
	World    *World
	TickRate int
	last     []EntityState
}

// NewStateSyncServer wraps a world with the tick rate (ticks per second) the
// server intends to broadcast at.
func NewStateSyncServer(w *World, tickRate int) *StateSyncServer {
	return &StateSyncServer{World: w, TickRate: tickRate}
}

// Tick applies one frame of inputs and returns the authoritative replication
// set. The asymmetry with lockstep is the whole point: to produce this the
// server had to run the entire simulation itself, every tick, for every player.
func (s *StateSyncServer) Tick(inputs []Input) []EntityState {
	s.World.Step(inputs)
	s.last = s.World.Replicate()
	return s.last
}

// AuthoritativeDigest is the server's fingerprint of the world. A client that
// disagrees with it is out of sync and must be corrected, not trusted.
func (s *StateSyncServer) AuthoritativeDigest() uint64 { return s.World.Digest() }

// snippet: internal/sync/determinism_test.go（节选）

// TestLockstepConverges is the whole promise of lockstep in one test: the
// server relays inputs, every client replays them, and all replicas end with
// the same Digest. The server never ran a Step.
func TestLockstepConverges(t *testing.T) {
	const players, frames = 4, 200
	srv := NewLockstepServer(players)

	clients := make([]*World, players)
	for i := range clients {
		clients[i] = newTestWorld(players)
	}

	rng := rand.New(rand.NewSource(1))
	for f := 0; f < frames; f++ {
		for p := 0; p < players; p++ {
			in := Input{PlayerID: uint32(p), MoveX: int8(rng.Intn(3) - 1),
				MoveY: int8(rng.Intn(3) - 1), Fire: rng.Intn(4) == 0}
			srv.Submit(in)
		}
		frame, _ := srv.Advance()
		for _, c := range clients {
			c.Step(frame.Inputs)
		}
	}

	want := clients[0].Digest()
	for i, c := range clients {
		if got := c.Digest(); got != want {
			t.Fatalf("client %d desynced: digest %#x, want %#x", i, got, want)
		}
	}
}