《游戏服务端编程实践》7.3.2 区域广播算法实现

tick(moves):
    merged = merge_by_entity(moves)      # 同一实体只保留最后位置
    for entity in merged:
        oldCell = grid.cell(entity.pos)
        newCell = grid.cell(command.pos)
        apply(entity, command)
        if oldCell != newCell:
            emit leave(oldCell, entity)
            emit enter(newCell, entity)
        else if changed(entity):
            emit update(newCell, entity)
    stable_sort(events, type, entityID, cell)

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

package worldmap

import (
	"math"
	"sort"
)

type MoveCommand struct {
	Handle EntityHandle
	Pos    Vec2
	Dir    float64
	Speed  float64
}

type EventType uint8

const (
	EventLeave EventType = iota
	EventEnter
	EventUpdate
)

func (t EventType) String() string {
	switch t {
	case EventLeave:
		return "leave"
	case EventEnter:
		return "enter"
	case EventUpdate:
		return "update"
	default:
		return "unknown"
	}
}

// Event 是发给一个格子的区域事件，不是发给单个玩家的完整包。
type Event struct {
	Type   EventType
	Entity EntityID
	Cell   Cell
	From   Cell
	To     Cell
	Pos    Vec2
	Dir    float64
	Speed  float64
	Tick   uint64
}

type BroadcastConfig struct {
	// UpdateInterval 内，只有位移或转向超过阈值才补发 update。
	UpdateInterval uint64
	MoveEpsilon    float64
	DirEpsilon     float64
}

func DefaultBroadcastConfig() BroadcastConfig {
	return BroadcastConfig{UpdateInterval: 2, MoveEpsilon: 0.05, DirEpsilon: math.Pi / 180}
}

// Tick 先合并本帧所有移动，再统一应用并生成事件。
func (m *Map) Tick(moves []MoveCommand, cfg BroadcastConfig) []Event {
	m.tick++
	merged := make(map[EntityID]MoveCommand, len(moves))
	order := make([]EntityID, 0, len(moves))
	for _, mv := range moves {
		if _, err := m.entity(mv.Handle); err != nil {
			continue
		}
		if _, ok := merged[mv.Handle.ID]; !ok {
			order = append(order, mv.Handle.ID)
		}
		merged[mv.Handle.ID] = mv // 同一实体只保留最后一次位置
	}

	events := make([]Event, 0, len(merged)*2)
	for _, id := range order {
		mv := merged[id]
		st, err := m.entity(mv.Handle)
		if err != nil {
			continue
		}
		oldPos, oldDir, oldSpeed := st.Pos, st.Dir, st.Speed
		from := m.aoi.CellOf(oldPos)
		to := m.aoi.CellOf(mv.Pos)

		st.Pos, st.Dir, st.Speed = mv.Pos, mv.Dir, mv.Speed
		if from != to {
			m.aoi.Move(id, mv.Pos)
			events = append(events,
				Event{Type: EventLeave, Entity: id, Cell: from, From: from, To: to, Pos: oldPos, Dir: oldDir, Speed: oldSpeed, Tick: m.tick},
				Event{Type: EventEnter, Entity: id, Cell: to, From: from, To: to, Pos: mv.Pos, Dir: mv.Dir, Speed: mv.Speed, Tick: m.tick},
			)
			st.hasSent, st.lastSentTick, st.lastSentPos, st.lastSentDir = true, m.tick, mv.Pos, mv.Dir
			continue
		}
		if oldPos == mv.Pos && oldDir == mv.Dir && oldSpeed == mv.Speed {
			continue
		}
		if !shouldSendUpdate(st, cfg, m.tick) {
			continue
		}
		events = append(events, Event{Type: EventUpdate, Entity: id, Cell: to, From: from, To: to, Pos: mv.Pos, Dir: mv.Dir, Speed: mv.Speed, Tick: m.tick})
		st.hasSent, st.lastSentTick, st.lastSentPos, st.lastSentDir = true, m.tick, mv.Pos, mv.Dir
	}

	sort.SliceStable(events, func(i, j int) bool {
		if events[i].Type != events[j].Type {
			return events[i].Type < events[j].Type
		}
		if events[i].Entity != events[j].Entity {
			return events[i].Entity < events[j].Entity
		}
		return events[i].To.X < events[j].To.X
	})
	return events
}

func shouldSendUpdate(st *entityState, cfg BroadcastConfig, tick uint64) bool {
	if !st.hasSent {
		return true
	}
	if tick-st.lastSentTick >= cfg.UpdateInterval {
		return true
	}
	if st.Pos.Distance(st.lastSentPos) >= cfg.MoveEpsilon {
		return true
	}
	return math.Abs(st.Dir-st.lastSentDir) >= cfg.DirEpsilon
}

// CountByType 便于监控一帧事件构成。
func CountByType(events []Event) map[EventType]int {
	out := make(map[EventType]int, 3)
	for _, ev := range events {
		out[ev.Type]++
	}
	return out
}

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

ok  	gspractice/ch07/map	0.374s