《游戏服务端编程实践》7.3.3 实时位置信息同步

frame(tick, entities):
    updates = []
    for entity in sort_by_id(entities):
        q = quantize(entity)
        if last[entity.id] missing or changed(last, q):
            q.tick = tick
            updates.append(q)
            last[entity.id] = q
    if tick % keyframeInterval == 0:
        return full_snapshot(entities)
    return updates

// file: ch07/map/sync.go
// tier: L1
// verify: go test ./ch07/map/

package worldmap

import (
	"math"
	"sort"
)

const (
	DefaultPosScale   = 16.0
	DefaultSpeedScale = 100.0
)

// WireUpdate 是位置同步的最小增量包，坐标为定点整数。
type WireUpdate struct {
	ID    EntityID
	X     int32
	Y     int32
	Dir   uint16
	Speed uint16
	Tick  uint64
}

type Encoder struct {
	posScale   float64
	speedScale float64
	moveEps    float64
	dirEps     float64
	speedEps   float64
	last       map[EntityID]WireUpdate
}

func NewEncoder() *Encoder {
	return &Encoder{
		posScale:   DefaultPosScale,
		speedScale: DefaultSpeedScale,
		moveEps:    0.05,
		dirEps:     math.Pi / 90, // 2 度
		speedEps:   0.05,
		last:       make(map[EntityID]WireUpdate),
	}
}

func (e *Encoder) Quantize(ent Entity) WireUpdate {
	return WireUpdate{
		ID:    ent.ID,
		X:     quantize(ent.Pos.X, e.posScale),
		Y:     quantize(ent.Pos.Y, e.posScale),
		Dir:   quantizeDir(ent.Dir),
		Speed: quantizeSpeed(ent.Speed, e.speedScale),
	}
}

func (e *Encoder) Decode(u WireUpdate) Entity {
	return Entity{
		ID:    u.ID,
		Pos:   Vec2{X: float64(u.X) / e.posScale, Y: float64(u.Y) / e.posScale},
		Dir:   decodeDir(u.Dir),
		Speed: float64(u.Speed) / e.speedScale,
	}
}

// Encode 与上一帧已发送值比较，阈值内不返回更新。
func (e *Encoder) Encode(tick uint64, ent Entity) (WireUpdate, bool) {
	cur := e.Quantize(ent)
	cur.Tick = tick
	prev, ok := e.last[ent.ID]
	if !ok {
		e.last[ent.ID] = cur
		return cur, true
	}
	if !e.changed(prev, cur) {
		return WireUpdate{}, false
	}
	e.last[ent.ID] = cur
	return cur, true
}

// EncodeFrame 对一批实体按 ID 排序后编码，保证同输入产出稳定。
func (e *Encoder) EncodeFrame(tick uint64, entities []Entity) []WireUpdate {
	ordered := append([]Entity(nil), entities...)
	sort.Slice(ordered, func(i, j int) bool { return ordered[i].ID < ordered[j].ID })
	out := make([]WireUpdate, 0, len(ordered))
	for _, ent := range ordered {
		if u, ok := e.Encode(tick, ent); ok {
			out = append(out, u)
		}
	}
	return out
}

func (e *Encoder) Forget(id EntityID) {
	delete(e.last, id)
}

func (e *Encoder) changed(prev, cur WireUpdate) bool {
	if math.Abs(float64(cur.X-prev.X))/e.posScale >= e.moveEps {
		return true
	}
	if math.Abs(float64(cur.Y-prev.Y))/e.posScale >= e.moveEps {
		return true
	}
	if dirDelta(prev.Dir, cur.Dir) >= e.dirEps {
		return true
	}
	ds := math.Abs(float64(int32(cur.Speed)-int32(prev.Speed))) / e.speedScale
	return ds >= e.speedEps
}

func quantize(v, scale float64) int32 {
	if math.IsNaN(v) || math.IsInf(v, 0) {
		return 0
	}
	q := math.Round(v * scale)
	if q > math.MaxInt32 {
		return math.MaxInt32
	}
	if q < math.MinInt32 {
		return math.MinInt32
	}
	return int32(q)
}

func quantizeSpeed(speed, scale float64) uint16 {
	if math.IsNaN(speed) || math.IsInf(speed, 0) || speed < 0 {
		speed = 0
	}
	q := math.Round(speed * scale)
	if q > math.MaxUint16 {
		return math.MaxUint16
	}
	return uint16(q)
}

func normalizeDir(dir float64) float64 {
	if math.IsNaN(dir) || math.IsInf(dir, 0) {
		return 0
	}
	dir = math.Mod(dir, 2*math.Pi)
	if dir < 0 {
		dir += 2 * math.Pi
	}
	return dir
}

func quantizeDir(dir float64) uint16 {
	return uint16(math.Round(normalizeDir(dir) / (2 * math.Pi) * 65535))
}

func decodeDir(q uint16) float64 {
	return float64(q) / 65535 * 2 * math.Pi
}

func dirDelta(a, b uint16) float64 {
	d := int32(a) - int32(b)
	if d < 0 {
		d = -d
	}
	if d > 32767 {
		d = 65535 - d
	}
	return float64(d) / 65535 * 2 * math.Pi
}

cd .local/checks/gs-practice-lab && gofmt -l ch07/map && go vet ./ch07/map/ && go test ./ch07/map/ -count=1 -run 'TestQuantize|TestEncoder|TestEncodeFrame'

ok  	gspractice/ch07/map	0.347s