《游戏服务端编程实践》7.2.3 客户端与服务端同步路径

path_id      uint32   单调递增，用于丢弃旧包
map_version  uint16   与地图数据握手
start_tick   uint32   路径生效的服务器 tick
point_count  uint16   后续路点数量
each point   int16 x, int16 y, uint16 tick
crc32        uint32   覆盖以上字段

allowed  = maxSpeed × duration + tolerance
distance = hypot(to.x - from.x, to.y - from.y)
reject if distance > allowed

// file: ch07/path/syncpath.go
// tier: L1
// verify: go test ./ch07/path/

package path

import (
	"errors"
	"fmt"
	"math"
	"time"
)

var (
	ErrEmptyPath     = errors.New("syncpath: empty path")
	ErrBadDuration   = errors.New("syncpath: non-positive duration")
	ErrTooFast       = errors.New("syncpath: speed exceeds limit")
	ErrThroughWall   = errors.New("syncpath: segment crosses blocked cell")
	ErrDiscontinuous = errors.New("syncpath: segment endpoints do not match")
	ErrTimeOrder     = errors.New("syncpath: segment time out of order")
	ErrExpired       = errors.New("syncpath: path too old")
)

// Blocker 只回答地形是否阻挡；单位占位应在移动解算层单独处理，
// 否则两个玩家互相占格会把合法路径误判为穿墙。
type Blocker interface {
	Blocked(p Point) bool
}

// Segment 是一段匀速直线移动。服务端不接收“当前位置”，只接收
// 起点、终点、开始时间和持续时间，由服务端自行推导轨迹。
type Segment struct {
	From     Point
	To       Point
	Start    time.Time
	Duration time.Duration
}

type PathClaim struct {
	Tick     uint32
	SentAt   time.Time
	Segments []Segment
}

type Validator struct {
	blocker    Blocker
	maxSpeed   float64
	tolerance  float64
	maxAge     time.Duration
	sampleStep float64
	futureSkew time.Duration
}

func NewValidator(blocker Blocker, maxSpeed float64) *Validator {
	if maxSpeed <= 0 {
		maxSpeed = 8
	}
	return &Validator{
		blocker:    blocker,
		maxSpeed:   maxSpeed,
		tolerance:  0.75,
		maxAge:     2 * time.Second,
		sampleStep: 0.25,
		futureSkew: 500 * time.Millisecond,
	}
}

// Validate 返回整条路径的累计距离。任何一段超速、穿墙、时间倒退或
// 端点不连续都会整体拒绝，而不是只截断到出错的那一段。
func (v *Validator) Validate(claim PathClaim, now time.Time) (float64, error) {
	if len(claim.Segments) == 0 {
		return 0, ErrEmptyPath
	}
	if claim.SentAt.IsZero() {
		return 0, ErrTimeOrder
	}
	if now.Sub(claim.SentAt) > v.maxAge {
		return 0, ErrExpired
	}
	if claim.SentAt.After(now.Add(v.futureSkew)) {
		return 0, ErrTimeOrder
	}
	var total float64
	var prevTo Point
	var prevEnd time.Time
	for i, seg := range claim.Segments {
		if seg.Duration <= 0 {
			return 0, ErrBadDuration
		}
		if i == 0 {
			if v.blocker.Blocked(seg.From) {
				return 0, ErrThroughWall
			}
		} else {
			if seg.From != prevTo {
				return 0, ErrDiscontinuous
			}
			if !seg.Start.Equal(prevEnd) {
				return 0, ErrTimeOrder
			}
		}
		if seg.Start.Add(seg.Duration).After(now.Add(v.futureSkew)) {
			return 0, ErrTimeOrder
		}
		dist := math.Hypot(float64(seg.To.X-seg.From.X), float64(seg.To.Y-seg.From.Y))
		allowed := v.maxSpeed*seg.Duration.Seconds() + v.tolerance
		if dist > allowed {
			return 0, fmt.Errorf("%w: %.2f cells in %.2fs, allowed %.2f",
				ErrTooFast, dist, seg.Duration.Seconds(), allowed)
		}
		if v.crossesWall(seg.From, seg.To) {
			return 0, ErrThroughWall
		}
		total += dist
		prevTo = seg.To
		prevEnd = seg.Start.Add(seg.Duration)
	}
	return total, nil
}

func (v *Validator) crossesWall(from, to Point) bool {
	dist := math.Hypot(float64(to.X-from.X), float64(to.Y-from.Y))
	steps := int(math.Ceil(dist / v.sampleStep))
	if steps < 1 {
		steps = 1
	}
	for i := 0; i <= steps; i++ {
		t := float64(i) / float64(steps)
		p := Point{
			X: int(math.Round(float64(from.X) + (float64(to.X-from.X))*t)),
			Y: int(math.Round(float64(from.Y) + (float64(to.Y-from.Y))*t)),
		}
		if v.blocker.Blocked(p) {
			return true
		}
	}
	return false
}

cd .local/checks/gs-practice-lab && gofmt -l ch07/path && go vet ./ch07/path/ && go test ./ch07/path/ -count=1

ok  	gspractice/ch07/path	0.262s