《MMO 服务器开发》14.1 为什么不能只用一张表

CmdRankQueryReq 0x0901  客户端 -> 服务端
  boardType(1) | boardID(4, BE) | offset(2, BE) | limit(2, BE)

CmdRankQueryResp 0x0902 服务端 -> 客户端
  boardType(1) | boardID(4, BE) | total(4, BE) | myRank(4, BE) | count(2, BE)
  count × { playerID(8, BE) | score(8, BE) | nameLen(1) | name(nameLen) }

帧 = length(4) | cmd(2) | seq(4) | flags(1) | payload      // 固定头 11 字节
length = 7 + N，帧总长 = 11 + N，HeaderSize = 11

// file: internal/rank/naive.go
// tier: L1
// verify: go test ./internal/rank/ -run TestNaive -v

package rank

import "sort"

// Entry is one row on a leaderboard: a player and their score.
type Entry struct {
	PlayerID uint64
	Score    int64
}

// better reports whether a outranks b: higher score wins, and ties go to the
// smaller player id. The order must be total, otherwise ranks flicker between
// two players who happen to share a score.
func better(a, b Entry) bool {
	if a.Score != b.Score {
		return a.Score > b.Score
	}
	return a.PlayerID < b.PlayerID
}

// NaiveBoard answers every rank query by re-sorting the whole board. It is the
// "one table plus ORDER BY" model moved into memory: correct, and fine until
// the board grows or the query rate climbs.
type NaiveBoard struct {
	entries []Entry
	index   map[uint64]int
}

func NewNaiveBoard() *NaiveBoard {
	return &NaiveBoard{index: make(map[uint64]int)}
}

// Set inserts a player or overwrites their score.
func (b *NaiveBoard) Set(id uint64, score int64) {
	if i, ok := b.index[id]; ok {
		b.entries[i].Score = score
		return
	}
	b.index[id] = len(b.entries)
	b.entries = append(b.entries, Entry{PlayerID: id, Score: score})
}

func (b *NaiveBoard) sorted() []Entry {
	cp := make([]Entry, len(b.entries))
	copy(cp, b.entries)
	sort.Slice(cp, func(i, j int) bool { return better(cp[i], cp[j]) })
	return cp
}

// Rank returns the 1-based rank of id, or 0 if the player is not on the board.
// Cost is O(n log n) per call because it sorts from scratch every time.
func (b *NaiveBoard) Rank(id uint64) int {
	if _, ok := b.index[id]; !ok {
		return 0
	}
	for i, e := range b.sorted() {
		if e.PlayerID == id {
			return i + 1
		}
	}
	return 0
}

// Len reports how many players are on the board.
func (b *NaiveBoard) Len() int { return len(b.entries) }

// file: internal/rank/naive_test.go
// tier: L1
// verify: go test ./internal/rank/ -run TestNaive -v

package rank

import "testing"

func TestNaiveRankAndTieBreak(t *testing.T) {
	b := NewNaiveBoard()
	b.Set(7, 100)
	b.Set(3, 100) // same score: the smaller id outranks
	b.Set(9, 50)
	b.Set(1, 999)

	if got := b.Rank(1); got != 1 {
		t.Fatalf("rank(1)=%d want 1", got)
	}
	if got := b.Rank(3); got != 2 {
		t.Fatalf("rank(3)=%d want 2 (tie -> smaller id)", got)
	}
	if got := b.Rank(7); got != 3 {
		t.Fatalf("rank(7)=%d want 3", got)
	}
	if got := b.Rank(9); got != 4 {
		t.Fatalf("rank(9)=%d want 4", got)
	}
	if got := b.Rank(42); got != 0 {
		t.Fatalf("rank(absent)=%d want 0", got)
	}

	// An update moves the player. The naive board still answers correctly --
	// it just re-sorts on every call to do it.
	b.Set(9, 1000)
	if got := b.Rank(9); got != 1 {
		t.Fatalf("after update rank(9)=%d want 1", got)
	}
	if b.Len() != 4 {
		t.Fatalf("len=%d want 4", b.Len())
	}
}