《MMO 服务器开发》17.2 登录、移动与广播端到端

// snippet: internal/gateway/world.go（世界 goroutine 与事件分派）

// event 是投进世界邮箱的一条消息。所有世界状态变更都由世界 goroutine
// 串行消费这些事件完成，因此 World 内部无需任何锁。
type event struct {
	kind  eventKind
	sess  *Session
	frame proto.Frame
}

// World 是 aegis 的权威世界：一个 actor，所有消息进它的邮箱，单线程处理。
type World struct {
	cfg    Config
	ln     net.Listener
	router *Router
	sched  *Scheduler
	grid   *Grid

	inbox   chan event
	stopped chan struct{}
	wg      sync.WaitGroup

	// 以下状态只由世界 goroutine 读写。
	sessions map[uint64]*Session
	byName   map[string]*Session
	nextID   uint64
}

// run 是世界 goroutine：串行消费邮箱事件与定时任务，直到收到关停事件。
func (w *World) run() {
	defer w.wg.Done()
	defer close(w.stopped)
	ticker := time.NewTicker(w.cfg.Tick)
	defer ticker.Stop()
	for {
		select {
		case e := <-w.inbox:
			if e.kind == evShutdown {
				w.closeAll()
				return
			}
			w.handle(e)
		case now := <-ticker.C:
			w.sched.Run(now) // 心跳清扫等周期任务，也在同一个 goroutine 里跑
		}
	}
}

// handle 分派一条事件。它在世界 goroutine 里运行，可安全改状态。
func (w *World) handle(e event) {
	switch e.kind {
	case evConnect:
		w.onConnect(e.sess)
	case evFrame:
		w.router.Dispatch(e.sess, e.frame)
	case evDisconnect:
		w.onDisconnect(e.sess)
	}
}

// snippet: internal/gateway/world.go（权威移动与 AOI 广播）

// onMove 是权威移动的入口：先做速度校验，通过后再改状态并向 AOI 邻居广播。
func (w *World) onMove(s *Session, f proto.Frame) {
	if !s.inWorld {
		s.send(errorFrame(f.Seq, "move before enter world"))
		return
	}
	var req moveReq
	if err := json.Unmarshal(f.Payload, &req); err != nil {
		s.send(errorFrame(f.Seq, "bad move payload"))
		return
	}
	to := Vec3{X: req.X, Y: req.Y}
	now := time.Now()
	dt := now.Sub(s.lastMoveAt).Seconds()
	if s.lastMoveAt.IsZero() || dt < 0.02 {
		dt = 0.02 // 首个移动或同 tick 内连发，给 dt 一个下限，避免误判
	}
	if d := distance(s.Pos, to); d/dt > w.cfg.MaxSpeed {
		log.Printf("[world] #%d 移动被拒: %.2f 单位 / %.0f ms 超过 %.0f 单位/s",
			s.ID, d, dt*1000, w.cfg.MaxSpeed)
		s.send(errorFrame(f.Seq, "move rejected: speed"))
		return
	}
	from := s.Pos
	w.grid.Move(s, from, to)
	s.Pos = to
	s.lastMoveAt = now

	body, _ := json.Marshal(moveResp{OK: true, X: to.X, Y: to.Y})
	s.send(proto.Frame{Cmd: proto.CmdMoveResp, Seq: f.Seq, Payload: body})
	w.fanoutMove(s, from, to)
}

// fanoutMove 比较移动前后的可见集，只对「新进入」和「已离开」的实体发通知。
func (w *World) fanoutMove(s *Session, from, to Vec3) {
	oldN := w.neighborSet(from, s.ID)
	newN := w.neighborSet(to, s.ID)
	for id := range newN {
		if oldN[id] {
			continue
		}
		if other := w.sessions[id]; other != nil {
			other.send(aoiAddFrame(s)) // 对方开始能看见我
			s.send(aoiAddFrame(other)) // 我开始能看见对方
			w.metrics.AoiAdds.Add(2)
		}
	}
	for id := range oldN {
		if newN[id] {
			continue
		}
		if other := w.sessions[id]; other != nil {
			other.send(aoiRemoveFrame(s.ID))
			s.send(aoiRemoveFrame(id))
			w.metrics.AoiRemoves.Add(2)
		}
	}
}

