《MMO 服务器开发》6.1 跨服报名与匹配

// snippet: 报名载荷 SignupReq 的字节布局（大端）
PlayerID(8) | ServerID(2) | BatchNo(4) | Score(4) | len(2) | Snapshot(len)
// 服号 ServerID 是关键：撮合结果要靠它找到「回哪条连接」。

// file: internal/crossserver/queue.go
// tier: L1
// verify: go test ./internal/crossserver/
package crossserver

import "sort"

// 一场对局的规模：两队、每队 3 人。
const (
	TeamSize       = 3
	PlayersPerBout = TeamSize * 2
)

// MatchMember 是撮合结果里的一个成员，带服号——通知要靠它找到「回哪条连接」。
type MatchMember struct {
	PlayerID uint64
	ServerID uint16
	TeamID   uint8
}

// MatchResult 一次撮合的产物。
type MatchResult struct {
	MatchID uint64
	Members []MatchMember
}

// MatchQueue 是跨服报名队列：按 BatchNo（赛事批次）分桶，
// 桶内按 Score 升序排列后「蛇形」分到两队，保证两队战力接近。
type MatchQueue struct{ buckets map[uint32][]SignupReq }

func NewMatchQueue() *MatchQueue { return &MatchQueue{buckets: make(map[uint32][]SignupReq)} }

func (q *MatchQueue) Enqueue(s SignupReq) { q.buckets[s.BatchNo] = append(q.buckets[s.BatchNo], s) }

// Pending 返回队列里还剩多少人。
func (q *MatchQueue) Pending() int {
	n := 0
	for _, l := range q.buckets {
		n += len(l)
	}
	return n
}

// Match 从任意一个够人的桶里取 PlayersPerBout 人。
// 桶内按分数升序后下标 0/2/4 归一队、1/3/5 归另一队，两队总分差最小。
func (q *MatchQueue) Match(matchID uint64) (MatchResult, bool) {
	for batch, list := range q.buckets {
		if len(list) < PlayersPerBout {
			continue
		}
		sort.SliceStable(list, func(i, j int) bool { return list[i].Score < list[j].Score })
		res := MatchResult{MatchID: matchID}
		for i, s := range list[:PlayersPerBout] {
			team := uint8(1)
			if i%2 == 1 {
				team = 2
			}
			res.Members = append(res.Members, MatchMember{PlayerID: s.PlayerID, ServerID: s.ServerID, TeamID: team})
		}
		q.buckets[batch] = list[PlayersPerBout:]
		return res, true
	}
	return MatchResult{}, false
}

// file: internal/crossserver/hub.go
// tier: L2
// verify: go test ./internal/crossserver/ -run TestCrossServerSignupAndMatch
package crossserver

import (
	"net"
	"sync"
)

// peer 包住一条母服连接，并给它配一把写锁。
// 同一连接的读与写可并发，但两次写绝不能并发——否则帧会交错。
type peer struct {
	c  net.Conn
	mu sync.Mutex
}

func (p *peer) write(f Frame) error {
	p.mu.Lock()
	defer p.mu.Unlock()
	return WriteFrame(p.c, f)
}

// Hub 是跨服中心：每个母服开一条 TCP 长连接接进来，报名经此汇总，
// 撮合结果沿「玩家报名时那条连接」推回各自的服。
type Hub struct {
	ln    net.Listener
	queue *MatchQueue

	mu       sync.Mutex
	conns    map[uint16]*peer // ServerID -> 该服的长连接
	nextID   uint64
	notified int

	wg   sync.WaitGroup
	done chan struct{}
}

func NewHub() (*Hub, error) {
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		return nil, err
	}
	return &Hub{ln: ln, queue: NewMatchQueue(), conns: make(map[uint16]*peer), done: make(chan struct{})}, nil
}

func (h *Hub) Addr() string { return h.ln.Addr().String() }

func (h *Hub) Serve() {
	for {
		c, err := h.ln.Accept()
		if err != nil {
			return
		}
		h.wg.Add(1)
		go h.handleConn(c)
	}
}

func (h *Hub) handleConn(c net.Conn) {
	p := &peer{c: c}
	defer c.Close()
	defer h.wg.Done()
	for {
		f, err := ReadFrame(c)
		if err != nil {
			return
		}
		if f.Cmd != CmdCrossSignupReq {
			continue
		}
		s, err := DecodeSignupReq(f.Payload)
		if err != nil {
			continue
		}
		h.register(s.ServerID, p)
		_ = p.write(Frame{Cmd: CmdCrossSignupResp, Seq: f.Seq, Flags: f.Flags}) // 报名受理
		h.enqueue(s)
	}
}

func (h *Hub) register(serverID uint16, p *peer) {
	h.mu.Lock()
	h.conns[serverID] = p
	h.mu.Unlock()
}

func (h *Hub) enqueue(s SignupReq) {
	h.mu.Lock()
	h.queue.Enqueue(s)
	h.mu.Unlock()
	h.tryMatch()
}

// tryMatch 尝试撮合一场；够人就沿各成员的服号把通知推回去。
func (h *Hub) tryMatch() {
	h.mu.Lock()
	defer h.mu.Unlock()
	res, ok := h.queue.Match(h.nextID + 1)
	if !ok {
		return
	}
	h.nextID++
	for _, m := range res.Members {
		p := h.conns[m.ServerID]
		if p == nil {
			continue // 该服连接已断，通知留给重连后补投（见 6.3 的对账）
		}
		n := MatchFoundNotify{MatchID: res.MatchID, PlayerID: m.PlayerID, ServerID: m.ServerID, TeamID: m.TeamID}
		if p.write(Frame{Cmd: CmdCrossMatchFoundNotify, Payload: n.Encode()}) == nil {
			h.notified++
		}
	}
}

// Notified 返回已成功推回母服的通知条数。
func (h *Hub) Notified() int {
	h.mu.Lock()
	defer h.mu.Unlock()
	return h.notified
}

func (h *Hub) Close() {
	close(h.done)
	_ = h.ln.Close()
	h.mu.Lock()
	for _, p := range h.conns {
		_ = p.c.Close()
	}
	h.mu.Unlock()
	h.wg.Wait()
}

=== RUN   TestCrossServerSignupAndMatch
--- PASS: TestCrossServerSignupAndMatch (0.02s)
=== RUN   TestNoMatchUntilQuorum
--- PASS: TestNoMatchUntilQuorum (0.16s)
=== RUN   TestPayloadRoundTrip
--- PASS: TestPayloadRoundTrip (0.00s)
ok  	aegis/internal/crossserver	1.692s