// snippet: internal/gateway/world_test.go（核心 L2 断言节选）

// TestLoginMoveBroadcast 是本章的核心 L2 断言：三个客户端登录进世界后，
// 每个都能看到另外两个；其中一个走远后，其余收到它的 AOI 移除。
func TestLoginMoveBroadcast(t *testing.T) {
	w := startWorld(t, Config{MaxSpeed: 1e6, AOIRadius: 30})
	addr := w.Addr().String()

	clients := map[string]*tclient{}
	ids := map[string]uint64{}
	for _, name := range []string{"alpha", "beta", "gamma"} {
		c := dialT(t, addr)
		ids[name] = loginT(t, c, name)
		clients[name] = c
	}
	for _, name := range []string{"alpha", "beta", "gamma"} {
		enterT(t, clients[name])
	}

	// 每个客户端都应看到另外两个（去重后）。
	for _, name := range []string{"alpha", "beta", "gamma"} {
		seen := map[uint64]bool{}
		for _, f := range clients[name].collect(300 * time.Millisecond) {
			if f.Cmd != proto.CmdAoiAdd {
				continue
			}
			var e struct {
				ID uint64 `json:"id"`
			}
			_ = json.Unmarshal(f.Payload, &e)
			seen[e.ID] = true
		}
		if len(seen) != 2 {
			t.Fatalf("%s 可见 %d 个邻居，期望 2（ids=%v）", name, len(seen), ids)
		}
	}

	// gamma 跳到远处（超过 AOIRadius），alpha 与 beta 应收到它的 AOI 移除。
	clients["gamma"].call(proto.CmdMoveReq, mustJSONT(map[string]float64{"x": 500, "y": 0}), proto.CmdMoveResp)
	for _, name := range []string{"alpha", "beta"} {
		got := false
		for _, f := range clients[name].collect(300 * time.Millisecond) {
			if f.Cmd != proto.CmdAoiRemove {
				continue
			}
			var e struct {
				ID uint64 `json:"id"`
			}
			_ = json.Unmarshal(f.Payload, &e)
			if e.ID == ids["gamma"] {
				got = true
			}
		}
		if !got {
			t.Fatalf("%s 未收到 gamma(#%d) 的 AOI 移除", name, ids["gamma"])
		}
	}
}

$ ./bin/aegis -role=world   -listen 127.0.0.1:19002 -aoi-radius 30 &
$ ./bin/aegis -role=gateway -listen 127.0.0.1:19001 -upstream 127.0.0.1:19002 &
$ ./bin/bot -mode=smoke -addr 127.0.0.1:19001

[alpha] 登录应答 {"ok":true,"id":1,"name":"alpha"}
[beta] 登录应答 {"ok":true,"id":2,"name":"beta"}
[gamma] 登录应答 {"ok":true,"id":3,"name":"gamma"}
[alpha] 进入世界 (x=8.0)
[beta] 进入世界 (x=16.0)
[gamma] 进入世界 (x=24.0)
[alpha] 可见 2 个邻居: [beta gamma]
[beta] 可见 2 个邻居: [alpha gamma]
[gamma] 可见 2 个邻居: [alpha beta]
[alpha] 合法移动 -> MoveResp
[alpha] 瞬移到 x=9999 -> 被拒（ErrorNotify）
smoke OK

[world] #1 "alpha" 进入世界 (8.0, 0.0)
[world] #2 "beta" 进入世界 (16.0, 0.0)
[world] #3 "gamma" 进入世界 (24.0, 0.0)
[world] #1 移动被拒: 9990.90 单位 / 20 ms 超过 12 单位/s